Port the rest of the cohosting endpoints to VS Code (#8249)

davidwengier · web-flow · commit d8c8cd0359db · 2025-05-06T11:14:46.000+10:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,15 @@
 - Debug from .csproj and .sln [#5876](https://github.com/dotnet/vscode-csharp/issues/5876)
 
 # 2.77.x
+* Bump Razor to 10.0.0-preview.25255.4 (PR: [#8249](https://github.com/dotnet/vscode-csharp/pull/8249))
+  * Port remaining cohosting endpoints to VS Code (#11815) (PR: [#11815](https://github.com/dotnet/razor/pull/11815))
+  * Fix cohost semantic tokens in VS Code (#11816) (PR: [#11816](https://github.com/dotnet/razor/pull/11816))
+  * Fix some hardcoded values in cohosting (#11817) (PR: [#11817](https://github.com/dotnet/razor/pull/11817))
+  * Add new shared SelectXXXAsArray helpers (#11796) (PR: [#11796](https://github.com/dotnet/razor/pull/11796))
+* Bump Roslyn to 5.0.0-1.25255.4 (PR: [#8249](https://github.com/dotnet/vscode-csharp/pull/8249))
+  * Ensure hover markdown for supported platforms uses non-breaking spaces for indentation (#78405) (PR: [#78405](https://github.com/dotnet/roslyn/pull/78405))
+  * Change O(n) + O(lg n) search in SolutionState.SortedProjectStates to just O(lg n) (#78427) (PR: [#78427](https://github.com/dotnet/roslyn/pull/78427))
+  * Fix syntax tree creation when modifying source generated documents (#78343) (PR: [#78343](https://github.com/dotnet/roslyn/pull/78343))
 
 # 2.76.x
 * Bump Razor to 10.0.0-preview.25252.1 (PR: [#8239](https://github.com/dotnet/vscode-csharp/pull/8239))
diff --git a/package.json b/package.json
@@ -40,9 +40,9 @@
     "workspace"
   ],
   "defaults": {
-    "roslyn": "5.0.0-1.25252.3",
+    "roslyn": "5.0.0-1.25255.4",
     "omniSharp": "1.39.12",
-    "razor": "10.0.0-preview.25252.1",
+    "razor": "10.0.0-preview.25255.4",
     "razorOmnisharp": "7.0.0-preview.23363.1",
     "xamlTools": "17.14.36010.33"
   },
diff --git a/src/lsptoolshost/razor/razorEndpoints.ts b/src/lsptoolshost/razor/razorEndpoints.ts
@@ -6,28 +6,28 @@
 import * as vscode from 'vscode';
 import { RoslynLanguageServer } from '../server/roslynLanguageServer';
 import {
-    ColorInformation,
-    ColorPresentationParams,
     ColorPresentationRequest,
-    CompletionList,
-    CompletionParams,
     CompletionRequest,
-    DocumentColorParams,
+    DefinitionRequest,
     DocumentColorRequest,
+    DocumentFormattingRequest,
     DocumentHighlight,
     DocumentHighlightKind,
-    DocumentHighlightParams,
     DocumentHighlightRequest,
-    FoldingRange,
-    FoldingRangeParams,
+    DocumentOnTypeFormattingRequest,
     FoldingRangeRequest,
     Hover,
-    HoverParams,
     HoverRequest,
+    ImplementationRequest,
+    Location,
     LogMessageParams,
     MarkupKind,
+    MarkupContent,
     NotificationType,
+    ReferencesRequest,
     RequestType,
+    SignatureHelp,
+    SignatureHelpRequest,
 } from 'vscode-languageclient';
 import { RazorLogger } from '../../razor/src/razorLogger';
 import { HtmlUpdateParameters } from './htmlUpdateParameters';
@@ -37,7 +37,6 @@ import { HtmlDocumentManager } from './htmlDocumentManager';
 import { DocumentColorHandler } from '../../razor/src/documentColor/documentColorHandler';
 import { razorOptions } from '../../shared/options';
 import { ColorPresentationHandler } from '../../razor/src/colorPresentation/colorPresentationHandler';
-import { ColorPresentation } from 'vscode-html-languageservice';
 import { convertRangeToSerializable } from '../../razor/src/rpc/serializableRange';
 import { FoldingRangeHandler } from '../../razor/src/folding/foldingRangeHandler';
 import { CompletionHandler } from '../../razor/src/completion/completionHandler';
@@ -49,6 +48,7 @@ import { RazorMapSpansResponse } from '../../razor/src/mapping/razorMapSpansResp
 import { MappingHandler } from '../../razor/src/mapping/mappingHandler';
 import { RazorMapTextChangesParams } from '../../razor/src/mapping/razorMapTextChangesParams';
 import { RazorMapTextChangesResponse } from '../../razor/src/mapping/razorMapTextChangesResponse';
+import { FormattingHandler } from '../../razor/src/formatting/formattingHandler';
 
 export function registerRazorEndpoints(
     context: vscode.ExtensionContext,
@@ -76,29 +76,26 @@ export function registerRazorEndpoints(
         const documentManager = new HtmlDocumentManager(platformInfo, razorLogger);
         context.subscriptions.push(documentManager.register());
 
-        registerRequestHandler<HtmlUpdateParameters, void>('razor/updateHtml', async (params) => {
+        registerMethodHandler<HtmlUpdateParameters, void>('razor/updateHtml', async (params) => {
             const uri = UriConverter.deserialize(params.textDocument.uri);
             await documentManager.updateDocumentText(uri, params.text);
         });
 
-        registerRequestHandler<DocumentColorParams, ColorInformation[]>(DocumentColorRequest.method, async (params) => {
+        registerRequestHandler(DocumentColorRequest.type, async (params) => {
             const uri = UriConverter.deserialize(params.textDocument.uri);
             const document = await documentManager.getDocument(uri);
 
             return await DocumentColorHandler.doDocumentColorRequest(document.uri);
         });
 
-        registerRequestHandler<ColorPresentationParams, ColorPresentation[]>(
-            ColorPresentationRequest.method,
-            async (params) => {
-                const uri = UriConverter.deserialize(params.textDocument.uri);
-                const document = await documentManager.getDocument(uri);
+        registerRequestHandler(ColorPresentationRequest.type, async (params) => {
+            const uri = UriConverter.deserialize(params.textDocument.uri);
+            const document = await documentManager.getDocument(uri);
 
-                return await ColorPresentationHandler.doColorPresentationRequest(document.uri, params);
-            }
-        );
+            return await ColorPresentationHandler.doColorPresentationRequest(document.uri, params);
+        });
 
-        registerRequestHandler<FoldingRangeParams, FoldingRange[]>(FoldingRangeRequest.method, async (params) => {
+        registerRequestHandler(FoldingRangeRequest.type, async (params) => {
             const uri = UriConverter.deserialize(params.textDocument.uri);
             const document = await documentManager.getDocument(uri);
 
@@ -110,7 +107,7 @@ export function registerRazorEndpoints(
             return FoldingRangeHandler.convertFoldingRanges(results, razorLogger);
         });
 
-        registerRequestHandler<HoverParams, Hover | undefined>(HoverRequest.method, async (params) => {
+        registerRequestHandler(HoverRequest.type, async (params) => {
             const uri = UriConverter.deserialize(params.textDocument.uri);
             const document = await documentManager.getDocument(uri);
 
@@ -124,23 +121,20 @@ export function registerRazorEndpoints(
             return rewriteHover(applicableHover);
         });
 
-        registerRequestHandler<DocumentHighlightParams, DocumentHighlight[]>(
-            DocumentHighlightRequest.method,
-            async (params) => {
-                const uri = UriConverter.deserialize(params.textDocument.uri);
-                const document = await documentManager.getDocument(uri);
+        registerRequestHandler(DocumentHighlightRequest.type, async (params) => {
+            const uri = UriConverter.deserialize(params.textDocument.uri);
+            const document = await documentManager.getDocument(uri);
 
-                const results = await vscode.commands.executeCommand<vscode.DocumentHighlight[]>(
-                    'vscode.executeDocumentHighlights',
-                    document.uri,
-                    params.position
-                );
+            const results = await vscode.commands.executeCommand<vscode.DocumentHighlight[]>(
+                'vscode.executeDocumentHighlights',
+                document.uri,
+                params.position
+            );
 
-                return rewriteHighlight(results);
-            }
-        );
+            return rewriteHighlight(results);
+        });
 
-        registerRequestHandler<CompletionParams, CompletionList>(CompletionRequest.method, async (params) => {
+        registerRequestHandler(CompletionRequest.type, async (params) => {
             const uri = UriConverter.deserialize(params.textDocument.uri);
             const document = await documentManager.getDocument(uri);
 
@@ -150,24 +144,108 @@ export function registerRazorEndpoints(
                 params.context?.triggerCharacter
             );
         });
+
+        registerRequestHandler(ReferencesRequest.type, async (params) => {
+            const uri = UriConverter.deserialize(params.textDocument.uri);
+            const document = await documentManager.getDocument(uri);
+
+            const results = await vscode.commands.executeCommand<vscode.Location[]>(
+                'vscode.executeReferenceProvider',
+                document.uri,
+                params.position
+            );
+
+            return rewriteLocations(results);
+        });
+
+        registerRequestHandler(ImplementationRequest.type, async (params) => {
+            const uri = UriConverter.deserialize(params.textDocument.uri);
+            const document = await documentManager.getDocument(uri);
+
+            const results = await vscode.commands.executeCommand<vscode.Location[]>(
+                'vscode.executeImplementationProvider',
+                document.uri,
+                params.position
+            );
+
+            return rewriteLocations(results);
+        });
+
+        registerRequestHandler(DefinitionRequest.type, async (params) => {
+            const uri = UriConverter.deserialize(params.textDocument.uri);
+            const document = await documentManager.getDocument(uri);
+
+            const results = await vscode.commands.executeCommand<vscode.Location[]>(
+                'vscode.executeDefinitionProvider',
+                document.uri,
+                params.position
+            );
+
+            return rewriteLocations(results);
+        });
+
+        registerRequestHandler(SignatureHelpRequest.type, async (params) => {
+            const uri = UriConverter.deserialize(params.textDocument.uri);
+            const document = await documentManager.getDocument(uri);
+
+            const results = await vscode.commands.executeCommand<vscode.SignatureHelp>(
+                'vscode.executeSignatureHelpProvider',
+                document.uri,
+                params.position
+            );
+
+            if (!results) {
+                return undefined;
+            }
+
+            return rewriteSignatureHelp(results);
+        });
+
+        registerRequestHandler(DocumentFormattingRequest.type, async (params) => {
+            const uri = UriConverter.deserialize(params.textDocument.uri);
+            const document = await documentManager.getDocument(uri);
+
+            const content = document.getContent();
+            const options = <vscode.FormattingOptions>params.options;
+
+            const response = await FormattingHandler.getHtmlFormattingResult(document.uri, content, options);
+            return response?.edits;
+        });
+
+        registerRequestHandler(DocumentOnTypeFormattingRequest.type, async (params) => {
+            const uri = UriConverter.deserialize(params.textDocument.uri);
+            const document = await documentManager.getDocument(uri);
+
+            const content = document.getContent();
+            const options = <vscode.FormattingOptions>params.options;
+
+            const response = await FormattingHandler.getHtmlOnTypeFormattingResult(
+                document.uri,
+                content,
+                params.position,
+                params.ch,
+                options
+            );
+            return response?.edits;
+        });
     }
 
     function registerNonCohostingEndpoints() {
-        registerRequestHandler<ProvideDynamicFileParams, ProvideDynamicFileResponse>(
+        registerMethodHandler<ProvideDynamicFileParams, ProvideDynamicFileResponse>(
             'razor/provideDynamicFileInfo',
             async (params) =>
                 vscode.commands.executeCommand(DynamicFileInfoHandler.provideDynamicFileInfoCommand, params)
         );
 
-        registerRequestHandler<ProvideDynamicFileParams, ProvideDynamicFileResponse>(
+        registerMethodHandler<ProvideDynamicFileParams, ProvideDynamicFileResponse>(
             'razor/removeDynamicFileInfo',
             async (params) =>
                 vscode.commands.executeCommand(DynamicFileInfoHandler.provideDynamicFileInfoCommand, params)
         );
-        registerRequestHandler<RazorMapSpansParams, RazorMapSpansResponse>('razor/mapSpans', async (params) => {
+        registerMethodHandler<RazorMapSpansParams, RazorMapSpansResponse>('razor/mapSpans', async (params) => {
             return await vscode.commands.executeCommand<RazorMapSpansResponse>(MappingHandler.MapSpansCommand, params);
         });
-        registerRequestHandler<RazorMapTextChangesParams, RazorMapTextChangesResponse>(
+        registerMethodHandler<RazorMapTextChangesParams, RazorMapTextChangesResponse>(
             'razor/mapTextChanges',
             async (params) => {
                 return await vscode.commands.executeCommand<RazorMapTextChangesResponse>(
@@ -179,7 +257,14 @@ export function registerRazorEndpoints(
     }
 
     // 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>) {
+    function registerRequestHandler<Params, Result, Error>(
+        type: RequestType<Params, Result, Error>,
+        invocation: (params: Params) => Promise<Result>
+    ) {
+        return registerMethodHandler<Params, Result>(type.method, invocation);
+    }
+
+    function registerMethodHandler<Params, Result>(method: string, invocation: (params: Params) => Promise<Result>) {
         const requestType = new RequestType<Params, Result, Error>(method);
         roslynLanguageServer.registerOnRequest(requestType, async (params) => {
             try {
@@ -235,3 +320,47 @@ function convertHighlightKind(kind: vscode.DocumentHighlightKind | undefined): D
             return undefined;
     }
 }
+
+function rewriteLocations(locations: vscode.Location[]): Location[] {
+    return locations.map((location) => {
+        return {
+            uri: UriConverter.serialize(location.uri),
+            range: convertRangeToSerializable(location.range),
+        };
+    });
+}
+
+function rewriteSignatureHelp(signatureHelp: vscode.SignatureHelp): SignatureHelp {
+    return {
+        activeParameter: signatureHelp.activeParameter ?? undefined,
+        activeSignature: signatureHelp.activeSignature ?? undefined,
+        signatures: signatureHelp.signatures.map((signature) => {
+            return {
+                label: signature.label,
+                documentation: rewriteMarkdownString(signature.documentation),
+                parameters: signature.parameters.map((parameter) => {
+                    return {
+                        label: parameter.label,
+                        documentation: rewriteMarkdownString(parameter.documentation),
+                    };
+                }),
+            };
+        }),
+    };
+}
+
+function rewriteMarkdownString(documentation: string | vscode.MarkdownString | undefined): MarkupContent | undefined {
+    if (!documentation) {
+        return undefined;
+    }
+
+    if ((documentation as vscode.MarkdownString).value) {
+        const markdownString = documentation as vscode.MarkdownString;
+        return {
+            kind: MarkupKind.Markdown,
+            value: markdownString.value,
+        };
+    }
+
+    return { kind: MarkupKind.PlainText, value: <string>documentation };
+}
diff --git a/src/razor/src/formatting/formattingHandler.ts b/src/razor/src/formatting/formattingHandler.ts
