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,104 @@
+// 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.Tasks;
+using Microsoft.AspNetCore.Razor.LanguageServer.Hosting;
+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 class WorkspaceDiagnosticsRefresher : IRazorStartupService
+{
+    private readonly object _gate = new();
+    private readonly IClientCapabilitiesService _clientCapabilitiesService;
+    private readonly IClientConnection _clientConnection;
+    private bool _refreshQueued;
+    private Task? _refreshTask;
+
+    private static readonly TimeSpan s_delay = TimeSpan.FromMilliseconds(200);
+
+    public WorkspaceDiagnosticsRefresher(
+        IProjectSnapshotManager projectSnapshotManager,
+        IClientCapabilitiesService clientCapabilitiesService,
+        IClientConnection clientConnection)
+    {
+        projectSnapshotManager.Changed += ProjectSnapshotManager_Changed;
+        _clientCapabilitiesService = clientCapabilitiesService;
+        _clientConnection = clientConnection;
+    }
+
+    private void ProjectSnapshotManager_Changed(object? sender, ProjectChangeEventArgs e)
+    {
+        if (e.SolutionIsClosing)
+        {
+            return;
+        }
+
+        if (e.Kind is not ProjectChangeKind.DocumentChanged)
+        {
+            QueueRefresh();
+        }
+    }
+
+    private void QueueRefresh()
+    {
+        lock(_gate)
+        {
+            if (_refreshQueued)
+            {
+                return;
+            }
+
+            if (!_clientCapabilitiesService.CanGetClientCapabilities)
+            {
+                return;
+            }
+
+            var supported = _clientCapabilitiesService.ClientCapabilities.Workspace?.Diagnostics?.RefreshSupport;
+            if (supported != true)
+            {
+                return;
+            }
+
+            _refreshQueued = true;
+            _refreshTask = RefreshAfterDelayAsync();
+        }
+    }
+
+    private async Task RefreshAfterDelayAsync()
+    {
+        await Task.Delay(s_delay).ConfigureAwait(false);
+
+        _clientConnection
+            .SendNotificationAsync(Methods.WorkspaceDiagnosticRefreshName, default)
+            .Forget();
+
+        _refreshQueued = false;
+    }
+
+    public TestAccessor GetTestAccessor()
+        => new(this);
+
+    public class TestAccessor
+    {
+        private readonly WorkspaceDiagnosticsRefresher _instance;
+
+        public TestAccessor(WorkspaceDiagnosticsRefresher instance)
+        {
+            _instance = instance;
+        }
+
+        public Task WaitForRefreshAsync()
+        {
+            return _instance._refreshTask ?? Task.CompletedTask;
+        }
+    }
+}

src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/WorkspaceDiagnosticRefreshTest.cs

@@ -0,0 +1,137 @@
+// 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 System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor.LanguageServer.Hosting;
+using Microsoft.AspNetCore.Razor.Test.Common.LanguageServer;
+using Microsoft.AspNetCore.Razor.Test.Common.ProjectSystem;
+using Microsoft.CodeAnalysis.Razor.ProjectSystem;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
+using Moq;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.AspNetCore.Razor.LanguageServer.Test;
+
+public class WorkspaceDiagnosticRefreshTest(ITestOutputHelper testOutputHelper) : LanguageServerTestBase(testOutputHelper)
+{
+    [Fact]
+    public async Task WorkspaceRefreshSent()
+    {
+        var projectSnapshotManager = CreateProjectSnapshotManager();
+        var clientConnection = new Mock<IClientConnection>(MockBehavior.Strict);
+        clientConnection
+            .Setup(c => c.SendNotificationAsync(Methods.WorkspaceDiagnosticRefreshName, It.IsAny<CancellationToken>()))
+            .Returns(Task.CompletedTask)
+            .Verifiable();
+
+        var publisher = new WorkspaceDiagnosticsRefresher(
+            projectSnapshotManager,
+            new TestClientCapabilitiesService(new()
+            {
+                Workspace = new()
+                {
+                    Diagnostics = new()
+                    {
+                        RefreshSupport = true
+                    }
+                }
+            }),
+            clientConnection.Object);
+
+        var testAccessor = publisher.GetTestAccessor();
+
+        await projectSnapshotManager.UpdateAsync(
+            static updater =>
+            {
+                updater.CreateAndAddProject("C:/path/to/project.csproj");
+            });
+
+        await testAccessor.WaitForRefreshAsync();
+
+        clientConnection.Verify();
+    }
+
+    [Fact]
+    public async Task WorkspaceRefreshSent_MultipleTimes()
+    {
+        var projectSnapshotManager = CreateProjectSnapshotManager();
+        var clientConnection = new Mock<IClientConnection>(MockBehavior.Strict);
+        clientConnection
+            .Verify(c => c.SendNotificationAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()),
+                    Times.Exactly(2));
+
+        var publisher = new WorkspaceDiagnosticsRefresher(
+            projectSnapshotManager,
+            new TestClientCapabilitiesService(new()
+            {
+                Workspace = new()
+                {
+                    Diagnostics = new()
+                    {
+                        RefreshSupport = true
+                    }
+                }
+            }),
+            clientConnection.Object);
+
+        var testAccessor = publisher.GetTestAccessor();
+
+        await projectSnapshotManager.UpdateAsync(
+            static updater =>
+            {
+                updater.CreateAndAddProject("C:/path/to/project.csproj");
+            });
+
+        await testAccessor.WaitForRefreshAsync();
+
+        await projectSnapshotManager.UpdateAsync(
+            static updater =>
+            {
+                var project = (ProjectSnapshot)updater.GetProjects().Single();
+                updater.CreateAndAddDocument(project, "C:/path/to/document.razor");
+            });
+
+        await testAccessor.WaitForRefreshAsync();
+
+        clientConnection.Verify();
+    }
+
+    [Fact]
+    public async Task WorkspaceRefreshNotSent_ClientDoesNotSupport()
+    {
+        var projectSnapshotManager = CreateProjectSnapshotManager();
+        var clientConnection = new Mock<IClientConnection>(MockBehavior.Strict);
+        clientConnection
+            .Verify(c => c.SendNotificationAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()),
+                    Times.Never);
+
+        var publisher = new WorkspaceDiagnosticsRefresher(
+            projectSnapshotManager,
+            new TestClientCapabilitiesService(new()
+            {
+                Workspace = new()
+                {
+                    Diagnostics = new()
+                    {
+                        RefreshSupport = false
+                    }
+                }
+            }),
+            clientConnection.Object);
+
+        var testAccessor = publisher.GetTestAccessor();
+
+        await projectSnapshotManager.UpdateAsync(
+            static updater =>
+            {
+                updater.CreateAndAddProject("C:/path/to/project.csproj");
+            });
+
+        await testAccessor.WaitForRefreshAsync();
+
+        clientConnection.Verify();
+    }
+}