Add mapSpans

Author: Andrew Hall

src/lsptoolshost/razor/razorEndpoints.ts

@@ -27,15 +27,18 @@ import { ColorPresentation } from 'vscode-html-languageservice';
 import { DynamicFileInfoHandler } from '../../razor/src/dynamicFile/dynamicFileInfoHandler';
 import { ProvideDynamicFileParams } from '../../razor/src/dynamicFile/provideDynamicFileParams';
 import { ProvideDynamicFileResponse } from '../../razor/src/dynamicFile/provideDynamicFileResponse';
+import { RazorMapSpansParams } from '../../razor/src/mapping/razorMapSpansParams';
+import { RazorMapSpansResponse } from '../../razor/src/mapping/razorMapSpansResponse';
+import { MappingHandler } from '../../razor/src/mapping/mappingHandler';
 
 export function registerRazorEndpoints(
     context: vscode.ExtensionContext,
-    languageServer: RoslynLanguageServer,
+    roslynLanguageServer: RoslynLanguageServer,
     razorLogger: RazorLogger,
     platformInfo: PlatformInformation
 ) {
     const logNotificationType = new NotificationType<LogMessageParams>('razor/log');
-    languageServer.registerOnNotificationWithParams(logNotificationType, (params) =>
+    roslynLanguageServer.registerOnNotificationWithParams(logNotificationType, (params) =>
         razorLogger.log(params.message, params.type)
     );
 
@@ -78,8 +81,6 @@ export function registerRazorEndpoints(
     }
 
     function registerNonCohostingEndpoints() {
-        // When the Roslyn language server sends a request for Razor dynamic file info, we forward that request along to Razor via
-        // a command.
         registerRequestHandler<ProvideDynamicFileParams, ProvideDynamicFileResponse>(
             'razor/provideDynamicFileInfo',
             async (params) =>
@@ -91,12 +92,15 @@ export function registerRazorEndpoints(
             async (params) =>
                 vscode.commands.executeCommand(DynamicFileInfoHandler.provideDynamicFileInfoCommand, params)
         );
+        registerRequestHandler<RazorMapSpansParams, RazorMapSpansResponse>('razor/mapSpans', async (params) => {
+            return await vscode.commands.executeCommand<RazorMapSpansResponse>(MappingHandler.MapSpansCommand, params);
+        });
     }
 
     // Helper method that registers a request handler, and logs errors to the Razor logger.
     function registerRequestHandler<Params, Result>(method: string, invocation: (params: Params) => Promise<Result>) {
         const requestType = new RequestType<Params, Result, Error>(method);
-        languageServer.registerOnRequest(requestType, async (params) => {
+        roslynLanguageServer.registerOnRequest(requestType, async (params) => {
             try {
                 return await invocation(params);
             } catch (error) {

src/razor/src/document/razorDocumentManager.ts

@@ -56,6 +56,16 @@ export class RazorDocumentManager implements IRazorDocumentManager {
         return document;
     }
 
+    public async getDocumentForCSharpUri(csharpUri: vscode.Uri): Promise<IRazorDocument | undefined> {
+        return this.documents.find((document) => {
+            if (this.platformInfo.isLinux()) {
+                return document.csharpDocument.path === csharpUri.path;
+            }
+
+            return document.csharpDocument.path.localeCompare(csharpUri.path, undefined, { sensitivity: 'base' }) === 0;
+        });
+    }
+
     public async getActiveDocument(): Promise<IRazorDocument | null> {
         if (!vscode.window.activeTextEditor) {
             return null;

src/razor/src/extension.ts

@@ -51,6 +51,7 @@ import { InlayHintHandler } from './inlayHint/inlayHintHandler';
 import { InlayHintResolveHandler } from './inlayHint/inlayHintResolveHandler';
 import { getComponentPaths } from '../../lsptoolshost/extensions/builtInComponents';
 import { BlazorDebugConfigurationProvider } from './blazorDebug/blazorDebugConfigurationProvider';
+import { MappingHandler } from './mapping/mappingHandler';
 
 // We specifically need to take a reference to a particular instance of the vscode namespace,
 // otherwise providers attempt to operate on the null extension.
@@ -123,15 +124,15 @@ export async function activate(
             logger
         );
 
-        const languageServiceClient = new RazorLanguageServiceClient(languageServerClient);
-
         const documentManager = new RazorDocumentManager(
             languageServerClient,
             logger,
             razorTelemetryReporter,
             platformInfo
         );
 
+        const languageServiceClient = new RazorLanguageServiceClient(languageServerClient, documentManager);
+
         const documentSynchronizer = new RazorDocumentSynchronizer(documentManager, logger);
         reportTelemetryForDocuments(documentManager, razorTelemetryReporter);
         const languageConfiguration = new RazorLanguageConfiguration();
@@ -261,6 +262,8 @@ export async function activate(
                 logger
             );
 
+            const mappingHandler = new MappingHandler(languageServiceClient);
+
             localRegistrations.push(
                 languageConfiguration.register(),
                 vscodeType.languages.registerSignatureHelpProvider(RazorLanguage.id, signatureHelpProvider, '(', ','),
@@ -298,6 +301,7 @@ export async function activate(
                 completionHandler.register(),
                 razorSimplifyMethodHandler.register(),
                 razorFormatNewFileHandler.register(),
+                mappingHandler.register(),
             ]);
         });
 

src/razor/src/mapping/mappingHandler.ts

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { RazorLanguageServiceClient } from '../razorLanguageServiceClient';
+import { RazorMapSpansParams } from './razorMapSpansParams';
+
+export class MappingHandler {
+    public static readonly MapSpansCommand = 'razor.mapSpansCommand';
+    constructor(private readonly languageServiceClient: RazorLanguageServiceClient) {}
+
+    public async register(): Promise<void> {
+        vscode.commands.registerCommand(MappingHandler.MapSpansCommand, async (params: RazorMapSpansParams) => {
+            return this.languageServiceClient.mapSpans(params);
+        });
+    }
+}

src/razor/src/mapping/mappingHelpers.ts

@@ -10,7 +10,8 @@ import { RazorLanguageServiceClient } from '../razorLanguageServiceClient';
 import { RazorLogger } from '../razorLogger';
 
 export class MappingHelpers {
-    public readonly language = 'Razor';
+    public static readonly language = 'Razor';
+    public static readonly MapSpansCommand = 'razor.mapSpansCommand';
 
     public static async remapGeneratedFileWorkspaceEdit(
         workspaceEdit: vscode.WorkspaceEdit,

src/razor/src/mapping/razorMapSpansParams.ts

@@ -0,0 +1,11 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Range, TextDocumentIdentifier } from 'vscode-languageserver-protocol';
+
+// Matches https://github.com/dotnet/razor/blob/main/src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Services/RazorMapSpansParams.cs
+export class RazorMapSpansParams {
+    constructor(public readonly csharpDocument: TextDocumentIdentifier, public readonly ranges: Range[]) {}
+}

src/razor/src/mapping/razorMapSpansResponse.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Range, TextDocumentIdentifier } from 'vscode-languageserver-types';
+import { razorTextSpan } from '../dynamicFile/razorTextSpan';
+
+// matches https://github.com/dotnet/razor/blob/main/src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Services/RazorMapSpansResponse.cs
+export class RazorMapSpansResponse {
+    static empty: RazorMapSpansResponse = new RazorMapSpansResponse([], [], { uri: '' });
+
+    constructor(
+        public readonly ranges: Range[],
+        public readonly spans: razorTextSpan[],
+        public readonly razorDocument: TextDocumentIdentifier
+    ) {}
+}

src/razor/src/razorLanguageServiceClient.ts

@@ -11,9 +11,16 @@ import { LanguageQueryResponse } from './rpc/languageQueryResponse';
 import { RazorMapToDocumentRangesRequest } from './rpc/razorMapToDocumentRangesRequest';
 import { RazorMapToDocumentRangesResponse } from './rpc/razorMapToDocumentRangesResponse';
 import { convertRangeFromSerializable, convertRangeToSerializable } from './rpc/serializableRange';
+import { RazorMapSpansParams } from './mapping/razorMapSpansParams';
+import { RazorMapSpansResponse } from './mapping/razorMapSpansResponse';
+import { UriConverter } from '../../lsptoolshost/utils/uriConverter';
+import { RazorDocumentManager } from './document/razorDocumentManager';
 
 export class RazorLanguageServiceClient {
-    constructor(private readonly serverClient: RazorLanguageServerClient) {}
+    constructor(
+        private readonly serverClient: RazorLanguageServerClient,
+        private readonly documentManager: RazorDocumentManager
+    ) {}
 
     public async languageQuery(position: vscode.Position, uri: vscode.Uri) {
         await this.ensureStarted();
@@ -50,6 +57,49 @@ export class RazorLanguageServiceClient {
         return response;
     }
 
+    public async mapSpans(params: RazorMapSpansParams): Promise<RazorMapSpansResponse> {
+        const csharpUri = UriConverter.deserialize(params.csharpDocument.uri);
+
+        const request = new RazorMapToDocumentRangesRequest(
+            LanguageKind.CSharp,
+            params.ranges.map(
+                (r) =>
+                    new vscode.Range(
+                        new vscode.Position(r.start.line, r.start.character),
+                        new vscode.Position(r.end.line, r.end.character)
+                    )
+            ),
+            csharpUri
+        );
+
+        const result = await this.serverClient.sendRequest<RazorMapToDocumentRangesResponse>(
+            'razor/mapToDocumentRanges',
+            request
+        );
+
+        if (!result) {
+            return RazorMapSpansResponse.empty;
+        }
+
+        const document = await this.documentManager.getDocumentForCSharpUri(csharpUri);
+        if (!document) {
+            return RazorMapSpansResponse.empty;
+        }
+
+        return new RazorMapSpansResponse(
+            result.ranges.map((r) => {
+                return {
+                    start: { line: r.start.line, character: r.start.character },
+                    end: { line: r.end.line, character: r.end.character },
+                };
+            }),
+            result.spans,
+            {
+                uri: UriConverter.serialize(document.uri),
+            }
+        );
+    }
+
     private async ensureStarted() {
         // If the server is already started this will instantly return.
         await this.serverClient.start();

src/razor/src/rpc/razorMapToDocumentRangesResponse.ts

@@ -4,8 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
+import { razorTextSpan } from '../dynamicFile/razorTextSpan';
 
 export interface RazorMapToDocumentRangesResponse {
     ranges: vscode.Range[];
     hostDocumentVersion: number;
+    spans: razorTextSpan[];
 }