No more project.razor.bin files (in VS, at least) (#10475)

This is a pretty substantial pull request, so I'm getting it out there
for review. I have not fully tested the change with VS Code, but Visual
Studio is working ok.

This change completely refreshes all of the machinery around how
`RazorProjectInfo` instances are passed from the Razor language client
to the Razor language server. This is generally a complicated process
with a lot of potential for reliability issues. The language client is
expected to serialize a `RazorProjectInfo` instance representing a
project update to a known location within the project's folder on disk.
The language server watches for writes to that file (the dreaded
`project.razor.bin` file, deserializes it and updates the server's
project system.

Here's how things work after this change:

- There is a new `IRazorProjectInfoDriver` abstraction that is
optionally passed into `RazorLanguageServer` when it is created.
- The language server connects an `IRazorProjectInfoListener` to the
driver and is notified of project updates and removes. For an update,
the listener is provided a `RazorProjectInfo` instance. For a remove,
it's just given a `ProjectKey`.
- In the language server, `RazorProjectService` provides the
`IRazorProjectInfoListener` implementation. This results in a much
simpler system with less machinery, allowing several "file detectors"
and "state syncrhronizers" to be deleted.
- For Visual Studio, an `IRazorProjectInfoDriver` is provided to the
language server performs no serialization/deserialization of
`RazorProjectInfo` instances. Instead, the language client and server
just shared the same `RazorProjectInfo` instances. I'm expecting this to
lead to performance and memory allocation wins.
- For Visual Studio Code, no `IRazorProjectInfoDriver` implementation is
provided. So, the language server falls back to a special
`FileWatcherBasedRazorProjectInfoDriver` implementation that watches the
workspace folder. The `RazorWorkspaceListener` in
`ExernalAcess.RoslynWorkspace` still serializes `RazorProjectInfo`
instances for VS Code. So, that should work as it did before, though I
still need to test it. (I'd happily accept any help on this.)

Significant deletions from the language server in this change:

- `ProjectConfigurationFileChangeDetector`
- `ProjectConfigurationFileChangeEventArgs`
- `ProjectConfigurationStateSynchronizer`
- `MonitorProjectConfigurationFilePathEndpoint`
- `ProjectConfigurationStateManager`
- `ProjectInfoEndpoint`
- `RazorProjectInfoDeserializer`

Significant deletions from VS in this change:

- `ProejctConfigurationFilePathChangedEventsArgs`
- `ProjectConfigurationFilePathStore`
- `RazorProjectInfoEndpointPublisher`
- `RazorProjectInfoFileSerializer`
- `RazorProjectInfoPublisher`

Razor-CI for PR Validation:
https://dev.azure.com/dnceng/internal/_build/results?buildId=2473027&view=results

Author: DustinCampbell

src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorLanguageServerBenchmarkBase.cs

@@ -35,7 +35,7 @@ public RazorLanguageServerBenchmarkBase()
             serverStream,
             razorLoggerFactory,
             NoOpTelemetryReporter.Instance,
-            configure: (collection) =>
+            configureServices: (collection) =>
             {
                 collection.AddSingleton<IOnInitialized, NoopClientNotifierService>();
                 collection.AddSingleton<IClientConnection, NoopClientNotifierService>();

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/CapabilitiesManager.cs

@@ -2,19 +2,26 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor.Threading;
+using Microsoft.CodeAnalysis.Razor;
 using Microsoft.CodeAnalysis.Razor.Protocol;
 using Microsoft.CodeAnalysis.Razor.Workspaces;
 using Microsoft.CommonLanguageServerProtocol.Framework;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
+using Microsoft.VisualStudio.RpcContracts.Settings;
+using Microsoft.VisualStudio.Threading;
 
 namespace Microsoft.AspNetCore.Razor.LanguageServer;
 
-internal class CapabilitiesManager : IInitializeManager<InitializeParams, InitializeResult>, IClientCapabilitiesService
+internal sealed class CapabilitiesManager : IInitializeManager<InitializeParams, InitializeResult>, IClientCapabilitiesService, IWorkspaceRootPathProvider
 {
-    private InitializeParams? _initializeParams;
     private readonly ILspServices _lspServices;
+    private readonly TaskCompletionSource<InitializeParams> _initializeParamsTaskSource;
+    private readonly AsyncLazy<string> _lazyRootPath;
 
-    public bool HasInitialized => _initializeParams is not null;
+    public bool HasInitialized => _initializeParamsTaskSource.Task.IsCompleted;
 
     public bool CanGetClientCapabilities => HasInitialized;
 
@@ -23,16 +30,17 @@ internal class CapabilitiesManager : IInitializeManager<InitializeParams, Initia
     public CapabilitiesManager(ILspServices lspServices)
     {
         _lspServices = lspServices;
+
+        _initializeParamsTaskSource = new();
+
+#pragma warning disable VSTHRD012 // Provide JoinableTaskFactory where allowed
+        _lazyRootPath = new(ComputeRootPathAsync);
+#pragma warning restore VSTHRD012
     }
 
     public InitializeParams GetInitializeParams()
     {
-        if (_initializeParams is null)
-        {
-            throw new InvalidOperationException($"{nameof(GetInitializeParams)} was called before '{Methods.InitializeName}'");
-        }
-
-        return _initializeParams;
+        return _initializeParamsTaskSource.Task.VerifyCompleted();
     }
 
     public InitializeResult GetInitializeResult()
@@ -49,16 +57,40 @@ public InitializeResult GetInitializeResult()
             provider.ApplyCapabilities(serverCapabilities, vsClientCapabilities);
         }
 
-        var initializeResult = new InitializeResult
+        return new InitializeResult
         {
             Capabilities = serverCapabilities,
         };
-
-        return initializeResult;
     }
 
     public void SetInitializeParams(InitializeParams request)
     {
-        _initializeParams = request;
+        if (_initializeParamsTaskSource.Task.IsCompleted)
+        {
+            throw new InvalidOperationException($"{nameof(SetInitializeParams)} already called.");
+        }
+
+        _initializeParamsTaskSource.TrySetResult(request);
+    }
+
+    private async Task<string> ComputeRootPathAsync()
+    {
+#pragma warning disable VSTHRD003 // Avoid awaiting foreign Tasks
+        var initializeParams = await _initializeParamsTaskSource.Task.ConfigureAwaitRunInline();
+#pragma warning restore VSTHRD003 // Avoid awaiting foreign Tasks
+
+        if (initializeParams.RootUri is Uri rootUri)
+        {
+            return rootUri.GetAbsoluteOrUNCPath();
+        }
+
+        // RootUri was added in LSP3, fall back to RootPath
+
+#pragma warning disable CS0618 // Type or member is obsolete
+        return initializeParams.RootPath.AssumeNotNull();
+#pragma warning restore CS0618 // Type or member is obsolete
     }
+
+    public Task<string> GetRootPathAsync(CancellationToken cancellationToken)
+        => _lazyRootPath.GetValueAsync(cancellationToken);
 }

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/DefaultLanguageServerFeatureOptions.cs

@@ -38,13 +38,9 @@ public override bool ReturnCodeActionAndRenamePathsWithPrefixedSlash
 
     public override bool UsePreciseSemanticTokenRanges => false;
 
-    public override bool MonitorWorkspaceFolderForConfigurationFiles => true;
-
     public override bool UseRazorCohostServer => false;
 
     public override bool DisableRazorLanguageServer => false;
 
     public override bool ForceRuntimeCodeGeneration => false;
-
-    public override bool UseProjectConfigurationEndpoint => false;
 }

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/DefaultWorkspaceDirectoryPathResolver.cs

@@ -83,6 +83,11 @@ protected RazorDiagnosticsPublisher(
 
     public void Dispose()
     {
+        if (_disposeTokenSource.IsCancellationRequested)
+        {
+            return;
+        }
+
         _disposeTokenSource.Cancel();
         _disposeTokenSource.Dispose();
     }

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Diagnostics/RazorDiagnosticsPublisher.cs

@@ -26,7 +26,6 @@
 using Microsoft.CodeAnalysis.Razor.ProjectSystem;
 using Microsoft.CodeAnalysis.Razor.Protocol;
 using Microsoft.CodeAnalysis.Razor.SemanticTokens;
-using Microsoft.CodeAnalysis.Razor.Serialization;
 using Microsoft.CodeAnalysis.Razor.Workspaces;
 using Microsoft.CommonLanguageServerProtocol.Framework;
 using Microsoft.Extensions.DependencyInjection;
@@ -48,6 +47,7 @@ public static void AddLifeCycleServices(this IServiceCollection services, RazorL
         services.AddSingleton<CapabilitiesManager>();
         services.AddSingleton<IInitializeManager<InitializeParams, InitializeResult>, CapabilitiesManager>(sp => sp.GetRequiredService<CapabilitiesManager>());
         services.AddSingleton<IClientCapabilitiesService>(sp => sp.GetRequiredService<CapabilitiesManager>());
+        services.AddSingleton<IWorkspaceRootPathProvider>(sp => sp.GetRequiredService<CapabilitiesManager>());
         services.AddSingleton<AbstractRequestContextFactory<RazorRequestContext>, RazorRequestContextFactory>();
 
         services.AddSingleton<ICapabilitiesProvider, RazorLanguageServerCapability>();
@@ -211,31 +211,13 @@ public static void AddDocumentManagementServices(this IServiceCollection service
 
         services.AddSingleton<RemoteTextLoaderFactory, DefaultRemoteTextLoaderFactory>();
         services.AddSingleton<IRazorProjectService, RazorProjectService>();
+        services.AddSingleton<IRazorStartupService>((services) => (RazorProjectService)services.GetRequiredService<IRazorProjectService>());
         services.AddSingleton<IRazorStartupService, OpenDocumentGenerator>();
         services.AddSingleton<IRazorDocumentMappingService, RazorDocumentMappingService>();
         services.AddSingleton<RazorFileChangeDetectorManager>();
         services.AddSingleton<IOnInitialized>(sp => sp.GetRequiredService<RazorFileChangeDetectorManager>());
 
-        if (featureOptions.UseProjectConfigurationEndpoint)
-        {
-            services.AddSingleton<IRazorProjectInfoFileSerializer, RazorProjectInfoFileSerializer>();
-            services.AddSingleton<ProjectConfigurationStateManager>();
-        }
-        else 
-        {
-            services.AddSingleton<IProjectConfigurationFileChangeListener, ProjectConfigurationStateSynchronizer>();
-        }
-
         services.AddSingleton<IRazorFileChangeListener, RazorFileSynchronizer>();
-
-        // If we're not monitoring the whole workspace folder for configuration changes, then we don't actually need the the file change
-        // detector wired up via DI, as the razor/monitorProjectConfigurationFilePath endpoint will directly construct one. This means
-        // it can be a little simpler, and doesn't need to worry about which folders it's told to listen to.
-        if (featureOptions.MonitorWorkspaceFolderForConfigurationFiles)
-        {
-            services.AddSingleton<IFileChangeDetector, ProjectConfigurationFileChangeDetector>();
-        }
-
         services.AddSingleton<IFileChangeDetector, RazorFileChangeDetector>();
 
         // Document processed listeners

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Extensions/IServiceCollectionExtensions.cs

@@ -22,11 +22,9 @@ internal class ConfigurableLanguageServerFeatureOptions : LanguageServerFeatureO
     private readonly bool? _usePreciseSemanticTokenRanges;
     private readonly bool? _updateBuffersForClosedDocuments;
     private readonly bool? _includeProjectKeyInGeneratedFilePath;
-    private readonly bool? _monitorWorkspaceFolderForConfigurationFiles;
     private readonly bool? _useRazorCohostServer;
     private readonly bool? _disableRazorLanguageServer;
     private readonly bool? _forceRuntimeCodeGeneration;
-    private readonly bool? _useProjectConfigurationEndpoint;
 
     public override bool SupportsFileManipulation => _supportsFileManipulation ?? _defaults.SupportsFileManipulation;
     public override string ProjectConfigurationFileName => _projectConfigurationFileName ?? _defaults.ProjectConfigurationFileName;
@@ -40,11 +38,9 @@ internal class ConfigurableLanguageServerFeatureOptions : LanguageServerFeatureO
     public override bool UsePreciseSemanticTokenRanges => _usePreciseSemanticTokenRanges ?? _defaults.UsePreciseSemanticTokenRanges;
     public override bool UpdateBuffersForClosedDocuments => _updateBuffersForClosedDocuments ?? _defaults.UpdateBuffersForClosedDocuments;
     public override bool IncludeProjectKeyInGeneratedFilePath => _includeProjectKeyInGeneratedFilePath ?? _defaults.IncludeProjectKeyInGeneratedFilePath;
-    public override bool MonitorWorkspaceFolderForConfigurationFiles => _monitorWorkspaceFolderForConfigurationFiles ?? _defaults.MonitorWorkspaceFolderForConfigurationFiles;
     public override bool UseRazorCohostServer => _useRazorCohostServer ?? _defaults.UseRazorCohostServer;
     public override bool DisableRazorLanguageServer => _disableRazorLanguageServer ?? _defaults.DisableRazorLanguageServer;
     public override bool ForceRuntimeCodeGeneration => _forceRuntimeCodeGeneration ?? _defaults.ForceRuntimeCodeGeneration;
-    public override bool UseProjectConfigurationEndpoint => _useProjectConfigurationEndpoint ?? _defaults.UseProjectConfigurationEndpoint;
 
     public ConfigurableLanguageServerFeatureOptions(string[] args)
     {
@@ -67,11 +63,9 @@ public ConfigurableLanguageServerFeatureOptions(string[] args)
             TryProcessBoolOption(nameof(UsePreciseSemanticTokenRanges), ref _usePreciseSemanticTokenRanges, option, args, i);
             TryProcessBoolOption(nameof(UpdateBuffersForClosedDocuments), ref _updateBuffersForClosedDocuments, option, args, i);
             TryProcessBoolOption(nameof(IncludeProjectKeyInGeneratedFilePath), ref _includeProjectKeyInGeneratedFilePath, option, args, i);
-            TryProcessBoolOption(nameof(MonitorWorkspaceFolderForConfigurationFiles), ref _monitorWorkspaceFolderForConfigurationFiles, option, args, i);
             TryProcessBoolOption(nameof(UseRazorCohostServer), ref _useRazorCohostServer, option, args, i);
             TryProcessBoolOption(nameof(DisableRazorLanguageServer), ref _disableRazorLanguageServer, option, args, i);
             TryProcessBoolOption(nameof(ForceRuntimeCodeGeneration), ref _forceRuntimeCodeGeneration, option, args, i);
-            TryProcessBoolOption(nameof(UseProjectConfigurationEndpoint), ref _useProjectConfigurationEndpoint, option, args, i);
         }
     }
 

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Hosting/ConfigurableLanguageServerFeatureOptions.cs

@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Razor.Telemetry;
 using Microsoft.CodeAnalysis.Razor.Logging;
+using Microsoft.CodeAnalysis.Razor.ProjectSystem;
 using Microsoft.CodeAnalysis.Razor.Workspaces;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -42,10 +43,11 @@ public static RazorLanguageServerHost Create(
         Stream output,
         ILoggerFactory loggerFactory,
         ITelemetryReporter telemetryReporter,
-        Action<IServiceCollection>? configure = null,
+        Action<IServiceCollection>? configureServices = null,
         LanguageServerFeatureOptions? featureOptions = null,
         RazorLSPOptions? razorLSPOptions = null,
         ILspServerActivationTracker? lspServerActivationTracker = null,
+        IRazorProjectInfoDriver? projectInfoDriver = null,
         TraceSource? traceSource = null)
     {
         var (jsonRpc, jsonSerializer) = CreateJsonRpc(input, output);
@@ -61,9 +63,10 @@ public static RazorLanguageServerHost Create(
             jsonSerializer,
             loggerFactory,
             featureOptions,
-            configure,
+            configureServices,
             razorLSPOptions,
             lspServerActivationTracker,
+            projectInfoDriver,
             telemetryReporter);
 
         var host = new RazorLanguageServerHost(server);

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Hosting/RazorLanguageServerHost.cs

@@ -1,9 +1,12 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
+using System.Threading;
+using System.Threading.Tasks;
+
 namespace Microsoft.AspNetCore.Razor.LanguageServer;
 
-internal interface IProjectConfigurationFileChangeListener
+internal interface IWorkspaceRootPathProvider
 {
-    void ProjectConfigurationFileChanged(ProjectConfigurationFileChangeEventArgs args);
+    Task<string> GetRootPathAsync(CancellationToken cancellationToken);
 }

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/IProjectFileChangeListener.cs

@@ -57,6 +57,11 @@ public OpenDocumentGenerator(
 
     public void Dispose()
     {
+        if (_disposeTokenSource.IsCancellationRequested)
+        {
+            return;
+        }
+
         _disposeTokenSource.Cancel();
         _disposeTokenSource.Dispose();
     }