Merge pull request #8775 from davidwengier/CleanupDocumentMapping

Author: davidwengier

src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorCodeActionsBenchmark.cs

@@ -47,7 +47,7 @@ public async Task SetupAsync()
         var languageServer = RazorLanguageServer.GetInnerLanguageServerForTesting();
 
         CodeActionEndpoint = new CodeActionEndpoint(
-            documentMappingService: languageServer.GetRequiredService<RazorDocumentMappingService>(),
+            documentMappingService: languageServer.GetRequiredService<IRazorDocumentMappingService>(),
             razorCodeActionProviders: languageServer.GetRequiredService<IEnumerable<IRazorCodeActionProvider>>(),
             csharpCodeActionProviders: languageServer.GetRequiredService<IEnumerable<ICSharpCodeActionProvider>>(),
             htmlCodeActionProviders: languageServer.GetRequiredService<IEnumerable<IHtmlCodeActionProvider>>(),

src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorCompletionBenchmark.cs

@@ -37,7 +37,7 @@ public async Task SetupAsync()
         var razorCompletionListProvider = languageServer.GetRequiredService<RazorCompletionListProvider>();
         var lspServices = languageServer.GetLspServices();
         var responseRewriters = lspServices.GetRequiredServices<DelegatedCompletionResponseRewriter>();
-        var documentMappingService = lspServices.GetRequiredService<RazorDocumentMappingService>();
+        var documentMappingService = lspServices.GetRequiredService<IRazorDocumentMappingService>();
         var clientNotifierServiceBase = lspServices.GetRequiredService<ClientNotifierServiceBase>();
         var completionListCache = lspServices.GetRequiredService<CompletionListCache>();
 
@@ -142,7 +142,7 @@ public async Task RazorCompletionAsync()
 
     private class TestDelegatedCompletionListProvider : DelegatedCompletionListProvider
     {
-        public TestDelegatedCompletionListProvider(IEnumerable<DelegatedCompletionResponseRewriter> responseRewriters, RazorDocumentMappingService documentMappingService, ClientNotifierServiceBase languageServer, CompletionListCache completionListCache)
+        public TestDelegatedCompletionListProvider(IEnumerable<DelegatedCompletionResponseRewriter> responseRewriters, IRazorDocumentMappingService documentMappingService, ClientNotifierServiceBase languageServer, CompletionListCache completionListCache)
             : base(responseRewriters, documentMappingService, languageServer, completionListCache)
         {
         }

src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorSemanticTokensBenchmark.cs

@@ -126,7 +126,7 @@ internal class TestRazorSemanticTokensInfoService : RazorSemanticTokensInfoServi
     {
         public TestRazorSemanticTokensInfoService(
             ClientNotifierServiceBase languageServer,
-            RazorDocumentMappingService documentMappingService,
+            IRazorDocumentMappingService documentMappingService,
             ILoggerFactory loggerFactory)
             : base(languageServer, documentMappingService, loggerFactory)
         {

src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorSemanticTokensRangeEndpointBenchmark.cs

@@ -151,7 +151,7 @@ internal class TestCustomizableRazorSemanticTokensInfoService : RazorSemanticTok
     {
         public TestCustomizableRazorSemanticTokensInfoService(
             ClientNotifierServiceBase languageServer,
-            RazorDocumentMappingService documentMappingService,
+            IRazorDocumentMappingService documentMappingService,
             ILoggerFactory loggerFactory)
             : base(languageServer, documentMappingService, loggerFactory)
         {

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

@@ -20,13 +20,13 @@ internal abstract class AbstractRazorDelegatingEndpoint<TRequest, TResponse> : I
    where TRequest : ITextDocumentPositionParams
 {
     private readonly LanguageServerFeatureOptions _languageServerFeatureOptions;
-    private readonly RazorDocumentMappingService _documentMappingService;
+    private readonly IRazorDocumentMappingService _documentMappingService;
     private readonly ClientNotifierServiceBase _languageServer;
     protected readonly ILogger Logger;
 
     protected AbstractRazorDelegatingEndpoint(
         LanguageServerFeatureOptions languageServerFeatureOptions,
-        RazorDocumentMappingService documentMappingService,
+        IRazorDocumentMappingService documentMappingService,
         ClientNotifierServiceBase languageServer,
         ILogger logger)
     {
@@ -40,7 +40,7 @@ protected AbstractRazorDelegatingEndpoint(
     /// <summary>
     /// The strategy to use to project the incoming caret position onto the generated C#/Html document
     /// </summary>
-    protected virtual IProjectionStrategy ProjectionStrategy { get; } = DefaultProjectionStrategy.Instance;
+    protected virtual IDocumentPositionInfoStrategy DocumentPositionInfoStrategy { get; } = DefaultDocumentPositionInfoStrategy.Instance;
 
     protected bool SingleServerSupport => _languageServerFeatureOptions.SingleServerSupport;
 
@@ -67,20 +67,20 @@ protected AbstractRazorDelegatingEndpoint(
     /// <summary>
     /// The delegated object to send to the <see cref="CustomMessageTarget"/>
     /// </summary>
-    protected abstract Task<IDelegatedParams?> CreateDelegatedParamsAsync(TRequest request, RazorRequestContext requestContext, Projection projection, CancellationToken cancellationToken);
+    protected abstract Task<IDelegatedParams?> CreateDelegatedParamsAsync(TRequest request, RazorRequestContext requestContext, DocumentPositionInfo positionInfo, CancellationToken cancellationToken);
 
     /// <summary>
     /// If the response needs to be handled, such as for remapping positions back, override and handle here
     /// </summary>
-    protected virtual Task<TResponse> HandleDelegatedResponseAsync(TResponse delegatedResponse, TRequest originalRequest, RazorRequestContext requestContext, Projection projection, CancellationToken cancellationToken)
+    protected virtual Task<TResponse> HandleDelegatedResponseAsync(TResponse delegatedResponse, TRequest originalRequest, RazorRequestContext requestContext, DocumentPositionInfo positionInfo, CancellationToken cancellationToken)
         => Task.FromResult(delegatedResponse);
 
     /// <summary>
     /// If the request can be handled without delegation, override this to provide a response. If a null
     /// value is returned the request will be delegated to C#/HTML servers, otherwise the response
     /// will be used in <see cref="HandleRequestAsync(TRequest, RazorRequestContext, CancellationToken)"/>
     /// </summary>
-    protected virtual Task<TResponse?> TryHandleAsync(TRequest request, RazorRequestContext requestContext, Projection projection, CancellationToken cancellationToken)
+    protected virtual Task<TResponse?> TryHandleAsync(TRequest request, RazorRequestContext requestContext, DocumentPositionInfo positionInfo, CancellationToken cancellationToken)
         => Task.FromResult<TResponse?>(default);
 
     /// <summary>
@@ -111,13 +111,13 @@ protected virtual Task<TResponse> HandleDelegatedResponseAsync(TResponse delegat
             return default;
         }
 
-        var projection = await ProjectionStrategy.TryGetProjectionAsync(_documentMappingService, documentContext, request.Position, requestContext.Logger, cancellationToken).ConfigureAwait(false);
-        if (projection is null)
+        var positionInfo = await DocumentPositionInfoStrategy.TryGetPositionInfoAsync(_documentMappingService, documentContext, request.Position, requestContext.Logger, cancellationToken).ConfigureAwait(false);
+        if (positionInfo is null)
         {
             return default;
         }
 
-        var response = await TryHandleAsync(request, requestContext, projection, cancellationToken).ConfigureAwait(false);
+        var response = await TryHandleAsync(request, requestContext, positionInfo, cancellationToken).ConfigureAwait(false);
         if (response is not null && response is not ISumType { Value: null })
         {
             return response;
@@ -128,27 +128,27 @@ protected virtual Task<TResponse> HandleDelegatedResponseAsync(TResponse delegat
             return default;
         }
 
-        if (projection.LanguageKind == RazorLanguageKind.Razor)
+        if (positionInfo.LanguageKind == RazorLanguageKind.Razor)
         {
             // We can only delegate to C# and HTML, so if we're in a Razor context and our inheritor didn't want to provide
             // any response then that's all we can do.
             return default;
         }
-        else if (projection.LanguageKind == RazorLanguageKind.Html && PreferCSharpOverHtmlIfPossible)
+        else if (positionInfo.LanguageKind == RazorLanguageKind.Html && PreferCSharpOverHtmlIfPossible)
         {
             // Sometimes Html can actually be mapped to C#, like for example component attributes, which map to
             // C# properties, even though they appear entirely in a Html context. Since remapping is pretty cheap
             // it's easier to just try mapping, and see what happens, rather than checking for specific syntax nodes.
             var codeDocument = await documentContext.GetCodeDocumentAsync(cancellationToken).ConfigureAwait(false);
-            if (_documentMappingService.TryMapToProjectedDocumentPosition(codeDocument.GetCSharpDocument(), projection.AbsoluteIndex, out var csharpPosition, out _))
+            if (_documentMappingService.TryMapToGeneratedDocumentPosition(codeDocument.GetCSharpDocument(), positionInfo.HostDocumentIndex, out var csharpPosition, out _))
             {
-                // We're just gonna pretend this mapped perfectly normally onto C#. Moving this logic to the actual projection
+                // We're just gonna pretend this mapped perfectly normally onto C#. Moving this logic to the actual position info
                 // calculating code is possible, but could have untold effects, so opt-in is better (for now?)
-                projection = new Projection(RazorLanguageKind.CSharp, csharpPosition, projection.AbsoluteIndex);
+                positionInfo = new DocumentPositionInfo(RazorLanguageKind.CSharp, csharpPosition, positionInfo.HostDocumentIndex);
             }
         }
 
-        var delegatedParams = await CreateDelegatedParamsAsync(request, requestContext, projection, cancellationToken).ConfigureAwait(false);
+        var delegatedParams = await CreateDelegatedParamsAsync(request, requestContext, positionInfo, cancellationToken).ConfigureAwait(false);
 
         if (delegatedParams is null)
         {
@@ -171,7 +171,7 @@ protected virtual Task<TResponse> HandleDelegatedResponseAsync(TResponse delegat
             throw;
         }
 
-        var remappedResponse = await HandleDelegatedResponseAsync(delegatedRequest, request, requestContext, projection, cancellationToken).ConfigureAwait(false);
+        var remappedResponse = await HandleDelegatedResponseAsync(delegatedRequest, request, requestContext, positionInfo, cancellationToken).ConfigureAwait(false);
 
         return remappedResponse;
     }

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/AutoInsert/OnAutoInsertEndpoint.cs

@@ -32,7 +32,7 @@ internal class OnAutoInsertEndpoint : AbstractRazorDelegatingEndpoint<VSInternal
 
     public OnAutoInsertEndpoint(
         LanguageServerFeatureOptions languageServerFeatureOptions,
-        RazorDocumentMappingService documentMappingService,
+        IRazorDocumentMappingService documentMappingService,
         ClientNotifierServiceBase languageServer,
         IEnumerable<IOnAutoInsertProvider> onAutoInsertProvider,
         IOptionsMonitor<RazorLSPOptions> optionsMonitor,
@@ -65,7 +65,7 @@ public RegistrationExtensionResult GetRegistration(VSInternalClientCapabilities
         return new RegistrationExtensionResult(AssociatedServerCapability, registrationOptions);
     }
 
-    protected override async Task<VSInternalDocumentOnAutoInsertResponseItem?> TryHandleAsync(VSInternalDocumentOnAutoInsertParams request, RazorRequestContext requestContext, Projection projection, CancellationToken cancellationToken)
+    protected override async Task<VSInternalDocumentOnAutoInsertResponseItem?> TryHandleAsync(VSInternalDocumentOnAutoInsertParams request, RazorRequestContext requestContext, DocumentPositionInfo positionInfo, CancellationToken cancellationToken)
     {
         var documentContext = requestContext.GetRequiredDocumentContext();
         var codeDocument = await documentContext.GetCodeDocumentAsync(cancellationToken).ConfigureAwait(false);
@@ -118,16 +118,16 @@ public RegistrationExtensionResult GetRegistration(VSInternalClientCapabilities
         return null;
     }
 
-    protected override Task<IDelegatedParams?> CreateDelegatedParamsAsync(VSInternalDocumentOnAutoInsertParams request, RazorRequestContext requestContext, Projection projection, CancellationToken cancellationToken)
+    protected override Task<IDelegatedParams?> CreateDelegatedParamsAsync(VSInternalDocumentOnAutoInsertParams request, RazorRequestContext requestContext, DocumentPositionInfo positionInfo, CancellationToken cancellationToken)
     {
         var documentContext = requestContext.GetRequiredDocumentContext();
-        if (projection.LanguageKind == RazorLanguageKind.Html &&
+        if (positionInfo.LanguageKind == RazorLanguageKind.Html &&
            !s_htmlAllowedTriggerCharacters.Contains(request.Character))
         {
             Logger.LogInformation("Inapplicable HTML trigger char {request.Character}.", request.Character);
             return Task.FromResult<IDelegatedParams?>(null);
         }
-        else if (projection.LanguageKind == RazorLanguageKind.CSharp)
+        else if (positionInfo.LanguageKind == RazorLanguageKind.CSharp)
         {
             if (!s_cSharpAllowedTriggerCharacters.Contains(request.Character))
             {
@@ -155,8 +155,8 @@ public RegistrationExtensionResult GetRegistration(VSInternalClientCapabilities
 
         return Task.FromResult<IDelegatedParams?>(new DelegatedOnAutoInsertParams(
             documentContext.Identifier,
-            projection.Position,
-            projection.LanguageKind,
+            positionInfo.Position,
+            positionInfo.LanguageKind,
             request.Character,
             request.Options));
     }
@@ -165,7 +165,7 @@ public RegistrationExtensionResult GetRegistration(VSInternalClientCapabilities
         VSInternalDocumentOnAutoInsertResponseItem? delegatedResponse,
         VSInternalDocumentOnAutoInsertParams originalRequest,
         RazorRequestContext requestContext,
-        Projection projection,
+        DocumentPositionInfo positionInfo,
         CancellationToken cancellationToken)
     {
         if (delegatedResponse is null)
@@ -176,7 +176,7 @@ public RegistrationExtensionResult GetRegistration(VSInternalClientCapabilities
         var documentContext = requestContext.GetRequiredDocumentContext();
 
         // For Html we just return the edit as is
-        if (projection.LanguageKind == RazorLanguageKind.Html)
+        if (positionInfo.LanguageKind == RazorLanguageKind.Html)
         {
             return delegatedResponse;
         }
@@ -188,11 +188,11 @@ public RegistrationExtensionResult GetRegistration(VSInternalClientCapabilities
         TextEdit[] mappedEdits;
         if (delegatedResponse.TextEditFormat == InsertTextFormat.Snippet)
         {
-            mappedEdits = await razorFormattingService.FormatSnippetAsync(documentContext, projection.LanguageKind, edits, originalRequest.Options, cancellationToken).ConfigureAwait(false);
+            mappedEdits = await razorFormattingService.FormatSnippetAsync(documentContext, positionInfo.LanguageKind, edits, originalRequest.Options, cancellationToken).ConfigureAwait(false);
         }
         else
         {
-            mappedEdits = await razorFormattingService.FormatOnTypeAsync(documentContext, projection.LanguageKind, edits, originalRequest.Options, hostDocumentIndex: 0, triggerCharacter: '\0', cancellationToken).ConfigureAwait(false);
+            mappedEdits = await razorFormattingService.FormatOnTypeAsync(documentContext, positionInfo.LanguageKind, edits, originalRequest.Options, hostDocumentIndex: 0, triggerCharacter: '\0', cancellationToken).ConfigureAwait(false);
         }
 
         if (mappedEdits.Length != 1)

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/CodeActions/CSharp/UnformattedRemappingCSharpCodeActionResolver.cs

@@ -21,12 +21,12 @@ namespace Microsoft.AspNetCore.Razor.LanguageServer.CodeActions;
 internal sealed class UnformattedRemappingCSharpCodeActionResolver : CSharpCodeActionResolver
 {
     private readonly DocumentContextFactory _documentContextFactory;
-    private readonly RazorDocumentMappingService _documentMappingService;
+    private readonly IRazorDocumentMappingService _documentMappingService;
 
     public UnformattedRemappingCSharpCodeActionResolver(
         DocumentContextFactory documentContextFactory,
         ClientNotifierServiceBase languageServer,
-        RazorDocumentMappingService documentMappingService)
+        IRazorDocumentMappingService documentMappingService)
         : base(languageServer)
     {
         _documentContextFactory = documentContextFactory ?? throw new ArgumentNullException(nameof(documentContextFactory));
@@ -92,7 +92,7 @@ public async override Task<CodeAction> ResolveAsync(
             return codeAction;
         }
 
-        if (!_documentMappingService.TryMapFromProjectedDocumentRange(codeDocument.GetCSharpDocument(), textEdit.Range, MappingBehavior.Inclusive, out var originalRange))
+        if (!_documentMappingService.TryMapToHostDocumentRange(codeDocument.GetCSharpDocument(), textEdit.Range, MappingBehavior.Inclusive, out var originalRange))
         {
             // Text edit failed to map
             return codeAction;

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/CodeActions/CodeActionEndpoint.cs

@@ -29,7 +29,7 @@ namespace Microsoft.AspNetCore.Razor.LanguageServer.CodeActions;
 [LanguageServerEndpoint(Methods.TextDocumentCodeActionName)]
 internal sealed class CodeActionEndpoint : IRazorRequestHandler<VSCodeActionParams, SumType<Command, CodeAction>[]?>, IRegistrationExtension
 {
-    private readonly RazorDocumentMappingService _documentMappingService;
+    private readonly IRazorDocumentMappingService _documentMappingService;
     private readonly IEnumerable<IRazorCodeActionProvider> _razorCodeActionProviders;
     private readonly IEnumerable<ICSharpCodeActionProvider> _csharpCodeActionProviders;
     private readonly IEnumerable<IHtmlCodeActionProvider> _htmlCodeActionProviders;
@@ -43,7 +43,7 @@ internal sealed class CodeActionEndpoint : IRazorRequestHandler<VSCodeActionPara
     public bool MutatesSolutionState { get; } = false;
 
     public CodeActionEndpoint(
-        RazorDocumentMappingService documentMappingService,
+        IRazorDocumentMappingService documentMappingService,
         IEnumerable<IRazorCodeActionProvider> razorCodeActionProviders,
         IEnumerable<ICSharpCodeActionProvider> csharpCodeActionProviders,
         IEnumerable<IHtmlCodeActionProvider> htmlCodeActionProviders,
@@ -274,14 +274,14 @@ internal async Task<RazorVSInternalCodeAction[]> GetCodeActionsFromLanguageServe
         if (languageKind == RazorLanguageKind.CSharp)
         {
             // For C# we have to map the ranges to the generated document
-            if (!_documentMappingService.TryMapToProjectedDocumentRange(context.CodeDocument.GetCSharpDocument(), context.Request.Range, out var projectedRange))
+            if (!_documentMappingService.TryMapToGeneratedDocumentRange(context.CodeDocument.GetCSharpDocument(), context.Request.Range, out var projectedRange))
             {
                 return Array.Empty<RazorVSInternalCodeAction>();
             }
 
             var newContext = context.Request.Context;
             if (context.Request.Context is VSInternalCodeActionContext { SelectionRange: not null } vsContext &&
-                _documentMappingService.TryMapToProjectedDocumentRange(context.CodeDocument.GetCSharpDocument(), vsContext.SelectionRange, out var selectionRange))
+                _documentMappingService.TryMapToGeneratedDocumentRange(context.CodeDocument.GetCSharpDocument(), vsContext.SelectionRange, out var selectionRange))
             {
                 vsContext.SelectionRange = selectionRange;
                 newContext = vsContext;