Fix edit mapping for Html documents (#12027)

Fixes the integration tests that I broke when I removed Html source
mappings.

Also simplified the code actions and document color code, because they
were the only two requesting from multiple language servers, which made
debugging annoying, and is wasteful because we were getting empty
responses from the ESLint server. We only work with the Html server in
VS, and there is no point pretending otherwise.

Author: davidwengier

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/AbstractEditMappingService.cs

@@ -55,6 +55,13 @@ private async Task<Dictionary<string, TextEdit[]>> RemapDocumentEditsAsync(IDocu
         {
             var generatedDocumentUri = new Uri(uriString);
 
+            // For Html we just map the Uri, the range will be the same
+            if (_filePathService.IsVirtualHtmlFile(generatedDocumentUri))
+            {
+                var razorUri = _filePathService.GetRazorDocumentUri(generatedDocumentUri);
+                remappedChanges[razorUri.AbsoluteUri] = edits;
+            }
+
             // Check if the edit is actually for a generated document, because if not we don't need to do anything
             if (!_filePathService.IsVirtualCSharpFile(generatedDocumentUri))
             {
@@ -111,6 +118,18 @@ private async Task<TextDocumentEdit[]> RemapTextDocumentEditsAsync(IDocumentSnap
         {
             var generatedDocumentUri = entry.TextDocument.DocumentUri.GetRequiredParsedUri();
 
+            // For Html we just map the Uri, the range will be the same
+            if (_filePathService.IsVirtualHtmlFile(generatedDocumentUri))
+            {
+                var razorUri = _filePathService.GetRazorDocumentUri(generatedDocumentUri);
+                entry.TextDocument = new OptionalVersionedTextDocumentIdentifier()
+                {
+                    DocumentUri = new(razorUri),
+                };
+                remappedDocumentEdits.Add(entry);
+                continue;
+            }
+
             // Check if the edit is actually for a generated document, because if not we don't need to do anything
             if (!_filePathService.IsVirtualCSharpFile(generatedDocumentUri))
             {

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Endpoints/RazorCustomMessageTarget_CodeActions.cs

@@ -10,7 +10,6 @@
 using Microsoft.CodeAnalysis.Razor.Protocol.CodeActions;
 using Microsoft.CodeAnalysis.Razor.Telemetry;
 using Microsoft.VisualStudio.LanguageServer.ContainedLanguage;
-using Microsoft.VisualStudio.Threading;
 using StreamJsonRpc;
 
 namespace Microsoft.VisualStudio.Razor.LanguageClient.Endpoints;
@@ -54,33 +53,20 @@ internal partial class RazorCustomMessageTarget
 
         codeActionParams.CodeActionParams.TextDocument.DocumentUri = new(virtualDocumentSnapshot.Uri);
 
-        var textBuffer = virtualDocumentSnapshot.Snapshot.TextBuffer;
         var lspMethodName = Methods.TextDocumentCodeActionName;
         using var _ = _telemetryReporter.TrackLspRequest(lspMethodName, languageServerName, TelemetryThresholds.CodeActionSubLSPTelemetryThreshold, codeActionParams.CorrelationId);
-        var requests = _requestInvoker.ReinvokeRequestOnMultipleServersAsync<VSCodeActionParams, IReadOnlyList<VSInternalCodeAction>>(
-            textBuffer,
+        var response = await _requestInvoker.ReinvokeRequestOnServerAsync<VSCodeActionParams, IReadOnlyList<VSInternalCodeAction>>(
             lspMethodName,
+            languageServerName,
             codeActionParams.CodeActionParams,
             cancellationToken).ConfigureAwait(false);
 
-        var codeActions = new List<VSInternalCodeAction>();
-        await foreach (var response in requests.WithCancellation(cancellationToken).ConfigureAwait(false))
+        if (response.Result is { } codeActions)
         {
-            if (cancellationToken.IsCancellationRequested)
-            {
-                break;
-            }
-
-            if (response.Response != null)
-            {
-                foreach (var codeAction in response.Response)
-                {
-                    codeActions.Add(codeAction);
-                }
-            }
+            return codeActions;
         }
 
-        return codeActions;
+        return [];
     }
 
     // Called by the Razor Language Server to resolve code actions from the platform.
@@ -94,19 +80,22 @@ internal partial class RazorCustomMessageTarget
 
         bool synchronized;
         VirtualDocumentSnapshot virtualDocumentSnapshot;
+        string languageServerName;
         if (resolveCodeActionParams.LanguageKind == RazorLanguageKind.Html)
         {
             (synchronized, virtualDocumentSnapshot) = await TrySynchronizeVirtualDocumentAsync<HtmlVirtualDocumentSnapshot>(
                 resolveCodeActionParams.HostDocumentVersion,
                 resolveCodeActionParams.Identifier,
                 cancellationToken).ConfigureAwait(false);
+            languageServerName = RazorLSPConstants.HtmlLanguageServerName;
         }
         else if (resolveCodeActionParams.LanguageKind == RazorLanguageKind.CSharp)
         {
             (synchronized, virtualDocumentSnapshot) = await TrySynchronizeVirtualDocumentAsync<CSharpVirtualDocumentSnapshot>(
                 resolveCodeActionParams.HostDocumentVersion,
                 resolveCodeActionParams.Identifier,
                 cancellationToken).ConfigureAwait(false);
+            languageServerName = RazorLSPConstants.RazorCSharpLanguageServerName;
         }
         else
         {
@@ -120,22 +109,17 @@ internal partial class RazorCustomMessageTarget
             return null;
         }
 
-        var textBuffer = virtualDocumentSnapshot.Snapshot.TextBuffer;
         var codeAction = resolveCodeActionParams.CodeAction;
 
-        var requests = _requestInvoker.ReinvokeRequestOnMultipleServersAsync<CodeAction, VSInternalCodeAction?>(
-            textBuffer,
+        var response = await _requestInvoker.ReinvokeRequestOnServerAsync<CodeAction, VSInternalCodeAction?>(
             Methods.CodeActionResolveName,
+            languageServerName,
             codeAction,
             cancellationToken).ConfigureAwait(false);
 
-        await foreach (var response in requests.WithCancellation(cancellationToken).ConfigureAwait(false))
+        if (response.Result is { } resolvedCodeAction)
         {
-            if (response.Response is not null)
-            {
-                // Only take the first response from a resolution
-                return response.Response;
-            }
+            return resolvedCodeAction;
         }
 
         return null;

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Endpoints/RazorCustomMessageTarget_DocumentColor.cs

@@ -7,7 +7,6 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Razor.Protocol;
 using Microsoft.CodeAnalysis.Razor.Protocol.ColorPresentation;
-using Microsoft.VisualStudio.Threading;
 using StreamJsonRpc;
 
 namespace Microsoft.VisualStudio.Razor.LanguageClient.Endpoints;
@@ -26,27 +25,17 @@ internal partial class RazorCustomMessageTarget
         var (synchronized, htmlDoc) = await TrySynchronizeVirtualDocumentAsync<HtmlVirtualDocumentSnapshot>(documentColorParams.HostDocumentVersion, documentColorParams.TextDocument, cancellationToken);
         if (!synchronized || htmlDoc is null)
         {
-            return new List<ColorInformation>();
+            return [];
         }
 
         documentColorParams.TextDocument.DocumentUri = new(htmlDoc.Uri);
-        var htmlTextBuffer = htmlDoc.Snapshot.TextBuffer;
-        var requests = _requestInvoker.ReinvokeRequestOnMultipleServersAsync<DocumentColorParams, ColorInformation[]>(
-            htmlTextBuffer,
+        var response = await _requestInvoker.ReinvokeRequestOnServerAsync<DocumentColorParams, ColorInformation[]>(
             Methods.TextDocumentDocumentColor.Name,
+            RazorLSPConstants.HtmlLanguageServerName,
             documentColorParams,
             cancellationToken).ConfigureAwait(false);
 
-        var colorInformation = new List<ColorInformation>();
-        await foreach (var response in requests)
-        {
-            if (response.Response is not null)
-            {
-                colorInformation.AddRange(response.Response);
-            }
-        }
-
-        return colorInformation;
+        return response.Result;
     }
 
     // Called by the Razor Language Server to provide color presentation from the platform.
@@ -61,26 +50,16 @@ public async Task<IReadOnlyList<ColorPresentation>> ProvideHtmlColorPresentation
         var (synchronized, htmlDoc) = await TrySynchronizeVirtualDocumentAsync<HtmlVirtualDocumentSnapshot>(colorPresentationParams.RequiredHostDocumentVersion, colorPresentationParams.TextDocument, cancellationToken);
         if (!synchronized || htmlDoc is null)
         {
-            return new List<ColorPresentation>();
+            return [];
         }
 
         colorPresentationParams.TextDocument.DocumentUri = new(htmlDoc.Uri);
-        var htmlTextBuffer = htmlDoc.Snapshot.TextBuffer;
-        var requests = _requestInvoker.ReinvokeRequestOnMultipleServersAsync<ColorPresentationParams, ColorPresentation[]>(
-            htmlTextBuffer,
+        var response = await _requestInvoker.ReinvokeRequestOnServerAsync<ColorPresentationParams, ColorPresentation[]>(
             Methods.TextDocumentColorPresentationName,
+            RazorLSPConstants.HtmlLanguageServerName,
             colorPresentationParams,
             cancellationToken).ConfigureAwait(false);
 
-        var colorPresentation = new List<ColorPresentation>();
-        await foreach (var response in requests)
-        {
-            if (response.Response is not null)
-            {
-                colorPresentation.AddRange(response.Response);
-            }
-        }
-
-        return colorPresentation;
+        return response.Result;
     }
 }

src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/LanguageClient/RazorCustomMessageTargetTest.cs

@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using Azure;
 using Microsoft.AspNetCore.Razor.Test.Common;
 using Microsoft.AspNetCore.Razor.Test.Common.Editor;
 using Microsoft.AspNetCore.Razor.Test.Common.Workspaces;
@@ -242,26 +243,16 @@ public async Task ProvideCodeActionsAsync_ReturnsCodeActionsAsync()
             .Setup(manager => manager.TryGetDocument(It.IsAny<Uri>(), out testDocument))
             .Returns(true);
 
-        var languageServer1Response = new[] { new VSInternalCodeAction() { Title = "Response 1" } };
-        var languageServer2Response = new[] { new VSInternalCodeAction() { Title = "Response 2" } };
+        var languageServerResponse = new[] { new VSInternalCodeAction() { Title = "Response 1" } };
 
-        async IAsyncEnumerable<ReinvocationResponse<IReadOnlyList<VSInternalCodeAction>>> GetExpectedResultsAsync()
-        {
-            yield return new ReinvocationResponse<IReadOnlyList<VSInternalCodeAction>>("languageClient", languageServer1Response);
-            yield return new ReinvocationResponse<IReadOnlyList<VSInternalCodeAction>>("languageClient", languageServer2Response);
-
-            await Task.CompletedTask;
-        }
-
-        var expectedResults = GetExpectedResultsAsync();
         var requestInvoker = new Mock<LSPRequestInvoker>(MockBehavior.Strict);
         requestInvoker
-            .Setup(invoker => invoker.ReinvokeRequestOnMultipleServersAsync<VSCodeActionParams, IReadOnlyList<VSInternalCodeAction>>(
-                _textBuffer,
+            .Setup(invoker => invoker.ReinvokeRequestOnServerAsync<VSCodeActionParams, IReadOnlyList<VSInternalCodeAction>>(
                 Methods.TextDocumentCodeActionName,
+                RazorLSPConstants.RazorCSharpLanguageServerName,
                 It.IsAny<VSCodeActionParams>(),
                 It.IsAny<CancellationToken>()))
-            .Returns(expectedResults);
+            .ReturnsAsync(new ReinvokeResponse<IReadOnlyList<VSInternalCodeAction>>(languageClient: null, languageServerResponse));
 
         var documentSynchronizer = GetDocumentSynchronizer(GetCSharpSnapshot());
         var telemetryReporter = new Mock<ITelemetryReporter>(MockBehavior.Strict);
@@ -304,8 +295,7 @@ async IAsyncEnumerable<ReinvocationResponse<IReadOnlyList<VSInternalCodeAction>>
 
         // Assert
         Assert.Collection(result,
-            r => Assert.Equal(languageServer1Response[0].Title, r.Title),
-            r => Assert.Equal(languageServer2Response[0].Title, r.Title));
+            r => Assert.Equal(languageServerResponse[0].Title, r.Title));
     }
 
     [Fact]
@@ -322,28 +312,14 @@ public async Task ResolveCodeActionsAsync_ReturnsSingleCodeAction()
             Title = "Something",
             Data = new object()
         };
-        var unexpectedCodeAction = new VSInternalCodeAction()
-        {
-            Title = "Something Else",
-            Data = new object()
-        };
-
-        async IAsyncEnumerable<ReinvocationResponse<VSInternalCodeAction>> GetExpectedResultsAsync()
-        {
-            yield return new ReinvocationResponse<VSInternalCodeAction>("languageClient", expectedCodeAction);
-            yield return new ReinvocationResponse<VSInternalCodeAction>("languageClient", unexpectedCodeAction);
 
-            await Task.CompletedTask;
-        }
-
-        var expectedResponses = GetExpectedResultsAsync();
         requestInvoker
-            .Setup(invoker => invoker.ReinvokeRequestOnMultipleServersAsync<CodeAction, VSInternalCodeAction>(
-                It.IsAny<ITextBuffer>(),
+            .Setup(invoker => invoker.ReinvokeRequestOnServerAsync<CodeAction, VSInternalCodeAction>(
                 Methods.CodeActionResolveName,
+                RazorLSPConstants.RazorCSharpLanguageServerName,
                 It.IsAny<VSInternalCodeAction>(),
                 It.IsAny<CancellationToken>()))
-            .Returns(expectedResponses);
+            .ReturnsAsync(new ReinvokeResponse<VSInternalCodeAction>(languageClient: null, expectedCodeAction));
 
         var documentSynchronizer = new Mock<LSPDocumentSynchronizer>(MockBehavior.Strict);
         documentSynchronizer