fix: remove unused vscode-languageclient dependency

package.json

@@ -578,7 +578,7 @@
         "lodash": "^4.18.1",
         "lru-cache": "^7.17.0",
         "vscode-extension-telemetry-wrapper": "^0.15.3",
-        "vscode-languageclient": "6.0.0-next.9",
+        "vscode-languageserver-types": "3.18.0",
         "vscode-tas-client": "^0.1.75"
     },
     "overrides": {

src/commands/generationCommands.ts

@@ -1,14 +1,14 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
-import { TextEdit, Uri, window, workspace, WorkspaceEdit } from 'vscode';
-import * as protocolConverter from 'vscode-languageclient/lib/protocolConverter';
+import { Position, Range, SnippetString, SnippetTextEdit, TextEdit, Uri, window, workspace, WorkspaceEdit, WorkspaceEditEntryMetadata } from 'vscode';
+import { AnnotatedTextEdit, ChangeAnnotation, CreateFile, DeleteFile, RenameFile, SnippetTextEdit as ProtocolSnippetTextEdit, TextDocumentEdit, TextEdit as ProtocolTextEdit, WorkspaceEdit as ProtocolWorkspaceEdit } from 'vscode-languageserver-types';
 import { JavaTestRunnerDelegateCommands } from '../constants';
 import { executeJavaLanguageServerCommand } from '../utils/commandUtils';
 
-const converter: protocolConverter.Converter = protocolConverter.createConverter();
 export async function generateTests(uri: Uri, cursorOffset: number): Promise<void> {
-    const edit: WorkspaceEdit = converter.asWorkspaceEdit(await askServerToGenerateTests(uri, cursorOffset));
+    const protocolEdit: ProtocolWorkspaceEdit | undefined = await askServerToGenerateTests(uri, cursorOffset);
+    const edit: WorkspaceEdit | undefined = protocolEdit && asWorkspaceEdit(protocolEdit);
     if (edit) {
         await workspace.applyEdit(edit);
         const entries: [Uri, TextEdit[]][] = edit.entries();
@@ -20,6 +20,58 @@ export async function generateTests(uri: Uri, cursorOffset: number): Promise<voi
     }
 }
 
-async function askServerToGenerateTests(uri: Uri, cursorOffset: number): Promise<any> {
-    return await executeJavaLanguageServerCommand<any>(JavaTestRunnerDelegateCommands.GENERATE_TESTS, uri.toString(), cursorOffset);
+export function asWorkspaceEdit(protocolEdit: ProtocolWorkspaceEdit): WorkspaceEdit {
+    const edit: WorkspaceEdit = new WorkspaceEdit();
+    const metadata: (annotationId?: string) => WorkspaceEditEntryMetadata | undefined = (annotationId?: string): WorkspaceEditEntryMetadata | undefined => {
+        const annotation: ChangeAnnotation | undefined = annotationId ? protocolEdit.changeAnnotations?.[annotationId] : undefined;
+        return annotation && {
+            label: annotation.label,
+            needsConfirmation: !!annotation.needsConfirmation,
+            description: annotation.description,
+        };
+    };
+
+    if (protocolEdit.documentChanges) {
+        for (const change of protocolEdit.documentChanges) {
+            if (CreateFile.is(change)) {
+                edit.createFile(Uri.parse(change.uri), change.options, metadata(change.annotationId));
+            } else if (RenameFile.is(change)) {
+                edit.renameFile(Uri.parse(change.oldUri), Uri.parse(change.newUri), change.options, metadata(change.annotationId));
+            } else if (DeleteFile.is(change)) {
+                edit.deleteFile(Uri.parse(change.uri), change.options, metadata(change.annotationId));
+            } else if (TextDocumentEdit.is(change)) {
+                const edits: [TextEdit | SnippetTextEdit, WorkspaceEditEntryMetadata | undefined][] = change.edits.map(
+                    (textEdit: ProtocolTextEdit | AnnotatedTextEdit | ProtocolSnippetTextEdit): [TextEdit | SnippetTextEdit, WorkspaceEditEntryMetadata | undefined] => {
+                        const range: Range = new Range(
+                            new Position(textEdit.range.start.line, textEdit.range.start.character),
+                            new Position(textEdit.range.end.line, textEdit.range.end.character),
+                        );
+                        if (ProtocolSnippetTextEdit.is(textEdit)) {
+                            return [new SnippetTextEdit(range, new SnippetString(textEdit.snippet.value)), metadata(textEdit.annotationId)];
+                        }
+                        return [new TextEdit(range, textEdit.newText), metadata(AnnotatedTextEdit.is(textEdit) ? textEdit.annotationId : undefined)];
+                    },
+                );
+                edit.set(Uri.parse(change.textDocument.uri), edits);
+            } else {
+                throw new Error(`Unknown workspace edit change received: ${JSON.stringify(change)}`);
+            }
+        }
+    } else if (protocolEdit.changes) {
+        for (const uri of Object.keys(protocolEdit.changes)) {
+            const textEdits: ProtocolTextEdit[] = protocolEdit.changes[uri];
+            edit.set(Uri.parse(uri), textEdits.map((textEdit: ProtocolTextEdit) => new TextEdit(
+                new Range(
+                    new Position(textEdit.range.start.line, textEdit.range.start.character),
+                    new Position(textEdit.range.end.line, textEdit.range.end.character),
+                ),
+                textEdit.newText,
+            )));
+        }
+    }
+    return edit;
+}
+
+async function askServerToGenerateTests(uri: Uri, cursorOffset: number): Promise<ProtocolWorkspaceEdit | undefined> {
+    return await executeJavaLanguageServerCommand<ProtocolWorkspaceEdit | undefined>(JavaTestRunnerDelegateCommands.GENERATE_TESTS, uri.toString(), cursorOffset);
 }

test/suite/generationCommands.test.ts

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import { SnippetTextEdit, TextEdit, Uri, WorkspaceEdit } from 'vscode';
+import { WorkspaceEdit as ProtocolWorkspaceEdit } from 'vscode-languageserver-types';
+import { asWorkspaceEdit } from '../../src/commands/generationCommands';
+
+suite('Generation Commands Tests', () => {
+    test('converts protocol changes to VS Code text edits', () => {
+        const uri: Uri = Uri.file('/workspace/AppTest.java');
+        const protocolEdit: ProtocolWorkspaceEdit = {
+            changes: {
+                [uri.toString()]: [{
+                    range: { start: { line: 1, character: 2 }, end: { line: 3, character: 4 } },
+                    newText: 'generated',
+                }],
+            },
+        };
+
+        const entries = asWorkspaceEdit(protocolEdit).entries();
+
+        assert.strictEqual(entries.length, 1);
+        assert.strictEqual(entries[0][0].toString(), uri.toString());
+        assert.ok(entries[0][1][0] instanceof TextEdit);
+        assert.strictEqual(entries[0][1][0].newText, 'generated');
+        assert.strictEqual(entries[0][1][0].range.start.line, 1);
+        assert.strictEqual(entries[0][1][0].range.start.character, 2);
+        assert.strictEqual(entries[0][1][0].range.end.line, 3);
+        assert.strictEqual(entries[0][1][0].range.end.character, 4);
+    });
+
+    test('converts annotated document and resource changes', () => {
+        const uri: Uri = Uri.file('/workspace/GeneratedTest.java');
+        const protocolEdit: ProtocolWorkspaceEdit = {
+            changeAnnotations: {
+                generated: { label: 'Generate test', needsConfirmation: true },
+            },
+            documentChanges: [
+                { kind: 'create', uri: uri.toString(), annotationId: 'generated' },
+                {
+                    textDocument: { uri: uri.toString(), version: null },
+                    edits: [{
+                        range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+                        snippet: { kind: 'snippet', value: 'class ${1:GeneratedTest} {}' },
+                        annotationId: 'generated',
+                    }],
+                },
+            ],
+        };
+
+        const setSpy = sinon.spy(WorkspaceEdit.prototype, 'set');
+
+        try {
+            asWorkspaceEdit(protocolEdit);
+
+            assert.ok(setSpy.calledOnce);
+            assert.strictEqual(setSpy.firstCall.args[0].toString(), uri.toString());
+            const convertedEdit: unknown = setSpy.firstCall.args[1][0][0];
+            assert.ok(convertedEdit instanceof SnippetTextEdit);
+            assert.strictEqual(convertedEdit.snippet.value, 'class ${1:GeneratedTest} {}');
+        } finally {
+            setSpy.restore();
+        }
+    });
+});