Remove ProjectSnapshotManagerDispatcher from all "document processed listeners" (#10276)

This is a more significant change that removes usage of
`ProjectSnapshotManagerDispatcher` from all "document processed
listeners". As part of this work, I've re-worked the
`RazorDiagnosticsPublisher` to use an `AsyncBatchingWorkQueue` and
`Task.Delay` rather than a pair of timers. The result is a much simpler
for implementation of `RazorDiagnosticsPublisher`.

Author: DustinCampbell

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

@@ -8,31 +8,31 @@
 
 namespace Microsoft.AspNetCore.Razor.LanguageServer;
 
-internal class CodeDocumentReferenceHolder : DocumentProcessedListener
+internal class CodeDocumentReferenceHolder : IDocumentProcessedListener
 {
-    private Dictionary<DocumentKey, RazorCodeDocument> _codeDocumentCache;
-    private IProjectSnapshotManager? _projectManager;
+    private readonly IProjectSnapshotManager _projectManager;
+    private readonly Dictionary<DocumentKey, RazorCodeDocument> _codeDocumentCache;
 
-    public CodeDocumentReferenceHolder()
+    public CodeDocumentReferenceHolder(IProjectSnapshotManager projectManager)
     {
-        _codeDocumentCache = new();
+        _projectManager = projectManager;
+        _codeDocumentCache = [];
+
+        _projectManager.Changed += ProjectManager_Changed;
     }
 
-    public override void DocumentProcessed(RazorCodeDocument codeDocument, IDocumentSnapshot documentSnapshot)
+    public void DocumentProcessed(RazorCodeDocument codeDocument, IDocumentSnapshot documentSnapshot)
     {
         // We capture a reference to the code document after a document has been processed in order to ensure that
         // latest document state information is readily available without re-computation. The DocumentState type
         // (brains of DocumentSnapshot) will garbage collect its generated output aggressively and due to the
         // nature of LSP being heavily asynchronous (multiple requests for single keystrokes) we don't want to cause
         // multiple parses/regenerations across LSP requests that are all for the same document version.
-        var key = new DocumentKey(documentSnapshot.Project.Key, documentSnapshot.FilePath.AssumeNotNull());
-        _codeDocumentCache[key] = codeDocument;
-    }
-
-    public override void Initialize(IProjectSnapshotManager projectManager)
-    {
-        _projectManager = projectManager;
-        _projectManager.Changed += ProjectManager_Changed;
+        lock (_codeDocumentCache)
+        {
+            var key = new DocumentKey(documentSnapshot.Project.Key, documentSnapshot.FilePath.AssumeNotNull());
+            _codeDocumentCache[key] = codeDocument;
+        }
     }
 
     private void ProjectManager_Changed(object? sender, ProjectChangeEventArgs args)
@@ -45,26 +45,38 @@ private void ProjectManager_Changed(object? sender, ProjectChangeEventArgs args)
             case ProjectChangeKind.ProjectChanged:
                 foreach (var documentFilePath in args.Newer!.DocumentFilePaths)
                 {
-                    var key = new DocumentKey(args.Newer.Key, documentFilePath);
-                    _codeDocumentCache.Remove(key);
+                    lock (_codeDocumentCache)
+                    {
+                        var key = new DocumentKey(args.Newer.Key, documentFilePath);
+                        _codeDocumentCache.Remove(key);
+                    }
                 }
 
                 break;
+
             case ProjectChangeKind.ProjectRemoved:
                 foreach (var documentFilePath in args.Older!.DocumentFilePaths)
                 {
-                    var key = new DocumentKey(args.Older.Key, documentFilePath);
-                    _codeDocumentCache.Remove(key);
+                    lock (_codeDocumentCache)
+                    {
+                        var key = new DocumentKey(args.Older.Key, documentFilePath);
+                        _codeDocumentCache.Remove(key);
+                    }
                 }
 
                 break;
+
             case ProjectChangeKind.DocumentChanged:
             case ProjectChangeKind.DocumentRemoved:
                 {
-                    var key = new DocumentKey(args.ProjectKey, args.DocumentFilePath.AssumeNotNull());
-                    _codeDocumentCache.Remove(key);
-                    break;
+                    lock (_codeDocumentCache)
+                    {
+                        var key = new DocumentKey(args.ProjectKey, args.DocumentFilePath.AssumeNotNull());
+                        _codeDocumentCache.Remove(key);
+                    }
                 }
+
+                break;
         }
     }
 }

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

@@ -0,0 +1,34 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis.Razor;
+using Microsoft.CodeAnalysis.Razor.ProjectSystem;
+
+namespace Microsoft.AspNetCore.Razor.LanguageServer.Diagnostics;
+
+internal partial class RazorDiagnosticsPublisher
+{
+    private sealed class Comparer : IEqualityComparer<IDocumentSnapshot>
+    {
+        public static readonly Comparer Instance = new();
+
+        private Comparer()
+        {
+        }
+
+        public bool Equals(IDocumentSnapshot? x, IDocumentSnapshot? y)
+        {
+            var filePathX = x?.FilePath;
+            var filePathY = y?.FilePath;
+
+            return FilePathComparer.Instance.Equals(filePathX, filePathY);
+        }
+
+        public int GetHashCode(IDocumentSnapshot obj)
+        {
+            var filePath = obj.FilePath.AssumeNotNull();
+            return FilePathComparer.Instance.GetHashCode(filePath);
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.CodeAnalysis.Razor.ProjectSystem;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
+
+namespace Microsoft.AspNetCore.Razor.LanguageServer.Diagnostics;
+
+internal partial class RazorDiagnosticsPublisher
+{
+    internal TestAccessor GetTestAccessor() => new(this);
+
+    internal sealed class TestAccessor(RazorDiagnosticsPublisher instance)
+    {
+        public bool IsWaitingToClearClosedDocuments
+        {
+            get
+            {
+                return !instance._clearClosedDocumentsTask.IsCompleted;
+            }
+        }
+
+        public Task WaitForClearClosedDocumentsAsync()
+        {
+#pragma warning disable VSTHRD003 // Avoid awaiting foreign Tasks
+            return instance._clearClosedDocumentsTask;
+#pragma warning restore VSTHRD003 // Avoid awaiting foreign Tasks
+        }
+
+        public Task WaitForDiagnosticsToPublishAsync()
+        {
+            return instance._workQueue.WaitUntilCurrentBatchCompletesAsync();
+        }
+
+        public void SetPublishedDiagnostics(string filePath, RazorDiagnostic[] razorDiagnostics, Diagnostic[]? csharpDiagnostics)
+        {
+            lock (instance._publishedDiagnostics)
+            {
+                instance._publishedDiagnostics[filePath] = new(razorDiagnostics, csharpDiagnostics);
+            }
+        }
+
+        public void ClearClosedDocuments()
+        {
+            instance.ClearClosedDocuments();
+        }
+
+        public Task PublishDiagnosticsAsync(IDocumentSnapshot document, CancellationToken cancellationToken)
+        {
+            return instance.PublishDiagnosticsAsync(document, cancellationToken);
+        }
+    }
+}