Add support for InlayHint.TextEdits

Author: JoeRobich

package-lock.json

@@ -95,7 +95,7 @@
     "@types/semver": "5.5.0",
     "@types/tmp": "0.0.33",
     "@types/unzipper": "^0.9.1",
-    "@types/vscode": "1.65.0",
+    "@types/vscode": "1.66.0",
     "@types/yauzl": "2.9.1",
     "archiver": "5.3.0",
     "chai": "4.3.4",
@@ -541,7 +541,7 @@
     }
   ],
   "engines": {
-    "vscode": "^1.65.0"
+    "vscode": "^1.66.0"
   },
   "activationEvents": [
     "onDebugInitialConfigurations",

package.json

@@ -8,8 +8,8 @@ import AbstractProvider from './abstractProvider';
 import { OmniSharpServer } from '../omnisharp/server';
 import { LanguageMiddlewareFeature } from '../omnisharp/LanguageMiddlewareFeature';
 import CompositeDisposable from '../CompositeDisposable';
-import { InlayHint, InlayHintRequest, InlayHintResolve as InlayHintResolveRequest } from '../omnisharp/protocol';
-import { fromVSCodeRange, toVSCodePosition } from '../omnisharp/typeConversion';
+import { InlayHint, InlayHintRequest, InlayHintResolve as InlayHintResolveRequest, LinePositionSpanTextChange } from '../omnisharp/protocol';
+import { fromVSCodeRange, toVSCodePosition, toVSCodeTextEdit } from '../omnisharp/typeConversion';
 import { isVirtualCSharpDocument } from './virtualDocumentTracker';
 
 export default class CSharpInlayHintProvider extends AbstractProvider implements vscode.InlayHintsProvider {
@@ -34,7 +34,7 @@ export default class CSharpInlayHintProvider extends AbstractProvider implements
         if (document.uri.scheme !== "file") {
             return [];
         }
-        
+
         if (isVirtualCSharpDocument(document)) {
             return [];
         }
@@ -50,7 +50,7 @@ export default class CSharpInlayHintProvider extends AbstractProvider implements
             const hints = await serverUtils.getInlayHints(this._server, request, token);
 
             return hints.InlayHints.map((inlayHint): vscode.InlayHint => {
-                const mappedHint = this.toVscodeHint(inlayHint);
+                const mappedHint = this.toVSCodeHint(inlayHint);
                 this._hintsMap.set(mappedHint, inlayHint);
                 return mappedHint;
             });
@@ -68,17 +68,22 @@ export default class CSharpInlayHintProvider extends AbstractProvider implements
 
         try {
             const result = await serverUtils.resolveInlayHints(this._server, request, token);
-            return this.toVscodeHint(result);
+            return this.toVSCodeHint(result);
         } catch (error) {
             return Promise.reject(`Problem invoking 'ResolveInlayHints' on OmniSharpServer: ${error}`);
         }
     }
 
-    private toVscodeHint(inlayHint: InlayHint): vscode.InlayHint {
+    private toVSCodeHint(inlayHint: InlayHint): vscode.InlayHint {
         return {
             label: inlayHint.Label,
             position: toVSCodePosition(inlayHint.Position),
-            tooltip: new vscode.MarkdownString(inlayHint.Tooltip ?? "")
+            tooltip: new vscode.MarkdownString(inlayHint.Tooltip ?? ""),
+            textEdits: toVSCodeTextEdits(inlayHint.TextEdits),
         };
+
+        function toVSCodeTextEdits(textEdits: LinePositionSpanTextChange[]): vscode.TextEdit[] {
+            return textEdits ? textEdits.map(toVSCodeTextEdit) : undefined;
+        }
     }
 }

src/features/inlayHintProvider.ts

@@ -592,6 +592,7 @@ export interface InlayHint {
     Label: string;
     Tooltip?: string;
     Data: any;
+    TextEdits?: LinePositionSpanTextChange[];
 }
 
 export interface InlayHintResponse {

src/omnisharp/protocol.ts

@@ -62,6 +62,16 @@ export function toVSCodePosition(point: protocol.V2.Point): vscode.Position {
     return new vscode.Position(point.Line, point.Column);
 }
 
+export function toVSCodeTextEdit(textChange: protocol.LinePositionSpanTextChange): vscode.TextEdit {
+    return new vscode.TextEdit(toVSCodeRange(textChange), textChange.NewText);
+
+    function toVSCodeRange(textChange: protocol.LinePositionSpanTextChange): vscode.Range {
+        const newStart = new vscode.Position(textChange.StartLine, textChange.StartColumn);
+        const newEnd = new vscode.Position(textChange.EndLine, textChange.EndColumn);
+        return new vscode.Range(newStart, newEnd);
+    }
+}
+
 export function createRequest<T extends protocol.Request>(document: vscode.TextDocument, where: vscode.Position | vscode.Range, includeBuffer: boolean = false): T {
 
     let Line: number, Column: number;

src/omnisharp/typeConversion.ts

@@ -9,6 +9,7 @@ import { should, assert } from 'chai';
 import { activateCSharpExtension, isRazorWorkspace, isSlnWithGenerator, restartOmniSharpServer } from './integrationHelpers';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
 import * as path from 'path';
+import { InlayHint, LinePositionSpanTextChange } from '../../src/omnisharp/protocol';
 
 const chai = require('chai');
 chai.use(require('chai-arrays'));
@@ -49,7 +50,7 @@ suite(`Inlay Hints ${testAssetWorkspace.description}`, function () {
         const projectDirectory = testAssetWorkspace.projects[0].projectDirectoryPath;
         const filePath = path.join(projectDirectory, fileName);
         fileUri = vscode.Uri.file(filePath);
-        
+
         await vscode.commands.executeCommand("vscode.open", fileUri);
         await testAssetWorkspace.waitForIdle(activation.eventStream);
     });
@@ -60,19 +61,42 @@ suite(`Inlay Hints ${testAssetWorkspace.description}`, function () {
 
     test("Hints retrieved for region", async () => {
         const range = new vscode.Range(new vscode.Position(4, 8), new vscode.Position(15, 85));
-        const hints : vscode.InlayHint[] = await vscode.commands.executeCommand('vscode.executeInlayHintProvider', fileUri, range);
+        const hints: vscode.InlayHint[] = await vscode.commands.executeCommand('vscode.executeInlayHintProvider', fileUri, range);
+
         assert.lengthOf(hints, 6);
-        assertValues(hints[0], 'InlayHints ', 6, 12);
-        assertValues(hints[1], ' InlayHints', 7, 27);
-        assertValues(hints[2], 'string ', 8, 28);
-        assertValues(hints[3], 'i: ', 9, 17);
-        assertValues(hints[4], 'param1: ', 10, 15);
-        assertValues(hints[5], 'param1: ', 11, 27);
-
-        function assertValues(hint: vscode.InlayHint, expectedLabel: string, expectedLine: number, expectedCharacter: number) {
-            assert.equal(hint.label, expectedLabel);
-            assert.equal(hint.position.line, expectedLine);
-            assert.equal(hint.position.character, expectedCharacter);
+
+        assertInlayHintEqual(hints[0], { Label: 'InlayHints ', Position: { Line: 6, Column: 12 }, Data: {}, TextEdits: [{ StartLine: 6, StartColumn: 8, EndLine: 6, EndColumn: 11, NewText: 'InlayHints' }] });
+        assertInlayHintEqual(hints[1], { Label: ' InlayHints', Position: { Line: 7, Column: 27 }, Data: {}, TextEdits: [{ StartLine: 7, StartColumn: 27, EndLine: 7, EndColumn: 27, NewText: ' InlayHints' }] });
+        assertInlayHintEqual(hints[2], { Label: 'string ', Position: { Line: 8, Column: 28 }, Data: {}, TextEdits: [{ StartLine: 8, StartColumn: 28, EndLine: 8, EndColumn: 28, NewText: 'string ' }] });
+        assertInlayHintEqual(hints[3], { Label: 'i: ', Position: { Line: 9, Column: 17 }, Data: {}, TextEdits: [{ StartLine: 9, StartColumn: 17, EndLine: 9, EndColumn: 17, NewText: 'i: ' }] });
+        assertInlayHintEqual(hints[4], { Label: 'param1: ', Position: { Line: 10, Column: 15 }, Data: {}, TextEdits: [{ StartLine: 10, StartColumn: 15, EndLine: 10, EndColumn: 15, NewText: 'param1: ' }] });
+        assertInlayHintEqual(hints[5], { Label: 'param1: ', Position: { Line: 11, Column: 27 }, Data: {}, TextEdits: [{ StartLine: 11, StartColumn: 27, EndLine: 11, EndColumn: 27, NewText: 'param1: ' }] });
+
+        function assertInlayHintEqual(actual: vscode.InlayHint, expected: InlayHint) {
+            assert.equal(actual.label, expected.Label);
+            assert.equal(actual.position.line, expected.Position.Line);
+            assert.equal(actual.position.character, expected.Position.Column);
+
+            if (!actual.textEdits) {
+                assert.isUndefined(expected.TextEdits);
+                return;
+            }
+
+            assert.equal(actual.textEdits.length, expected.TextEdits.length);
+            for (let i = 0; i < actual.textEdits.length; i++) {
+                const actualTextEdit = actual.textEdits[i];
+                const expectedTextEdit = expected.TextEdits[i];
+
+                assertTextEditEqual(actualTextEdit, expectedTextEdit);
+            }
+        }
+
+        function assertTextEditEqual(actual: vscode.TextEdit, expected: LinePositionSpanTextChange) {
+            assert.equal(actual.range.start.line, expected.StartLine);
+            assert.equal(actual.range.start.character, expected.StartColumn);
+            assert.equal(actual.range.end.line, expected.EndLine);
+            assert.equal(actual.range.end.character, expected.EndColumn);
+            assert.equal(actual.newText, expected.NewText);
         }
     });
 });