Support more endpoints

Author: davidwengier

src/lsptoolshost/razor/razorEndpoints.ts

@@ -3,15 +3,29 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { RoslynLanguageServer } from '../server/roslynLanguageServer';
 import * as vscode from 'vscode';
+import { RoslynLanguageServer } from '../server/roslynLanguageServer';
 import {
     ColorInformation,
     ColorPresentationParams,
     ColorPresentationRequest,
+    CompletionList,
+    CompletionParams,
+    CompletionRequest,
     DocumentColorParams,
     DocumentColorRequest,
+    DocumentHighlight,
+    DocumentHighlightKind,
+    DocumentHighlightParams,
+    DocumentHighlightRequest,
+    FoldingRange,
+    FoldingRangeParams,
+    FoldingRangeRequest,
+    Hover,
+    HoverParams,
+    HoverRequest,
     LogMessageParams,
+    MarkupKind,
     NotificationType,
     RequestType,
 } from 'vscode-languageclient';
@@ -24,6 +38,9 @@ import { DocumentColorHandler } from '../../razor/src/documentColor/documentColo
 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';
 
 export function registerRazorEndpoints(
     context: vscode.ExtensionContext,
@@ -65,6 +82,59 @@ export function registerRazorEndpoints(
         }
     );
 
+    registerRequestHandler<FoldingRangeParams, FoldingRange[]>(FoldingRangeRequest.method, async (params) => {
+        const uri = UriConverter.deserialize(params.textDocument.uri);
+        const document = await documentManager.getDocument(uri);
+
+        const results = await vscode.commands.executeCommand<vscode.FoldingRange[]>(
+            'vscode.executeFoldingRangeProvider',
+            document.uri
+        );
+
+        return FoldingRangeHandler.convertFoldingRanges(results, razorLogger);
+    });
+
+    registerRequestHandler<HoverParams, Hover | undefined>(HoverRequest.method, async (params) => {
+        const uri = UriConverter.deserialize(params.textDocument.uri);
+        const document = await documentManager.getDocument(uri);
+
+        const results = await vscode.commands.executeCommand<vscode.Hover[]>(
+            'vscode.executeHoverProvider',
+            document.uri,
+            params.position
+        );
+        const applicableHover = results.filter((item) => item.range)[0];
+
+        return rewriteHover(applicableHover);
+    });
+
+    registerRequestHandler<DocumentHighlightParams, DocumentHighlight[]>(
+        DocumentHighlightRequest.method,
+        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
+            );
+
+            return rewriteHighlight(results);
+        }
+    );
+
+    registerRequestHandler<CompletionParams, CompletionList>(CompletionRequest.method, async (params) => {
+        const uri = UriConverter.deserialize(params.textDocument.uri);
+        const document = await documentManager.getDocument(uri);
+
+        return CompletionHandler.provideVscodeCompletions(
+            document.uri,
+            params.position,
+            params.context?.triggerCharacter
+        );
+    });
+
     // 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);
@@ -78,3 +148,47 @@ export function registerRazorEndpoints(
         });
     }
 }
+
+function rewriteHover(hover: vscode.Hover): Hover | undefined {
+    if (!hover) {
+        return undefined;
+    }
+
+    const markdownString = new vscode.MarkdownString();
+    for (const content of hover.contents) {
+        if ((content as { language: string; value: string }).language) {
+            const contentObject = content as { language: string; value: string };
+            markdownString.appendCodeblock(contentObject.value, contentObject.language);
+        } else {
+            const contentValue = (content as vscode.MarkdownString).value;
+            markdownString.appendMarkdown(contentValue);
+        }
+    }
+
+    return {
+        contents: { kind: MarkupKind.Markdown, value: markdownString.value },
+        range: hover.range ? convertRangeToSerializable(hover.range) : undefined,
+    };
+}
+
+function rewriteHighlight(highlights: vscode.DocumentHighlight[]): DocumentHighlight[] {
+    return highlights.map((highlight) => {
+        return {
+            range: convertRangeToSerializable(highlight.range),
+            kind: convertHighlightKind(highlight.kind),
+        };
+    });
+}
+
+function convertHighlightKind(kind: vscode.DocumentHighlightKind | undefined): DocumentHighlightKind | undefined {
+    switch (kind) {
+        case vscode.DocumentHighlightKind.Text:
+            return DocumentHighlightKind.Text;
+        case vscode.DocumentHighlightKind.Read:
+            return DocumentHighlightKind.Read;
+        case vscode.DocumentHighlightKind.Write:
+            return DocumentHighlightKind.Write;
+        default:
+            return undefined;
+    }
+}

src/razor/src/completion/completionHandler.ts

@@ -137,7 +137,7 @@ export class CompletionHandler {
             }
 
             // HTML completion - provided via vscode command
-            return this.provideVscodeCompletions(
+            return CompletionHandler.provideVscodeCompletions(
                 virtualDocument.uri,
                 delegatedCompletionParams.projectedPosition,
                 modifiedTriggerCharacter
@@ -372,7 +372,7 @@ export class CompletionHandler {
 
     // Provide completions using standard vscode executeCompletionItemProvider command
     // Used in HTML context
-    private async provideVscodeCompletions(
+    public static async provideVscodeCompletions(
         virtualDocumentUri: vscode.Uri,
         projectedPosition: Position,
         triggerCharacter: string | undefined

src/razor/src/folding/foldingRangeHandler.ts

@@ -63,11 +63,11 @@ export class FoldingRangeHandler {
             const convertedHtmlFoldingRanges =
                 htmlFoldingRanges === undefined
                     ? new Array<FoldingRange>()
-                    : this.convertFoldingRanges(htmlFoldingRanges);
+                    : FoldingRangeHandler.convertFoldingRanges(htmlFoldingRanges, this.logger);
             const convertedCSharpFoldingRanges =
                 csharpFoldingRanges === undefined
                     ? new Array<FoldingRange>()
-                    : this.convertFoldingRanges(csharpFoldingRanges);
+                    : FoldingRangeHandler.convertFoldingRanges(csharpFoldingRanges, this.logger);
 
             const response = new SerializableFoldingRangeResponse(
                 convertedHtmlFoldingRanges,
@@ -81,15 +81,18 @@ export class FoldingRangeHandler {
         return this.emptyFoldingRangeReponse;
     }
 
-    private convertFoldingRanges(foldingRanges: vscode.FoldingRange[]) {
+    public static convertFoldingRanges(foldingRanges: vscode.FoldingRange[], logger: RazorLogger) {
         const convertedFoldingRanges = new Array<FoldingRange>();
         foldingRanges.forEach((foldingRange) => {
             const convertedFoldingRange: FoldingRange = {
                 startLine: foldingRange.start,
                 startCharacter: 0,
                 endLine: foldingRange.end,
                 endCharacter: 0,
-                kind: foldingRange.kind === undefined ? undefined : this.convertFoldingRangeKind(foldingRange.kind),
+                kind:
+                    foldingRange.kind === undefined
+                        ? undefined
+                        : FoldingRangeHandler.convertFoldingRangeKind(foldingRange.kind, logger),
             };
 
             convertedFoldingRanges.push(convertedFoldingRange);
@@ -98,15 +101,15 @@ export class FoldingRangeHandler {
         return convertedFoldingRanges;
     }
 
-    private convertFoldingRangeKind(kind: vscode.FoldingRangeKind) {
+    private static convertFoldingRangeKind(kind: vscode.FoldingRangeKind, logger: RazorLogger) {
         if (kind === vscode.FoldingRangeKind.Comment) {
             return FoldingRangeKind.Comment;
         } else if (kind === vscode.FoldingRangeKind.Imports) {
             return FoldingRangeKind.Imports;
         } else if (kind === vscode.FoldingRangeKind.Region) {
             return FoldingRangeKind.Region;
         } else {
-            this.logger.logWarning(`Unexpected FoldingRangeKind ${kind}`);
+            logger.logWarning(`Unexpected FoldingRangeKind ${kind}`);
             return undefined;
         }
     }