Improve solution load performance (#11591)

Razor's language server does a lot of extra work to initialize that is
really no longer necessary, at least in Visual Studio. This pull request
is an attempt to remove a bunch of that extra work.

- In Visual Studio, no longer initialize the misc files project with
_all- of the `*.razor` and `*.cshtml` files in the workspace root path.
With the `IRazorProjectInfoDriver` in place, I believe this to be
unnecessary work. Note that I've left this behavior for VS Code for now,
but we might remove it later.
- If we *do* initialize the misc files project with all Razor files, add
a method to `IRazorProjectServer` to add all of the documents to the
`ProjectSnapshotManager` at once. Adding them one at a time results in a
ton of extra asynchrony that slows solution load down as each document
add hops around the thread pool.
- When `IRazorProjectService.OpenDocumentAsync(...)` is called, it first
attempts to add the open document to the misc files project. This is
because we might learn of an open document before the project system is
done loading. However, it first adds the document using a `TextLoader`
that loads the file off disk. Then, it updates the document with the
`SourceText` that was passed to `OpenDocumentAsync`. However, this
causes the file to be loaded so that its contents can be compared with
the new `SourceText`. To avoid this additional I/O, `OpenDocumentAsync`
will now add the document to the misc files project with the
`SourceText` rather than a `TextLoader`.
- Don't create `DocumentSnapshot` instances unnecessarily when checking
to see if a project contains a document file path.

In addition, I've refactored all of the `IFileChangeDetector` and
`IRazorFileChangeListener` abstractions into the singleton,
`WorkspaceRootPathWatcher`. There was only a single implementation of
each, so they really don't have a lot of value. I've similar unified a
bunch of relevant tests.

CI Build:
https://dev.azure.com/dnceng/internal/_build/results?buildId=2656343&view=results
VS Test Insertion:
https://dev.azure.com/devdiv/DevDiv/_git/VS/pullrequest/616458

Author: DustinCampbell

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

@@ -42,4 +42,6 @@ internal class DefaultLanguageServerFeatureOptions : LanguageServerFeatureOption
     public override bool SupportsSoftSelectionInCompletion => true;
 
     public override bool UseVsCodeCompletionTriggerCharacters => false;
+
+    public override bool DoNotInitializeMiscFilesProjectFromWorkspace => false;
 }

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

@@ -214,11 +214,8 @@ public static void AddDocumentManagementServices(this IServiceCollection service
         services.AddSingleton<IRazorStartupService, OpenDocumentGenerator>();
         services.AddSingleton<IDocumentMappingService, LspDocumentMappingService>();
         services.AddSingleton<IEditMappingService, LspEditMappingService>();
-        services.AddSingleton<RazorFileChangeDetectorManager>();
-        services.AddSingleton<IOnInitialized>(sp => sp.GetRequiredService<RazorFileChangeDetectorManager>());
-
-        services.AddSingleton<IRazorFileChangeListener, RazorFileSynchronizer>();
-        services.AddSingleton<IFileChangeDetector, RazorFileChangeDetector>();
+        services.AddSingleton<WorkspaceRootPathWatcher>();
+        services.AddSingleton<IOnInitialized>(sp => sp.GetRequiredService<WorkspaceRootPathWatcher>());
 
         // Document processed listeners
         if (!featureOptions.SingleServerSupport)

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

@@ -23,6 +23,7 @@ internal class ConfigurableLanguageServerFeatureOptions : LanguageServerFeatureO
     private readonly bool? _useRazorCohostServer;
     private readonly bool? _forceRuntimeCodeGeneration;
     private readonly bool? _useNewFormattingEngine;
+    private readonly bool? _doNotInitializeMiscFilesProjectFromWorkspace;
 
     public override bool SupportsFileManipulation => _supportsFileManipulation ?? _defaults.SupportsFileManipulation;
     public override string CSharpVirtualDocumentSuffix => _csharpVirtualDocumentSuffix ?? DefaultLanguageServerFeatureOptions.DefaultCSharpVirtualDocumentSuffix;
@@ -40,6 +41,12 @@ internal class ConfigurableLanguageServerFeatureOptions : LanguageServerFeatureO
     public override bool SupportsSoftSelectionInCompletion => false;
     public override bool UseVsCodeCompletionTriggerCharacters => true;
 
+    // Note: This option is defined in the negative because the default behavior should be to add documents to misc files project
+    // when the language server is initialized. Adding the option at the command-line should disable that behavior.
+    //
+    // This is a temporary option and should be removed as part of https://github.com/dotnet/razor/issues/11594.
+    public override bool DoNotInitializeMiscFilesProjectFromWorkspace => _doNotInitializeMiscFilesProjectFromWorkspace ?? _defaults.DoNotInitializeMiscFilesProjectFromWorkspace;
+
     public ConfigurableLanguageServerFeatureOptions(string[] args)
     {
         for (var i = 0; i < args.Length; i++)
@@ -62,6 +69,7 @@ public ConfigurableLanguageServerFeatureOptions(string[] args)
             TryProcessBoolOption(nameof(UseRazorCohostServer), ref _useRazorCohostServer, option, args, i);
             TryProcessBoolOption(nameof(ForceRuntimeCodeGeneration), ref _forceRuntimeCodeGeneration, option, args, i);
             TryProcessBoolOption(nameof(UseNewFormattingEngine), ref _useNewFormattingEngine, option, args, i);
+            TryProcessBoolOption(nameof(DoNotInitializeMiscFilesProjectFromWorkspace), ref _doNotInitializeMiscFilesProjectFromWorkspace, option, args, i);
         }
     }
 

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

@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.AspNetCore.Razor.PooledObjects;
+using Microsoft.AspNetCore.Razor.ProjectSystem;
 using Microsoft.AspNetCore.Razor.Utilities;
 using Microsoft.CodeAnalysis.Razor;
 using Microsoft.CodeAnalysis.Razor.Logging;
@@ -26,7 +27,7 @@ public static ImmutableArray<ProjectSnapshot> FindPotentialProjects(this Project
         foreach (var project in projectManager.GetProjects())
         {
             // Always exclude the miscellaneous project.
-            if (project.FilePath == MiscFilesProject.FilePath)
+            if (project.IsMiscellaneousProject())
             {
                 continue;
             }
@@ -69,6 +70,21 @@ public static bool TryResolveAllProjects(
         return projects.Length > 0;
     }
 
+    public static bool TryFindContainingProject(this ProjectSnapshotManager projectManager, string documentFilePath, out ProjectKey projectKey)
+    {
+        foreach (var project in projectManager.GetProjects())
+        {
+            if (project.ContainsDocument(documentFilePath))
+            {
+                projectKey = project.Key;
+                return true;
+            }
+        }
+
+        projectKey = default;
+        return false;
+    }
+
     public static bool TryResolveDocumentInAnyProject(
         this ProjectSnapshotManager projectManager,
         string documentFilePath,

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

@@ -13,6 +13,7 @@ namespace Microsoft.AspNetCore.Razor.LanguageServer.ProjectSystem;
 
 internal interface IRazorProjectService
 {
+    Task AddDocumentsToMiscProjectAsync(ImmutableArray<string> filePaths, CancellationToken cancellationToken);
     Task AddDocumentToMiscProjectAsync(string filePath, CancellationToken cancellationToken);
     Task OpenDocumentAsync(string filePath, SourceText sourceText, CancellationToken cancellationToken);
     Task UpdateDocumentAsync(string filePath, SourceText sourceText, CancellationToken cancellationToken);

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

@@ -139,41 +139,89 @@ await AddOrUpdateProjectCoreAsync(
             .ConfigureAwait(false);
     }
 
+    public async Task AddDocumentsToMiscProjectAsync(ImmutableArray<string> filePaths, CancellationToken cancellationToken)
+    {
+        await WaitForInitializationAsync().ConfigureAwait(false);
+
+        await _projectManager
+            .UpdateAsync(
+                (updater, cancellationToken) =>
+                {
+                    var projects = _projectManager.GetProjects();
+
+                    // For each file, check to see if it's already in a project.
+                    // If it is, we don't want to add it to the misc project.
+                    foreach (var filePath in filePaths)
+                    {
+                        var add = true;
+
+                        foreach (var project in projects)
+                        {
+                            if (project.ContainsDocument(filePath))
+                            {
+                                // The file is already in a project, so we shouldn't add it to the misc project.
+                                add = false;
+                                break;
+                            }
+                        }
+
+                        if (cancellationToken.IsCancellationRequested)
+                        {
+                            break;
+                        }
+
+                        if (add)
+                        {
+                            AddDocumentToMiscProjectCore(updater, filePath);
+                        }
+                    }
+                },
+                state: cancellationToken,
+                cancellationToken)
+            .ConfigureAwait(false);
+    }
+
     public async Task AddDocumentToMiscProjectAsync(string filePath, CancellationToken cancellationToken)
     {
         await WaitForInitializationAsync().ConfigureAwait(false);
 
         await _projectManager
             .UpdateAsync(
-                updater: AddDocumentToMiscProjectCore,
-                state: filePath,
+                updater =>
+                {
+                    if (!_projectManager.TryFindContainingProject(filePath, out _))
+                    {
+                        AddDocumentToMiscProjectCore(updater, filePath);
+                    }
+                },
                 cancellationToken)
             .ConfigureAwait(false);
     }
 
-    private void AddDocumentToMiscProjectCore(ProjectSnapshotManager.Updater updater, string filePath)
+    private void AddDocumentToMiscProjectCore(ProjectSnapshotManager.Updater updater, string filePath, SourceText? sourceText = null)
     {
-        var textDocumentPath = FilePathNormalizer.Normalize(filePath);
-        _logger.LogDebug($"Asked to add {textDocumentPath} to the miscellaneous files project, because we don't have project info (yet?)");
+        Debug.Assert(
+            !_projectManager.TryFindContainingProject(filePath, out _),
+            $"File already belongs to a project and can't be added to the misc files project");
 
-        if (_projectManager.TryResolveDocumentInAnyProject(textDocumentPath, _logger, out var document))
-        {
-            // Already in a known project, so we don't want it in the misc files project
-            _logger.LogDebug($"File {textDocumentPath} is already in {document.Project.Key}, so we're not adding it to the miscellaneous files project");
-            return;
-        }
+        _logger.LogInformation($"Adding document '{filePath}' to miscellaneous files project.");
 
         var miscFilesProject = _projectManager.GetMiscellaneousProject();
+        var textDocumentPath = FilePathNormalizer.Normalize(filePath);
 
         // Representing all of our host documents with a re-normalized target path to workaround GetRelatedDocument limitations.
         var normalizedTargetFilePath = textDocumentPath.Replace('/', '\\').TrimStart('\\');
 
         var hostDocument = new HostDocument(textDocumentPath, normalizedTargetFilePath);
-        var textLoader = _remoteTextLoaderFactory.Create(textDocumentPath);
 
-        _logger.LogInformation($"Adding document '{textDocumentPath}' to project '{miscFilesProject.Key}'.");
-
-        updater.AddDocument(miscFilesProject.Key, hostDocument, textLoader);
+        if (sourceText is not null)
+        {
+            updater.AddDocument(miscFilesProject.Key, hostDocument, sourceText);
+        }
+        else
+        {
+            updater.AddDocument(miscFilesProject.Key, hostDocument, _remoteTextLoaderFactory.Create(textDocumentPath));
+        }
     }
 
     public async Task OpenDocumentAsync(string filePath, SourceText sourceText, CancellationToken cancellationToken)
@@ -183,17 +231,15 @@ public async Task OpenDocumentAsync(string filePath, SourceText sourceText, Canc
         await _projectManager.UpdateAsync(
             updater =>
             {
-                var textDocumentPath = FilePathNormalizer.Normalize(filePath);
-
                 // We are okay to use the non-project-key overload of TryResolveDocument here because we really are just checking if the document
                 // has been added to _any_ project. AddDocument will take care of adding to all of the necessary ones, and then below we ensure
                 // we process them all too
-                if (!_projectManager.TryResolveDocumentInAnyProject(textDocumentPath, _logger, out var document))
+                if (!_projectManager.TryFindContainingProject(filePath, out _))
                 {
                     // Document hasn't been added. This usually occurs when VSCode trumps all other initialization
                     // processes and pre-initializes already open documents. We add this to the misc project, and
                     // if/when we get project info from the client, it will be migrated to a real project.
-                    AddDocumentToMiscProjectCore(updater, filePath);
+                    AddDocumentToMiscProjectCore(updater, filePath, sourceText);
                 }
 
                 ActOnDocumentInMultipleProjects(