Refresh diagnostics on project changes

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

@@ -105,6 +105,7 @@ public static void AddDiagnosticServices(this IServiceCollection services)
         services.AddHandlerWithCapabilities<DocumentPullDiagnosticsEndpoint>();
         services.AddSingleton<RazorTranslateDiagnosticsService>();
         services.AddSingleton(sp => new Lazy<RazorTranslateDiagnosticsService>(sp.GetRequiredService<RazorTranslateDiagnosticsService>));
+        services.AddSingleton<IRazorStartupService, WorkspaceDiagnosticsRefresher>();
     }
 
     public static void AddHoverServices(this IServiceCollection services)

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

@@ -0,0 +1,117 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor.LanguageServer.Hosting;
+using Microsoft.AspNetCore.Razor.Utilities;
+using Microsoft.CodeAnalysis.Razor.ProjectSystem;
+using Microsoft.CodeAnalysis.Razor.Protocol;
+using Microsoft.CodeAnalysis.Razor.Workspaces;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
+using Microsoft.VisualStudio.Threading;
+
+namespace Microsoft.AspNetCore.Razor.LanguageServer;
+
+internal sealed class WorkspaceDiagnosticsRefresher : IRazorStartupService, IDisposable
+{
+    private readonly AsyncBatchingWorkQueue _queue;
+    private readonly IProjectSnapshotManager _projectSnapshotManager;
+    private readonly IClientCapabilitiesService _clientCapabilitiesService;
+    private readonly IClientConnection _clientConnection;
+    private bool? _supported;
+    private CancellationTokenSource _disposeTokenSource = new();
+
+    public WorkspaceDiagnosticsRefresher(
+        IProjectSnapshotManager projectSnapshotManager,
+        IClientCapabilitiesService clientCapabilitiesService,
+        IClientConnection clientConnection)
+    {
+        _clientConnection = clientConnection;
+        _projectSnapshotManager = projectSnapshotManager;
+        _clientCapabilitiesService = clientCapabilitiesService;
+        _queue = new(
+            TimeSpan.FromMilliseconds(200),
+            ProcessBatchAsync,
+            _disposeTokenSource.Token);
+        _projectSnapshotManager.Changed += ProjectSnapshotManager_Changed;
+    }
+
+    private ValueTask ProcessBatchAsync(CancellationToken token)
+    {
+        _clientConnection
+            .SendNotificationAsync(Methods.WorkspaceDiagnosticRefreshName, _disposeTokenSource.Token)
+            .Forget();
+
+        return new ValueTask(Task.CompletedTask);
+    }
+
+    private void ProjectSnapshotManager_Changed(object? sender, ProjectChangeEventArgs e)
+    {
+        if (e.SolutionIsClosing)
+        {
+            return;
+        }
+
+        if ( _disposeTokenSource.IsCancellationRequested)
+        {
+            return;
+        }
+
+        _supported ??= GetSupported();
+
+        if (_supported != true)
+        {
+            return;
+        }
+
+
+        if (e.Kind is not ProjectChangeKind.DocumentChanged)
+        {
+            _queue.AddWork();
+        }
+    }
+
+    private bool? GetSupported()
+    {
+        if (!_clientCapabilitiesService.CanGetClientCapabilities)
+        {
+            return null;
+        }
+
+        return _clientCapabilitiesService.ClientCapabilities.Workspace?.Diagnostics?.RefreshSupport;
+    }
+
+    internal TestAccessor GetTestAccessor()
+        => new(this);
+
+    public void Dispose()
+    {
+        if (_disposeTokenSource.IsCancellationRequested)
+        {
+            return;
+        }
+
+        _disposeTokenSource.Cancel();
+        _projectSnapshotManager.Changed -= ProjectSnapshotManager_Changed;
+    }
+
+    internal sealed class TestAccessor
+    {
+        private readonly WorkspaceDiagnosticsRefresher _instance;
+
+        public TestAccessor(WorkspaceDiagnosticsRefresher instance)
+        {
+            _instance = instance;
+        }
+
+        public Task WaitForRefreshAsync()
+        {
+            return _instance._queue.WaitUntilCurrentBatchCompletesAsync();
+        }
+    }
+}

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

@@ -5,27 +5,26 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Razor.LanguageServer.Hosting;
+using Microsoft.AspNetCore.Razor.Utilities;
 using Microsoft.CodeAnalysis.Razor.Protocol;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 using Microsoft.VisualStudio.Threading;
 
 namespace Microsoft.AspNetCore.Razor.LanguageServer;
 
-internal class WorkspaceSemanticTokensRefreshNotifier : IWorkspaceSemanticTokensRefreshNotifier, IDisposable
+internal sealed class WorkspaceSemanticTokensRefreshNotifier : IWorkspaceSemanticTokensRefreshNotifier, IDisposable
 {
     private static readonly TimeSpan s_delay = TimeSpan.FromMilliseconds(250);
 
     private readonly IClientCapabilitiesService _clientCapabilitiesService;
     private readonly IClientConnection _clientConnection;
     private readonly CancellationTokenSource _disposeTokenSource;
     private readonly IDisposable _optionsChangeListener;
 
-    private readonly object _gate = new();
-    private bool? _supportsRefresh;
-    private bool _waitingToRefresh;
-    private Task _refreshTask = Task.CompletedTask;
+    private readonly AsyncBatchingWorkQueue _queue;
 
     private bool _isColoringBackground;
+    private bool? _supportsRefresh;
 
     public WorkspaceSemanticTokensRefreshNotifier(
         IClientCapabilitiesService clientCapabilitiesService,
@@ -37,10 +36,24 @@
 
         _disposeTokenSource = new();
 
+        _queue = new(
+            TimeSpan.FromMilliseconds(250),
+            ProcessBatchAsync,
+            _disposeTokenSource.Token);
+
         _isColoringBackground = optionsMonitor.CurrentValue.ColorBackground;
         _optionsChangeListener = optionsMonitor.OnChange(HandleOptionsChange);
     }
 
+    private ValueTask ProcessBatchAsync(CancellationToken token)
+    {
+        _clientConnection
+            .SendNotificationAsync(Methods.WorkspaceSemanticTokensRefreshName, _disposeTokenSource.Token)
+            .Forget();
+
+        return new(Task.CompletedTask);
+    }
+
     public void Dispose()
     {
         if (_disposeTokenSource.IsCancellationRequested)
@@ -70,58 +83,30 @@
             return;
         }
 
-        lock (_gate)
+        // We could have been called before the LSP server has even been initialized
+        if (!_clientCapabilitiesService.CanGetClientCapabilities)
         {
-            if (_waitingToRefresh)
-            {
-                // We're going to refresh shortly.
-                return;
-            }
-
-            // We could have been called before the LSP server has even been initialized
-            if (!_clientCapabilitiesService.CanGetClientCapabilities)
-            {
-                return;
-            }
-
-            _supportsRefresh ??= _clientCapabilitiesService.ClientCapabilities.Workspace?.SemanticTokens?.RefreshSupport ?? false;
-
-            if (_supportsRefresh is false)
-            {
-                return;
-            }
-
-            _refreshTask = RefreshAfterDelayAsync();
-            _waitingToRefresh = true;
+            return;
         }
 
-        async Task RefreshAfterDelayAsync()
-        {
-            await Task.Delay(s_delay, _disposeTokenSource.Token).ConfigureAwait(false);
-
-            _clientConnection
-                .SendNotificationAsync(Methods.WorkspaceSemanticTokensRefreshName, _disposeTokenSource.Token)
-                .Forget();
+        _supportsRefresh ??= _clientCapabilitiesService.ClientCapabilities.Workspace?.SemanticTokens?.RefreshSupport ?? false;
 
-            _waitingToRefresh = false;
+        if (_supportsRefresh is false)
+        {
+            return;
         }
+
+        _queue.AddWork();
     }
 
     internal TestAccessor GetTestAccessor()
         => new(this);
 
-    internal class TestAccessor(WorkspaceSemanticTokensRefreshNotifier instance)
+    internal sealed class TestAccessor(WorkspaceSemanticTokensRefreshNotifier instance)
     {
-        public async Task WaitForNotificationAsync()
+        public Task WaitForNotificationAsync()
         {
-            Task refreshTask;
-
-            lock (instance._gate)
-            {
-                refreshTask = instance._refreshTask;
-            }
-
-            await refreshTask.ConfigureAwait(false);
+            return instance._queue.WaitUntilCurrentBatchCompletesAsync();
         }
     }
 }