typescript-language-server 0.11.1 → 1.1.0

package/lib/lsp-server.spec.js

@@ -1,120 +1,90 @@
-"use strict";
 /*
  * Copyright (C) 2017, 2018 TypeFox and others.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const chai = __importStar(require("chai"));
-const lsp = __importStar(require("vscode-languageserver/node"));
-const lspcalls = __importStar(require("./lsp-protocol.calls.proposed"));
-const test_utils_1 = require("./test-utils");
-const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
-const types_1 = require("./utils/types");
+import * as chai from 'chai';
+import fs from 'fs-extra';
+import * as lsp from 'vscode-languageserver';
+import * as lspcalls from './lsp-protocol.calls.proposed.js';
+import { uri, createServer, position, lastPosition, filePath, positionAfter, readContents, toPlatformEOL } from './test-utils.js';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Commands } from './commands.js';
+import { CodeActionKind } from './utils/types.js';
 const assert = chai.assert;
 const diagnostics = new Map();
 let server;
-before(() => __awaiter(void 0, void 0, void 0, function* () {
-    server = yield (0, test_utils_1.createServer)({
-        rootUri: null,
-        publishDiagnostics: args => diagnostics.set(args.uri, args)
+before(async () => {
+    server = await createServer({
+        rootUri: uri(),
+        publishDiagnostics: args => diagnostics.set(args.uri, args),
     });
     server.didChangeConfiguration({
         settings: {
             completions: {
-                completeFunctionCalls: true
-            }
-        }
+                completeFunctionCalls: true,
+            },
+        },
     });
-}));
+});
 beforeEach(() => {
     server.closeAll();
     // "closeAll" triggers final publishDiagnostics with an empty list so clear last.
     diagnostics.clear();
+    server.workspaceEdits = [];
 });
 after(() => {
     server.closeAll();
+    server.shutdown();
 });
 describe('completion', () => {
-    it('simple test', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('simple test', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         export function foo(): void {
           console.log('test')
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        const pos = (0, test_utils_1.position)(doc, 'console');
-        const proposals = yield server.completion({ textDocument: doc, position: pos });
+        const pos = position(doc, 'console');
+        const proposals = await server.completion({ textDocument: doc, position: pos });
         assert.isNotNull(proposals);
         assert.isAtLeast(proposals.items.length, 800);
         const item = proposals.items.find(i => i.label === 'addEventListener');
         assert.isDefined(item);
-        const resolvedItem = yield server.completionResolve(item);
+        const resolvedItem = await server.completionResolve(item);
         assert.isNotTrue(resolvedItem.deprecated, 'resolved item is not deprecated');
         assert.isDefined(resolvedItem.detail);
         server.didCloseTextDocument({ textDocument: doc });
-    })).timeout(10000);
-    it('simple JS test', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('simple JS test', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.js'),
+            uri: uri('bar.js'),
             languageId: 'javascript',
             version: 1,
             text: `
         export function foo() {
           console.log('test')
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        const pos = (0, test_utils_1.position)(doc, 'console');
-        const proposals = yield server.completion({ textDocument: doc, position: pos });
+        const pos = position(doc, 'console');
+        const proposals = await server.completion({ textDocument: doc, position: pos });
         assert.isNotNull(proposals);
         assert.isAtLeast(proposals.items.length, 800);
         const item = proposals.items.find(i => i.label === 'addEventListener');
         assert.isDefined(item);
-        const resolvedItem = yield server.completionResolve(item);
+        const resolvedItem = await server.completionResolve(item);
         assert.isDefined(resolvedItem.detail);
         const containsInvalidCompletions = proposals.items.reduce((accumulator, current) => {
             if (accumulator) {
@@ -126,10 +96,10 @@ describe('completion', () => {
         }, false);
         assert.isFalse(containsInvalidCompletions);
         server.didCloseTextDocument({ textDocument: doc });
-    })).timeout(10000);
-    it('deprecated by JSDoc', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('deprecated by JSDoc', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
@@ -142,58 +112,58 @@ describe('completion', () => {
             }
 
             foo(); // call me
-            `
+            `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        const pos = (0, test_utils_1.position)(doc, 'foo(); // call me');
-        const proposals = yield server.completion({ textDocument: doc, position: pos });
+        const pos = position(doc, 'foo(); // call me');
+        const proposals = await server.completion({ textDocument: doc, position: pos });
         assert.isNotNull(proposals);
         const item = proposals.items.find(i => i.label === 'foo');
         assert.isDefined(item);
-        const resolvedItem = yield server.completionResolve(item);
+        const resolvedItem = await server.completionResolve(item);
         assert.isDefined(resolvedItem.detail);
         assert.isArray(resolvedItem.tags);
         assert.include(resolvedItem.tags, lsp.CompletionItemTag.Deprecated, 'resolved item is deprecated');
         server.didCloseTextDocument({ textDocument: doc });
-    })).timeout(10000);
-    it('incorrect source location', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('incorrect source location', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         export function foo(): void {
           console.log('test')
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        const pos = (0, test_utils_1.position)(doc, 'foo');
-        const proposals = yield server.completion({ textDocument: doc, position: pos });
+        const pos = position(doc, 'foo');
+        const proposals = await server.completion({ textDocument: doc, position: pos });
         assert.isNull(proposals);
         server.didCloseTextDocument({ textDocument: doc });
-    })).timeout(10000);
-    it('includes completions from global modules', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('includes completions from global modules', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'pathex'
+            text: 'pathex',
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: (0, test_utils_1.position)(doc, 'ex') });
+        const proposals = await server.completion({ textDocument: doc, position: position(doc, 'ex') });
         assert.isNotNull(proposals);
         const pathExistsCompletion = proposals.items.find(completion => completion.label === 'pathExists');
         assert.isDefined(pathExistsCompletion);
         server.didCloseTextDocument({ textDocument: doc });
-    })).timeout(10000);
-    it('includes completions with invalid identifier names', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('includes completions with invalid identifier names', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
@@ -203,159 +173,159 @@ describe('completion', () => {
 
                 const foo: Foo
                 foo.i
-            `
+            `,
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: (0, test_utils_1.positionAfter)(doc, '.i') });
+        const proposals = await server.completion({ textDocument: doc, position: positionAfter(doc, '.i') });
         assert.isNotNull(proposals);
         const completion = proposals.items.find(completion => completion.label === 'invalid-identifier-name');
         assert.isDefined(completion);
         assert.isDefined(completion.textEdit);
         assert.equal(completion.textEdit.newText, '["invalid-identifier-name"]');
         server.didCloseTextDocument({ textDocument: doc });
-    })).timeout(10000);
-    it('includes detail field with package name for auto-imports', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('includes detail field with package name for auto-imports', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'readFile'
+            text: 'readFile',
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: (0, test_utils_1.positionAfter)(doc, 'readFile') });
+        const proposals = await server.completion({ textDocument: doc, position: positionAfter(doc, 'readFile') });
         assert.isNotNull(proposals);
         const completion = proposals.items.find(completion => completion.label === 'readFile');
         assert.isDefined(completion);
         assert.strictEqual(completion.detail, 'fs');
         assert.strictEqual(completion.insertTextFormat, /* snippet */ 2);
         server.didCloseTextDocument({ textDocument: doc });
-    })).timeout(10000);
-    it('resolves text edit for auto-import completion', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('resolves text edit for auto-import completion', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'readFile'
+            text: 'readFile',
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: (0, test_utils_1.positionAfter)(doc, 'readFile') });
+        const proposals = await server.completion({ textDocument: doc, position: positionAfter(doc, 'readFile') });
         assert.isNotNull(proposals);
         const completion = proposals.items.find(completion => completion.label === 'readFile');
         assert.isDefined(completion);
-        const resolvedItem = yield server.completionResolve(completion);
+        const resolvedItem = await server.completionResolve(completion);
         assert.deepEqual(resolvedItem.additionalTextEdits, [
             {
                 newText: 'import { readFile } from "fs";\n\n',
                 range: {
                     end: {
                         character: 0,
-                        line: 0
+                        line: 0,
                     },
                     start: {
                         character: 0,
-                        line: 0
-                    }
-                }
-            }
+                        line: 0,
+                    },
+                },
+            },
         ]);
         server.didCloseTextDocument({ textDocument: doc });
-    })).timeout(10000);
-    it('resolves text edit for auto-import completion in right format', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('resolves text edit for auto-import completion in right format', async () => {
         server.didChangeConfiguration({
             settings: {
                 typescript: {
                     format: {
                         semicolons: 'remove',
-                        insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: false
-                    }
-                }
-            }
+                        insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: false,
+                    },
+                },
+            },
         });
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'readFile'
+            text: 'readFile',
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: (0, test_utils_1.positionAfter)(doc, 'readFile') });
+        const proposals = await server.completion({ textDocument: doc, position: positionAfter(doc, 'readFile') });
         assert.isNotNull(proposals);
         const completion = proposals.items.find(completion => completion.label === 'readFile');
         assert.isDefined(completion);
-        const resolvedItem = yield server.completionResolve(completion);
+        const resolvedItem = await server.completionResolve(completion);
         assert.deepEqual(resolvedItem.additionalTextEdits, [
             {
                 newText: 'import {readFile} from "fs"\n\n',
                 range: {
                     end: {
                         character: 0,
-                        line: 0
+                        line: 0,
                     },
                     start: {
                         character: 0,
-                        line: 0
-                    }
-                }
-            }
+                        line: 0,
+                    },
+                },
+            },
         ]);
         server.didCloseTextDocument({ textDocument: doc });
         server.didChangeConfiguration({
             settings: {
                 completions: {
-                    completeFunctionCalls: true
+                    completeFunctionCalls: true,
                 },
                 typescript: {
                     format: {
                         semicolons: 'ignore',
-                        insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true
-                    }
-                }
-            }
+                        insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+                    },
+                },
+            },
         });
-    })).timeout(10000);
-    it('resolves a snippet for method completion', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('resolves a snippet for method completion', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
                 import fs from 'fs'
                 fs.readFile
-            `
+            `,
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: (0, test_utils_1.positionAfter)(doc, 'readFile') });
+        const proposals = await server.completion({ textDocument: doc, position: positionAfter(doc, 'readFile') });
         assert.isNotNull(proposals);
         const completion = proposals.items.find(completion => completion.label === 'readFile');
         assert.strictEqual(completion.insertTextFormat, lsp.InsertTextFormat.Snippet);
         assert.strictEqual(completion.label, 'readFile');
-        const resolvedItem = yield server.completionResolve(completion);
+        const resolvedItem = await server.completionResolve(completion);
         assert.strictEqual(resolvedItem.insertTextFormat, lsp.InsertTextFormat.Snippet);
         // eslint-disable-next-line no-template-curly-in-string
         assert.strictEqual(resolvedItem.insertText, 'readFile(${1:path}, ${2:options}, ${3:callback})$0');
         server.didCloseTextDocument({ textDocument: doc });
-    })).timeout(10000);
-    it('includes textEdit for string completion', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('includes textEdit for string completion', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
               function test(value: "fs/read" | "hello/world") {
                 return true;
               }
-              
+
               test("fs/")
-            `
+            `,
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({
+        const proposals = await server.completion({
             textDocument: doc,
-            position: (0, test_utils_1.positionAfter)(doc, 'test("fs/'),
+            position: positionAfter(doc, 'test("fs/'),
             context: {
                 triggerCharacter: '/',
-                triggerKind: 2
-            }
+                triggerKind: 2,
+            },
         });
         assert.isNotNull(proposals);
         const completion = proposals.items.find(completion => completion.label === 'fs/read');
@@ -363,38 +333,183 @@ describe('completion', () => {
         assert.deepStrictEqual(completion.textEdit, {
             range: {
                 start: { line: 5, character: 20 },
-                end: { line: 5, character: 23 }
+                end: { line: 5, character: 23 },
+            },
+            newText: 'fs/read',
+        });
+    });
+    it('includes labelDetails with useLabelDetailsInCompletionEntries enabled', async () => {
+        const doc = {
+            uri: uri('foo.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: `
+              interface IFoo {
+                bar(x: number): void;
+              }
+              const obj: IFoo = {
+                /*a*/
+              }
+            `,
+        };
+        server.didOpenTextDocument({ textDocument: doc });
+        const proposals = await server.completion({
+            textDocument: doc,
+            position: positionAfter(doc, '/*a*/'),
+        });
+        assert.isNotNull(proposals);
+        assert.lengthOf(proposals.items, 2);
+        assert.deepInclude(proposals.items[0], {
+            label: 'bar',
+            kind: 2,
+            insertTextFormat: 2,
+        });
+        assert.deepInclude(proposals.items[1], {
+            label: 'bar',
+            labelDetails: {
+                detail: '(x)',
             },
-            newText: 'fs/read'
+            kind: 2,
+            insertTextFormat: 2,
+            insertText: toPlatformEOL('bar(x) {\n    $0\n},'),
         });
-    })).timeout(10000);
+    });
+});
+describe('definition', () => {
+    it('goes to definition', async () => {
+        // NOTE: This test needs to reference files that physically exist for the feature to work.
+        const indexUri = uri('source-definition', 'index.ts');
+        const indexDoc = {
+            uri: indexUri,
+            languageId: 'typescript',
+            version: 1,
+            text: readContents(filePath('source-definition', 'index.ts')),
+        };
+        server.didOpenTextDocument({ textDocument: indexDoc });
+        const definitions = await server.definition({
+            textDocument: indexDoc,
+            position: position(indexDoc, 'a/*identifier*/'),
+        });
+        assert.isArray(definitions);
+        assert.equal(definitions.length, 1);
+        assert.deepEqual(definitions[0], {
+            uri: uri('source-definition', 'a.d.ts'),
+            range: {
+                start: {
+                    line: 0,
+                    character: 21,
+                },
+                end: {
+                    line: 0,
+                    character: 22,
+                },
+            },
+        });
+    });
+});
+describe('definition (definition link supported)', () => {
+    let localServer;
+    before(async () => {
+        const clientCapabilitiesOverride = {
+            textDocument: {
+                definition: {
+                    linkSupport: true,
+                },
+            },
+        };
+        localServer = await createServer({
+            rootUri: uri('source-definition'),
+            publishDiagnostics: args => diagnostics.set(args.uri, args),
+            clientCapabilitiesOverride,
+        });
+    });
+    beforeEach(() => {
+        localServer.closeAll();
+        // "closeAll" triggers final publishDiagnostics with an empty list so clear last.
+        diagnostics.clear();
+        localServer.workspaceEdits = [];
+    });
+    after(() => {
+        localServer.closeAll();
+        localServer.shutdown();
+    });
+    it('goes to definition', async () => {
+        // NOTE: This test needs to reference files that physically exist for the feature to work.
+        const indexUri = uri('source-definition', 'index.ts');
+        const indexDoc = {
+            uri: indexUri,
+            languageId: 'typescript',
+            version: 1,
+            text: readContents(filePath('source-definition', 'index.ts')),
+        };
+        localServer.didOpenTextDocument({ textDocument: indexDoc });
+        const definitions = await localServer.definition({
+            textDocument: indexDoc,
+            position: position(indexDoc, 'a/*identifier*/'),
+        });
+        assert.isArray(definitions);
+        assert.equal(definitions.length, 1);
+        assert.deepEqual(definitions[0], {
+            originSelectionRange: {
+                start: {
+                    line: 1,
+                    character: 0,
+                },
+                end: {
+                    line: 1,
+                    character: 1,
+                },
+            },
+            targetRange: {
+                start: {
+                    line: 0,
+                    character: 0,
+                },
+                end: {
+                    line: 0,
+                    character: 30,
+                },
+            },
+            targetUri: uri('source-definition', 'a.d.ts'),
+            targetSelectionRange: {
+                start: {
+                    line: 0,
+                    character: 21,
+                },
+                end: {
+                    line: 0,
+                    character: 22,
+                },
+            },
+        });
+    });
 });
 describe('diagnostics', () => {
-    it('simple test', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('simple test', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('diagnosticsBar.ts'),
+            uri: uri('diagnosticsBar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         export function foo(): void {
           missing('test')
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
         const resultsForFile = diagnostics.get(doc.uri);
         assert.isDefined(resultsForFile);
         const fileDiagnostics = resultsForFile.diagnostics;
         assert.equal(fileDiagnostics.length, 1);
         assert.equal("Cannot find name 'missing'.", fileDiagnostics[0].message);
-    })).timeout(10000);
-    it('supports diagnostic tags', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('supports diagnostic tags', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('diagnosticsBar.ts'),
+            uri: uri('diagnosticsBar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
@@ -403,13 +518,13 @@ describe('diagnostics', () => {
         /** @deprecated */
         function foo(): void {}
         foo();
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
         const resultsForFile = diagnostics.get(doc.uri);
         assert.isDefined(resultsForFile);
         const fileDiagnostics = resultsForFile.diagnostics;
@@ -420,36 +535,36 @@ describe('diagnostics', () => {
         const deprecatedDiagnostic = fileDiagnostics.find(d => d.code === 6387);
         assert.isDefined(deprecatedDiagnostic);
         assert.deepEqual(deprecatedDiagnostic.tags, [lsp.DiagnosticTag.Deprecated]);
-    })).timeout(10000);
-    it('multiple files test', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('multiple files test', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('multipleFileDiagnosticsBar.ts'),
+            uri: uri('multipleFileDiagnosticsBar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
     export function bar(): void {
         missing('test')
     }
-`
+`,
         };
         const doc2 = {
-            uri: (0, test_utils_1.uri)('multipleFileDiagnosticsFoo.ts'),
+            uri: uri('multipleFileDiagnosticsFoo.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
     export function foo(): void {
         missing('test')
     }
-`
+`,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
         server.didOpenTextDocument({
-            textDocument: doc2
+            textDocument: doc2,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
         assert.equal(diagnostics.size, 2);
         const diagnosticsForDoc = diagnostics.get(doc.uri);
         const diagnosticsForDoc2 = diagnostics.get(doc2.uri);
@@ -457,17 +572,17 @@ describe('diagnostics', () => {
         assert.isDefined(diagnosticsForDoc2);
         assert.equal(diagnosticsForDoc.diagnostics.length, 1, JSON.stringify(diagnostics));
         assert.equal(diagnosticsForDoc2.diagnostics.length, 1, JSON.stringify(diagnostics));
-    })).timeout(10000);
-    it('code 6133 (ununsed variable) is ignored', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('code 6133 (ununsed variable) is ignored', async () => {
         server.didChangeConfiguration({
             settings: {
                 diagnostics: {
-                    ignoredCodes: [6133]
-                }
-            }
+                    ignoredCodes: [6133],
+                },
+            },
         });
         const doc = {
-            uri: (0, test_utils_1.uri)('diagnosticsBar2.ts'),
+            uri: uri('diagnosticsBar2.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
@@ -475,23 +590,23 @@ describe('diagnostics', () => {
                     const x = 42;
                     return 1;
                 }
-          `
+          `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
         const diagnosticsForThisFile = diagnostics.get(doc.uri);
         assert.isDefined(diagnosticsForThisFile);
         const fileDiagnostics = diagnosticsForThisFile.diagnostics;
         assert.equal(fileDiagnostics.length, 0, JSON.stringify(fileDiagnostics));
-    })).timeout(10000);
+    });
 });
 describe('document symbol', () => {
-    it('simple test', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('simple test', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
@@ -500,24 +615,21 @@ describe('document symbol', () => {
           public myFunction(arg: string) {
           }
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
-        });
-        const symbols = yield server.documentSymbol({
             textDocument: doc,
-            position: lsp.Position.create(1, 1)
         });
+        const symbols = await server.documentSymbol({ textDocument: doc });
         assert.equal(`
 Foo
   foo
   myFunction
 `, symbolsAsString(symbols) + '\n');
-    })).timeout(10000);
-    it('merges interfaces correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('merges interfaces correctly', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
@@ -528,15 +640,12 @@ interface Box {
 
 interface Box {
     scale: number;
-}`
+}`,
         };
         server.didOpenTextDocument({
-            textDocument: doc
-        });
-        const symbols = yield server.documentSymbol({
             textDocument: doc,
-            position: lsp.Position.create(1, 1)
         });
+        const symbols = await server.documentSymbol({ textDocument: doc });
         assert.equal(`
 Box
   height
@@ -544,10 +653,10 @@ Box
 Box
   scale
 `, symbolsAsString(symbols) + '\n');
-    })).timeout(10000);
-    it('duplication test', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('duplication test', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
@@ -561,15 +670,12 @@ Box
           public myFunction(arg: string) {
           }
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
-        });
-        const symbols = yield server.documentSymbol({
             textDocument: doc,
-            position: lsp.Position.create(1, 1)
         });
+        const symbols = await server.documentSymbol({ textDocument: doc });
         const expectation = `
 Foo
   foo
@@ -583,7 +689,7 @@ Foo
         assert.deepEqual(symbols[0].range, { start: { line: 1, character: 8 }, end: { line: 5, character: 9 } });
         assert.deepEqual(symbols[1].selectionRange, symbols[1].range);
         assert.deepEqual(symbols[1].range, { start: { line: 6, character: 8 }, end: { line: 10, character: 9 } });
-    })).timeout(10000);
+    });
 });
 function symbolsAsString(symbols, indentation = '') {
     return symbols.map(symbol => {
@@ -602,18 +708,18 @@ function symbolsAsString(symbols, indentation = '') {
     }).join('');
 }
 describe('editing', () => {
-    it('open and change', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('open and change', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('openAndChangeBar.ts'),
+            uri: uri('openAndChangeBar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         export function foo(): void {
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
         server.didChangeTextDocument({
             textDocument: doc,
@@ -623,142 +729,141 @@ describe('editing', () => {
           export function foo(): void {
             missing('test');
           }
-          `
-                }
-            ]
+          `,
+                },
+            ],
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
         const resultsForFile = diagnostics.get(doc.uri);
         assert.isDefined(resultsForFile);
         const fileDiagnostics = resultsForFile.diagnostics;
         assert.isTrue(fileDiagnostics.length >= 1, fileDiagnostics.map(d => d.message).join(','));
         assert.equal("Cannot find name 'missing'.", fileDiagnostics[0].message);
-    })).timeout(10000);
+    });
 });
 describe('references', () => {
-    it('respects "includeDeclaration" in the request', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('respects "includeDeclaration" in the request', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('foo.ts'),
+            uri: uri('foo.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
-                export let foo = 1;
-                foo++;
-                foo = 1;
-            `
+                function foo() {};
+                foo();
+            `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
         // Without declaration/definition.
-        let references = yield server.references({
+        const position = lastPosition(doc, 'function foo()');
+        let references = await server.references({
             context: { includeDeclaration: false },
             textDocument: doc,
-            position: (0, test_utils_1.lastPosition)(doc, 'foo')
+            position,
         });
-        assert.strictEqual(references.length, 2);
+        assert.strictEqual(references.length, 1);
         assert.strictEqual(references[0].range.start.line, 2);
-        assert.strictEqual(references[1].range.start.line, 3);
         // With declaration/definition.
-        references = yield server.references({
+        references = await server.references({
             context: { includeDeclaration: true },
             textDocument: doc,
-            position: (0, test_utils_1.lastPosition)(doc, 'foo')
+            position,
         });
-        assert.strictEqual(references.length, 3);
-    })).timeout(10000);
-});
-describe('workspace configuration', () => {
-    it('receives workspace configuration notification', () => __awaiter(void 0, void 0, void 0, function* () {
-        const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
-            languageId: 'typescript',
-            version: 1,
-            text: `
-                export function foo(): void {
-                  console.log('test')
-                }
-            `
-        };
-        server.didOpenTextDocument({
-            textDocument: doc
-        });
-        server.didChangeConfiguration({
-            settings: {
-                typescript: {
-                    format: {
-                        insertSpaceAfterCommaDelimiter: true
-                    }
-                },
-                javascript: {
-                    format: {
-                        insertSpaceAfterCommaDelimiter: false
-                    }
-                }
-            }
-        });
-        const file = (0, test_utils_1.filePath)('bar.ts');
-        const settings = server.getWorkspacePreferencesForDocument(file);
-        assert.deepEqual(settings, { format: { insertSpaceAfterCommaDelimiter: true } });
-    }));
+        assert.strictEqual(references.length, 2);
+    });
 });
+// describe('workspace configuration', () => {
+//     it('receives workspace configuration notification', async ()=>{
+//         const doc = {
+//             uri: uri('bar.ts'),
+//             languageId: 'typescript',
+//             version: 1,
+//             text: `
+//                 export function foo(): void {
+//                   console.log('test')
+//                 }
+//             `
+//         };
+//         server.didOpenTextDocument({
+//             textDocument: doc
+//         });
+//         server.didChangeConfiguration({
+//             settings: {
+//                 typescript: {
+//                     format: {
+//                         insertSpaceAfterCommaDelimiter: true
+//                     }
+//                 },
+//                 javascript: {
+//                     format: {
+//                         insertSpaceAfterCommaDelimiter: false
+//                     }
+//                 }
+//             }
+//         });
+//         const file = filePath('bar.ts');
+//         const settings = server.getWorkspacePreferencesForDocument(file);
+//         assert.deepEqual(settings, { format: { insertSpaceAfterCommaDelimiter: true } });
+//     });
+// });
 describe('formatting', () => {
-    const uriString = (0, test_utils_1.uri)('bar.ts');
+    const uriString = uri('bar.ts');
     const languageId = 'typescript';
     const version = 1;
-    it('full document formatting', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('full document formatting', async () => {
         const text = 'export  function foo (     )   :  void   {   }';
         const textDocument = {
-            uri: uriString, languageId, version, text
+            uri: uriString, languageId, version, text,
         };
         server.didOpenTextDocument({ textDocument });
-        const edits = yield server.documentFormatting({
+        const edits = await server.documentFormatting({
             textDocument,
             options: {
                 tabSize: 4,
-                insertSpaces: true
-            }
+                insertSpaces: true,
+            },
         });
-        const result = vscode_languageserver_textdocument_1.TextDocument.applyEdits(vscode_languageserver_textdocument_1.TextDocument.create(uriString, languageId, version, text), edits);
+        const result = TextDocument.applyEdits(TextDocument.create(uriString, languageId, version, text), edits);
         assert.equal('export function foo(): void { }', result);
-    })).timeout(10000);
-    it('indent settings (3 spaces)', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('indent settings (3 spaces)', async () => {
         const text = 'function foo() {\n// some code\n}';
         const textDocument = {
-            uri: uriString, languageId, version, text
+            uri: uriString, languageId, version, text,
         };
         server.didOpenTextDocument({ textDocument });
-        const edits = yield server.documentFormatting({
+        const edits = await server.documentFormatting({
             textDocument,
             options: {
                 tabSize: 3,
-                insertSpaces: true
-            }
+                insertSpaces: true,
+            },
         });
-        const result = vscode_languageserver_textdocument_1.TextDocument.applyEdits(vscode_languageserver_textdocument_1.TextDocument.create(uriString, languageId, version, text), edits);
+        const result = TextDocument.applyEdits(TextDocument.create(uriString, languageId, version, text), edits);
         assert.equal('function foo() {\n   // some code\n}', result);
-    })).timeout(10000);
-    it('indent settings (tabs)', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('indent settings (tabs)', async () => {
         const text = 'function foo() {\n// some code\n}';
         const textDocument = {
-            uri: uriString, languageId, version, text
+            uri: uriString, languageId, version, text,
         };
         server.didOpenTextDocument({ textDocument });
-        const edits = yield server.documentFormatting({
+        const edits = await server.documentFormatting({
             textDocument,
             options: {
                 tabSize: 4,
-                insertSpaces: false
-            }
+                insertSpaces: false,
+            },
         });
-        const result = vscode_languageserver_textdocument_1.TextDocument.applyEdits(vscode_languageserver_textdocument_1.TextDocument.create(uriString, languageId, version, text), edits);
+        const result = TextDocument.applyEdits(TextDocument.create(uriString, languageId, version, text), edits);
         assert.equal('function foo() {\n\t// some code\n}', result);
-    })).timeout(10000);
-    it('formatting setting set through workspace configuration', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('formatting setting set through workspace configuration', async () => {
         const text = 'function foo() {\n// some code\n}';
         const textDocument = {
-            uri: uriString, languageId, version, text
+            uri: uriString, languageId, version, text,
         };
         server.didOpenTextDocument({ textDocument });
         server.didChangeConfiguration({
@@ -766,104 +871,141 @@ describe('formatting', () => {
                 typescript: {
                     format: {
                         newLineCharacter: '\n',
-                        placeOpenBraceOnNewLineForFunctions: true
-                    }
-                }
-            }
+                        placeOpenBraceOnNewLineForFunctions: true,
+                    },
+                },
+            },
         });
-        const edits = yield server.documentFormatting({
+        const edits = await server.documentFormatting({
             textDocument,
             options: {
                 tabSize: 4,
-                insertSpaces: false
-            }
+                insertSpaces: false,
+            },
         });
-        const result = vscode_languageserver_textdocument_1.TextDocument.applyEdits(vscode_languageserver_textdocument_1.TextDocument.create(uriString, languageId, version, text), edits);
+        const result = TextDocument.applyEdits(TextDocument.create(uriString, languageId, version, text), edits);
         assert.equal('function foo()\n{\n\t// some code\n}', result);
-    })).timeout(10000);
-    it('selected range', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('selected range', async () => {
         const text = 'function foo() {\nconst first = 1;\nconst second = 2;\nconst val = foo( "something" );\n//const fourth = 4;\n}';
         const textDocument = {
-            uri: uriString, languageId, version, text
+            uri: uriString, languageId, version, text,
         };
         server.didOpenTextDocument({ textDocument });
-        const edits = yield server.documentRangeFormatting({
+        const edits = await server.documentRangeFormatting({
             textDocument,
             range: {
                 start: {
                     line: 2,
-                    character: 0
+                    character: 0,
                 },
                 end: {
                     line: 3,
-                    character: 30
-                }
+                    character: 30,
+                },
             },
             options: {
                 tabSize: 4,
-                insertSpaces: true
-            }
+                insertSpaces: true,
+            },
         });
-        const result = vscode_languageserver_textdocument_1.TextDocument.applyEdits(vscode_languageserver_textdocument_1.TextDocument.create(uriString, languageId, version, text), edits);
+        const result = TextDocument.applyEdits(TextDocument.create(uriString, languageId, version, text), edits);
         assert.equal('function foo() {\nconst first = 1;\n    const second = 2;\n    const val = foo("something");\n//const fourth = 4;\n}', result);
-    })).timeout(10000);
+    });
 });
 describe('signatureHelp', () => {
-    it('simple test', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('simple test', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         export function foo(bar: string, baz?:boolean): void {}
+        export function foo(n: number, baz?: boolean): void
         foo(param1, param2)
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        let result = (yield server.signatureHelp({
+        let result = (await server.signatureHelp({
             textDocument: doc,
-            position: (0, test_utils_1.position)(doc, 'param1')
+            position: position(doc, 'param1'),
         }));
+        assert.equal(result.signatures.length, 2);
         assert.equal('bar: string', result.signatures[result.activeSignature].parameters[result.activeParameter].label);
-        result = (yield server.signatureHelp({
+        result = (await server.signatureHelp({
             textDocument: doc,
-            position: (0, test_utils_1.position)(doc, 'param2')
+            position: position(doc, 'param2'),
         }));
         assert.equal('baz?: boolean', result.signatures[result.activeSignature].parameters[result.activeParameter].label);
-    })).timeout(10000);
+    });
+    it('retrigger with specific signature active', async () => {
+        const doc = {
+            uri: uri('bar.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: `
+        export function foo(bar: string, baz?: boolean): void {}
+        export function foo(n: number, baz?: boolean): void
+        foo(param1, param2)
+      `,
+        };
+        server.didOpenTextDocument({ textDocument: doc });
+        let result = await server.signatureHelp({
+            textDocument: doc,
+            position: position(doc, 'param1'),
+        });
+        assert.equal(result.signatures.length, 2);
+        result = (await server.signatureHelp({
+            textDocument: doc,
+            position: position(doc, 'param1'),
+            context: {
+                isRetrigger: true,
+                triggerKind: lsp.SignatureHelpTriggerKind.Invoked,
+                activeSignatureHelp: {
+                    signatures: result.signatures,
+                    activeSignature: 1, // select second signature
+                },
+            },
+        }));
+        const { activeSignature, signatures } = result;
+        assert.equal(activeSignature, 1);
+        assert.deepInclude(signatures[activeSignature], {
+            label: 'foo(n: number, baz?: boolean): void',
+        });
+    });
 });
 describe('code actions', () => {
     const doc = {
-        uri: (0, test_utils_1.uri)('bar.ts'),
+        uri: uri('bar.ts'),
         languageId: 'typescript',
         version: 1,
         text: `import { something } from "something";
     export function foo(bar: string, baz?:boolean): void {}
     foo(param1, param2)
-    `
+    `,
     };
-    it('can provide quickfix code actions', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('can provide quickfix code actions', async () => {
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        const result = (yield server.codeAction({
+        const result = (await server.codeAction({
             textDocument: doc,
             range: {
                 start: { line: 1, character: 25 },
-                end: { line: 1, character: 49 }
+                end: { line: 1, character: 49 },
             },
             context: {
                 diagnostics: [{
                         range: {
                             start: { line: 1, character: 25 },
-                            end: { line: 1, character: 49 }
+                            end: { line: 1, character: 49 },
                         },
                         code: 6133,
-                        message: 'unused arg'
-                    }]
-            }
+                        message: 'unused arg',
+                    }],
+            },
         }));
         assert.strictEqual(result.length, 2);
         const quickFixDiagnostic = result.find(diagnostic => diagnostic.kind === 'quickfix');
@@ -878,30 +1020,30 @@ describe('code actions', () => {
                         documentChanges: [
                             {
                                 textDocument: {
-                                    uri: (0, test_utils_1.uri)('bar.ts'),
-                                    version: 1
+                                    uri: uri('bar.ts'),
+                                    version: 1,
                                 },
                                 edits: [
                                     {
                                         range: {
                                             start: {
                                                 line: 1,
-                                                character: 24
+                                                character: 24,
                                             },
                                             end: {
                                                 line: 1,
-                                                character: 27
-                                            }
+                                                character: 27,
+                                            },
                                         },
-                                        newText: '_bar'
-                                    }
-                                ]
-                            }
-                        ]
-                    }
-                ]
+                                        newText: '_bar',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
             },
-            kind: 'quickfix'
+            kind: 'quickfix',
         });
         const refactorDiagnostic = result.find(diagnostic => diagnostic.kind === 'refactor');
         assert.isDefined(refactorDiagnostic);
@@ -912,40 +1054,40 @@ describe('code actions', () => {
                 command: '_typescript.applyRefactoring',
                 arguments: [
                     {
-                        file: (0, test_utils_1.filePath)('bar.ts'),
+                        file: filePath('bar.ts'),
                         startLine: 2,
                         startOffset: 26,
                         endLine: 2,
                         endOffset: 50,
                         refactor: 'Convert parameters to destructured object',
-                        action: 'Convert parameters to destructured object'
-                    }
-                ]
+                        action: 'Convert parameters to destructured object',
+                    },
+                ],
             },
-            kind: 'refactor'
+            kind: 'refactor',
         });
-    })).timeout(10000);
-    it('can filter quickfix code actions filtered by only', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('can filter quickfix code actions filtered by only', async () => {
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        const result = (yield server.codeAction({
+        const result = (await server.codeAction({
             textDocument: doc,
             range: {
                 start: { line: 1, character: 25 },
-                end: { line: 1, character: 49 }
+                end: { line: 1, character: 49 },
             },
             context: {
                 diagnostics: [{
                         range: {
                             start: { line: 1, character: 25 },
-                            end: { line: 1, character: 49 }
+                            end: { line: 1, character: 49 },
                         },
                         code: 6133,
-                        message: 'unused arg'
+                        message: 'unused arg',
                     }],
-                only: ['refactor', 'invalid-action']
-            }
+                only: ['refactor', 'invalid-action'],
+            },
         }));
         assert.deepEqual(result, [
             {
@@ -955,72 +1097,72 @@ describe('code actions', () => {
                             action: 'Convert parameters to destructured object',
                             endLine: 2,
                             endOffset: 50,
-                            file: (0, test_utils_1.filePath)('bar.ts'),
+                            file: filePath('bar.ts'),
                             refactor: 'Convert parameters to destructured object',
                             startLine: 2,
-                            startOffset: 26
-                        }
+                            startOffset: 26,
+                        },
                     ],
                     command: '_typescript.applyRefactoring',
-                    title: 'Convert parameters to destructured object'
+                    title: 'Convert parameters to destructured object',
                 },
                 kind: 'refactor',
-                title: 'Convert parameters to destructured object'
-            }
+                title: 'Convert parameters to destructured object',
+            },
         ]);
-    })).timeout(10000);
-    it('does not provide organize imports when there are errors', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('does not provide organize imports when there are errors', async () => {
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
-        const result = (yield server.codeAction({
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
+        const result = (await server.codeAction({
             textDocument: doc,
             range: {
                 start: { line: 1, character: 29 },
-                end: { line: 1, character: 53 }
+                end: { line: 1, character: 53 },
             },
             context: {
                 diagnostics: [{
                         range: {
                             start: { line: 1, character: 25 },
-                            end: { line: 1, character: 49 }
+                            end: { line: 1, character: 49 },
                         },
                         code: 6133,
-                        message: 'unused arg'
+                        message: 'unused arg',
                     }],
-                only: [types_1.CodeActionKind.SourceOrganizeImportsTs.value]
-            }
+                only: [CodeActionKind.SourceOrganizeImportsTs.value],
+            },
         }));
         assert.deepEqual(result, []);
-    })).timeout(10000);
-    it('provides "add missing imports" when explicitly requested in only', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('provides "add missing imports" when explicitly requested in only', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'existsSync(\'t\');'
+            text: 'existsSync(\'t\');',
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
-        const result = (yield server.codeAction({
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
+        const result = (await server.codeAction({
             textDocument: doc,
             range: {
                 start: { line: 1, character: 29 },
-                end: { line: 1, character: 53 }
+                end: { line: 1, character: 53 },
             },
             context: {
                 diagnostics: [],
-                only: [types_1.CodeActionKind.SourceAddMissingImportsTs.value]
-            }
+                only: [CodeActionKind.SourceAddMissingImportsTs.value],
+            },
         }));
         assert.deepEqual(result, [
             {
-                kind: types_1.CodeActionKind.SourceAddMissingImportsTs.value,
+                kind: CodeActionKind.SourceAddMissingImportsTs.value,
                 title: 'Add all missing imports',
                 edit: {
                     documentChanges: [
@@ -1032,54 +1174,54 @@ describe('code actions', () => {
                                     range: {
                                         end: {
                                             character: 0,
-                                            line: 0
+                                            line: 0,
                                         },
                                         start: {
                                             character: 0,
-                                            line: 0
-                                        }
-                                    }
-                                }
+                                            line: 0,
+                                        },
+                                    },
+                                },
                             ],
                             textDocument: {
-                                uri: (0, test_utils_1.uri)('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                uri: uri('bar.ts'),
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    })).timeout(10000);
-    it('provides "fix all" when explicitly requested in only', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('provides "fix all" when explicitly requested in only', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `function foo() {
   return
   setTimeout(() => {})
-}`
+}`,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
-        const result = (yield server.codeAction({
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
+        const result = (await server.codeAction({
             textDocument: doc,
             range: {
                 start: { line: 0, character: 0 },
-                end: { line: 4, character: 0 }
+                end: { line: 4, character: 0 },
             },
             context: {
                 diagnostics: [],
-                only: [types_1.CodeActionKind.SourceFixAllTs.value]
-            }
+                only: [CodeActionKind.SourceFixAllTs.value],
+            },
         }));
         assert.deepEqual(result, [
             {
-                kind: types_1.CodeActionKind.SourceFixAllTs.value,
+                kind: CodeActionKind.SourceFixAllTs.value,
                 title: 'Fix all',
                 edit: {
                     documentChanges: [
@@ -1090,58 +1232,58 @@ describe('code actions', () => {
                                     range: {
                                         end: {
                                             character: 0,
-                                            line: 3
+                                            line: 3,
                                         },
                                         start: {
                                             character: 0,
-                                            line: 2
-                                        }
-                                    }
-                                }
+                                            line: 2,
+                                        },
+                                    },
+                                },
                             ],
                             textDocument: {
-                                uri: (0, test_utils_1.uri)('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                uri: uri('bar.ts'),
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    })).timeout(10000);
-    it('provides organize imports when explicitly requested in only', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('provides organize imports when explicitly requested in only', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `import { existsSync } from 'fs';
 import { accessSync } from 'fs';
-existsSync('t');`
+existsSync('t');`,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        const result = (yield server.codeAction({
+        const result = (await server.codeAction({
             textDocument: doc,
             range: {
                 start: { line: 0, character: 0 },
-                end: { line: 3, character: 0 }
+                end: { line: 3, character: 0 },
             },
             context: {
                 diagnostics: [{
                         range: {
                             start: { line: 1, character: 25 },
-                            end: { line: 1, character: 49 }
+                            end: { line: 1, character: 49 },
                         },
                         code: 6133,
-                        message: 'unused arg'
+                        message: 'unused arg',
                     }],
-                only: [types_1.CodeActionKind.SourceOrganizeImportsTs.value]
-            }
+                only: [CodeActionKind.SourceOrganizeImportsTs.value],
+            },
         }));
         assert.deepEqual(result, [
             {
-                kind: types_1.CodeActionKind.SourceOrganizeImportsTs.value,
+                kind: CodeActionKind.SourceOrganizeImportsTs.value,
                 title: 'Organize imports',
                 edit: {
                     documentChanges: [
@@ -1152,64 +1294,64 @@ existsSync('t');`
                                     range: {
                                         end: {
                                             character: 0,
-                                            line: 1
+                                            line: 1,
                                         },
                                         start: {
                                             character: 0,
-                                            line: 0
-                                        }
-                                    }
+                                            line: 0,
+                                        },
+                                    },
                                 },
                                 {
                                     newText: '',
                                     range: {
                                         end: {
                                             character: 0,
-                                            line: 2
+                                            line: 2,
                                         },
                                         start: {
                                             character: 0,
-                                            line: 1
-                                        }
-                                    }
-                                }
+                                            line: 1,
+                                        },
+                                    },
+                                },
                             ],
                             textDocument: {
-                                uri: (0, test_utils_1.uri)('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                uri: uri('bar.ts'),
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    })).timeout(10000);
-    it('provides "remove unused" when explicitly requested in only', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('provides "remove unused" when explicitly requested in only', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'import { existsSync } from \'fs\';'
+            text: 'import { existsSync } from \'fs\';',
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
-        const result = (yield server.codeAction({
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
+        const result = (await server.codeAction({
             textDocument: doc,
             range: {
-                start: (0, test_utils_1.position)(doc, 'existsSync'),
-                end: (0, test_utils_1.positionAfter)(doc, 'existsSync')
+                start: position(doc, 'existsSync'),
+                end: positionAfter(doc, 'existsSync'),
             },
             context: {
                 diagnostics: [],
-                only: [types_1.CodeActionKind.SourceRemoveUnusedTs.value]
-            }
+                only: [CodeActionKind.SourceRemoveUnusedTs.value],
+            },
         }));
         assert.deepEqual(result, [
             {
-                kind: types_1.CodeActionKind.SourceRemoveUnusedTs.value,
+                kind: CodeActionKind.SourceRemoveUnusedTs.value,
                 title: 'Remove all unused code',
                 edit: {
                     documentChanges: [
@@ -1220,28 +1362,28 @@ existsSync('t');`
                                     range: {
                                         end: {
                                             character: 32,
-                                            line: 0
+                                            line: 0,
                                         },
                                         start: {
                                             character: 0,
-                                            line: 0
-                                        }
-                                    }
-                                }
+                                            line: 0,
+                                        },
+                                    },
+                                },
                             ],
                             textDocument: {
-                                uri: (0, test_utils_1.uri)('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                uri: uri('bar.ts'),
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    })).timeout(10000);
-    it('only provides the "source.fixAll" kind if requested in only', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('only provides the "source.fixAll" kind if requested in only', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
@@ -1250,28 +1392,28 @@ existsSync('t');`
                     return
                     setTimeout(() => {})
                 }
-            `
+            `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
-        const result = (yield server.codeAction({
+        await server.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
+        const result = (await server.codeAction({
             textDocument: doc,
             range: {
                 start: { line: 0, character: 0 },
-                end: (0, test_utils_1.lastPosition)(doc, '}')
+                end: lastPosition(doc, '}'),
             },
             context: {
                 diagnostics: [],
-                only: [types_1.CodeActionKind.SourceFixAllTs.value]
-            }
+                only: [CodeActionKind.SourceFixAllTs.value],
+            },
         }));
         assert.strictEqual(result.length, 1, JSON.stringify(result, null, 2));
         assert.deepEqual(result, [
             {
-                kind: types_1.CodeActionKind.SourceFixAllTs.value,
+                kind: CodeActionKind.SourceFixAllTs.value,
                 title: 'Fix all',
                 edit: {
                     documentChanges: [
@@ -1282,60 +1424,165 @@ existsSync('t');`
                                     range: {
                                         start: {
                                             line: 4,
-                                            character: 0
+                                            character: 0,
                                         },
                                         end: {
                                             line: 5,
-                                            character: 0
-                                        }
-                                    }
-                                }
+                                            character: 0,
+                                        },
+                                    },
+                                },
                             ],
                             textDocument: {
-                                uri: (0, test_utils_1.uri)('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                uri: uri('bar.ts'),
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    })).timeout(10000);
+    });
+});
+describe('executeCommand', () => {
+    it('apply refactoring (move to new file)', async () => {
+        const fooUri = uri('foo.ts');
+        const doc = {
+            uri: fooUri,
+            languageId: 'typescript',
+            version: 1,
+            text: 'export function fn(): void {}\nexport function newFn(): void {}',
+        };
+        server.didOpenTextDocument({
+            textDocument: doc,
+        });
+        const codeActions = (await server.codeAction({
+            textDocument: doc,
+            range: {
+                start: position(doc, 'newFn'),
+                end: position(doc, 'newFn'),
+            },
+            context: {
+                diagnostics: [],
+            },
+        }));
+        // Find refactoring code action.
+        const applyRefactoringAction = codeActions.find(action => action.command?.command === Commands.APPLY_REFACTORING);
+        assert.isDefined(applyRefactoringAction);
+        // Execute refactoring action.
+        await server.executeCommand({
+            command: applyRefactoringAction.command.command,
+            arguments: applyRefactoringAction.command.arguments,
+        });
+        assert.equal(1, server.workspaceEdits.length);
+        const { changes } = server.workspaceEdits[0].edit;
+        assert.isDefined(changes);
+        assert.equal(2, Object.keys(changes).length);
+        const change1 = changes[fooUri];
+        assert.isDefined(change1);
+        const change2 = changes[uri('newFn.ts')];
+        assert.isDefined(change2);
+        // Clean up file that is created on applying edit.
+        fs.unlinkSync(filePath('newFn.ts'));
+        assert.deepEqual(change1, [
+            {
+                range: {
+                    start: {
+                        line: 1,
+                        character: 0,
+                    },
+                    end: {
+                        line: 1,
+                        character: 32,
+                    },
+                },
+                newText: '',
+            },
+        ]);
+        assert.deepEqual(change2, [
+            {
+                range: {
+                    start: {
+                        line: 0,
+                        character: 0,
+                    },
+                    end: {
+                        line: 0,
+                        character: 0,
+                    },
+                },
+                newText: 'export function newFn(): void { }\n',
+            },
+        ]);
+    });
+    it('go to source definition', async () => {
+        // NOTE: This test needs to reference files that physically exist for the feature to work.
+        const indexUri = uri('source-definition', 'index.ts');
+        const indexDoc = {
+            uri: indexUri,
+            languageId: 'typescript',
+            version: 1,
+            text: readContents(filePath('source-definition', 'index.ts')),
+        };
+        server.didOpenTextDocument({ textDocument: indexDoc });
+        const result = await server.executeCommand({
+            command: Commands.SOURCE_DEFINITION,
+            arguments: [
+                indexUri,
+                position(indexDoc, '/*identifier*/'),
+            ],
+        });
+        assert.isNotNull(result);
+        assert.equal(result.length, 1);
+        assert.deepEqual(result[0], {
+            uri: uri('source-definition', 'a.js'),
+            range: {
+                start: {
+                    line: 0,
+                    character: 13,
+                },
+                end: {
+                    line: 0,
+                    character: 14,
+                },
+            },
+        });
+    });
 });
 describe('documentHighlight', () => {
-    it('simple test', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('simple test', async () => {
         const barDoc = {
-            uri: (0, test_utils_1.uri)('bar.d.ts'),
+            uri: uri('bar.d.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         export declare const Bar: unique symbol;
         export interface Bar {
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: barDoc
+            textDocument: barDoc,
         });
         const fooDoc = {
-            uri: (0, test_utils_1.uri)('bar.ts'),
+            uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         import { Bar } from './bar';
         export class Foo implements Bar {
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: fooDoc
+            textDocument: fooDoc,
         });
-        const result = yield server.documentHighlight({
+        const result = await server.documentHighlight({
             textDocument: fooDoc,
-            position: (0, test_utils_1.lastPosition)(fooDoc, 'Bar')
+            position: lastPosition(fooDoc, 'Bar'),
         });
         assert.equal(2, result.length, JSON.stringify(result, undefined, 2));
-    })).timeout(10000);
+    });
 });
 describe('calls', () => {
     function resultToString(callsResult, direction) {
@@ -1355,7 +1602,7 @@ describe('calls', () => {
         return out.join('\n');
     }
     const doDoc = {
-        uri: (0, test_utils_1.uri)('do.ts'),
+        uri: uri('do.ts'),
         languageId: 'typescript',
         version: 1,
         text: `
@@ -1370,10 +1617,10 @@ export function two() {
 export function three() {
     return "".toString();
 }
-`
+`,
     };
     const fooDoc = {
-        uri: (0, test_utils_1.uri)('foo.ts'),
+        uri: uri('foo.ts'),
         languageId: 'typescript',
         version: 1,
         text: `import { doStuff } from './do';
@@ -1387,21 +1634,17 @@ class MyClass {
 export function factory() {
     new MyClass().doSomething();
 }
-`
+`,
     };
     function openDocuments() {
-        server.didOpenTextDocument({
-            textDocument: doDoc
-        });
-        server.didOpenTextDocument({
-            textDocument: fooDoc
-        });
+        server.didOpenTextDocument({ textDocument: doDoc });
+        server.didOpenTextDocument({ textDocument: fooDoc });
     }
-    it('callers: first step', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('callers: first step', async () => {
         openDocuments();
-        const callsResult = yield server.calls({
+        const callsResult = await server.calls({
             textDocument: fooDoc,
-            position: lsp.Position.create(3, 9)
+            position: position(fooDoc, 'doStuff();'),
         });
         assert.equal(resultToString(callsResult, lspcalls.CallDirection.Incoming), `
 ↘ doStuff (do.ts#1)
@@ -1409,175 +1652,282 @@ export function factory() {
   ↘ doSomething (foo.ts#2) - foo.ts#3
   ↘ x (foo.ts#4) - foo.ts#4
             `.trim());
-    })).timeout(10000);
-    it('callers: second step', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('callers: second step', async () => {
         openDocuments();
-        const callsResult = yield server.calls({
+        const callsResult = await server.calls({
             textDocument: fooDoc,
-            position: lsp.Position.create(2, 5)
+            position: position(fooDoc, 'doSomething() {'),
         });
         assert.equal(resultToString(callsResult, lspcalls.CallDirection.Incoming), `
 ↘ doSomething (foo.ts#2)
   ↘ factory (foo.ts#8) - foo.ts#9
             `.trim());
-    })).timeout(10000);
-    it('callees: first step', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it.skip('callees: first step', async () => {
         openDocuments();
         const direction = lspcalls.CallDirection.Outgoing;
-        const callsResult = yield server.calls({
+        const callsResult = await server.calls({
             direction,
             textDocument: fooDoc,
-            position: lsp.Position.create(3, 9)
+            position: position(fooDoc, 'doStuff()'),
         });
         assert.equal(resultToString(callsResult, direction), `
 ↖ doStuff (do.ts#1)
   ↖ two (do.ts#4) - do.ts#2
             `.trim());
-    })).timeout(10000);
-    it('callees: second step', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it.skip('callees: second step', async () => {
         openDocuments();
         const direction = lspcalls.CallDirection.Outgoing;
-        const callsResult = yield server.calls({
+        const callsResult = await server.calls({
             direction,
             textDocument: doDoc,
-            position: lsp.Position.create(4, 17)
+            position: position(doDoc, 'function two()'),
         });
         assert.equal(resultToString(callsResult, direction), `
 ↖ two (do.ts#4)
   ↖ three (do.ts#9) - do.ts#5
   ↖ ttt (do.ts#6) - do.ts#7
             `.trim());
-    })).timeout(10000);
+    });
 });
 describe('diagnostics (no client support)', () => {
-    before(() => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
-        // Remove the "textDocument.publishDiagnostics" client capability.
-        const clientCapabilitiesOverride = (0, test_utils_1.getDefaultClientCapabilities)();
-        (_a = clientCapabilitiesOverride.textDocument) === null || _a === void 0 ? true : delete _a.publishDiagnostics;
-        server = yield (0, test_utils_1.createServer)({
+    let localServer;
+    before(async () => {
+        const clientCapabilitiesOverride = {
+            textDocument: {
+                publishDiagnostics: undefined,
+            },
+        };
+        localServer = await createServer({
             rootUri: null,
             publishDiagnostics: args => diagnostics.set(args.uri, args),
-            clientCapabilitiesOverride
+            clientCapabilitiesOverride,
         });
-    }));
-    it('diagnostics are published', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    beforeEach(() => {
+        localServer.closeAll();
+        // "closeAll" triggers final publishDiagnostics with an empty list so clear last.
+        diagnostics.clear();
+        localServer.workspaceEdits = [];
+    });
+    after(() => {
+        localServer.closeAll();
+        localServer.shutdown();
+    });
+    it('diagnostic tags are not returned', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('diagnosticsBar.ts'),
+            uri: uri('diagnosticsBar.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         export function foo(): void {
           missing('test')
         }
-      `
+      `,
         };
-        server.didOpenTextDocument({
-            textDocument: doc
+        localServer.didOpenTextDocument({
+            textDocument: doc,
         });
-        yield server.requestDiagnostics();
-        yield new Promise(resolve => setTimeout(resolve, 200));
+        await localServer.requestDiagnostics();
+        await new Promise(resolve => setTimeout(resolve, 200));
         const resultsForFile = diagnostics.get(doc.uri);
         assert.isDefined(resultsForFile);
-        assert.strictEqual(resultsForFile === null || resultsForFile === void 0 ? void 0 : resultsForFile.diagnostics.length, 1);
-    })).timeout(10000);
+        assert.strictEqual(resultsForFile.diagnostics.length, 1);
+        assert.notProperty(resultsForFile.diagnostics[0], 'tags');
+    });
 });
 describe('jsx/tsx project', () => {
-    before(() => __awaiter(void 0, void 0, void 0, function* () {
-        server = yield (0, test_utils_1.createServer)({
-            rootUri: (0, test_utils_1.uri)('jsx'),
-            publishDiagnostics: args => diagnostics.set(args.uri, args)
+    let localServer;
+    before(async () => {
+        localServer = await createServer({
+            rootUri: uri('jsx'),
+            publishDiagnostics: args => diagnostics.set(args.uri, args),
         });
-    }));
-    it('includes snippet completion for element prop', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    beforeEach(() => {
+        localServer.closeAll();
+        // "closeAll" triggers final publishDiagnostics with an empty list so clear last.
+        diagnostics.clear();
+        localServer.workspaceEdits = [];
+    });
+    after(() => {
+        localServer.closeAll();
+        localServer.shutdown();
+    });
+    it('includes snippet completion for element prop', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('jsx', 'app.tsx'),
+            uri: uri('jsx', 'app.tsx'),
             languageId: 'typescriptreact',
             version: 1,
-            text: (0, test_utils_1.readContents)((0, test_utils_1.filePath)('jsx', 'app.tsx'))
+            text: readContents(filePath('jsx', 'app.tsx')),
         };
-        server.didOpenTextDocument({
-            textDocument: doc
+        localServer.didOpenTextDocument({
+            textDocument: doc,
         });
-        const completion = yield server.completion({ textDocument: doc, position: (0, test_utils_1.position)(doc, 'title') });
+        const completion = await localServer.completion({ textDocument: doc, position: position(doc, 'title') });
         assert.isNotNull(completion);
         const item = completion.items.find(i => i.label === 'title');
         assert.isDefined(item);
-        assert.strictEqual(item === null || item === void 0 ? void 0 : item.insertTextFormat, 2);
-    })).timeout(10000);
+        assert.strictEqual(item?.insertTextFormat, 2);
+    });
 });
 describe('inlayHints', () => {
-    it('inlayHints', () => __awaiter(void 0, void 0, void 0, function* () {
+    before(async () => {
+        server.didChangeConfiguration({
+            settings: {
+                typescript: {
+                    inlayHints: {
+                        includeInlayFunctionLikeReturnTypeHints: true,
+                    },
+                },
+            },
+        });
+    });
+    after(() => {
+        server.didChangeConfiguration({
+            settings: {
+                typescript: {
+                    inlayHints: {
+                        includeInlayFunctionLikeReturnTypeHints: false,
+                    },
+                },
+            },
+        });
+    });
+    it('inlayHints', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('module.ts'),
+            uri: uri('module.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         export function foo() {
           return 3
         }
-      `
+      `,
         };
-        yield server.initialize({
-            initializationOptions: {
-                preferences: {
-                    includeInlayFunctionLikeReturnTypeHints: true
-                }
-            },
-            processId: null,
-            capabilities: (0, test_utils_1.getDefaultClientCapabilities)(),
-            workspaceFolders: [],
-            rootUri: ''
-        });
-        server.didOpenTextDocument({
-            textDocument: doc
-        });
-        const { inlayHints } = yield server.inlayHints({
-            textDocument: doc
-        });
+        server.didOpenTextDocument({ textDocument: doc });
+        const inlayHints = await server.inlayHints({ textDocument: doc, range: lsp.Range.create(0, 0, 4, 0) });
         assert.isDefined(inlayHints);
         assert.strictEqual(inlayHints.length, 1);
-        assert.strictEqual(inlayHints[0].text, ': number');
-        assert.strictEqual(inlayHints[0].kind, 'Type');
-        assert.deepStrictEqual(inlayHints[0].position, { line: 1, character: 29 });
-    })).timeout(10000);
-    it('inlayHints options set through workspace configuration ', () => __awaiter(void 0, void 0, void 0, function* () {
+        assert.deepEqual(inlayHints[0], {
+            label: ': number',
+            position: { line: 1, character: 29 },
+            kind: lsp.InlayHintKind.Type,
+            paddingLeft: true,
+        });
+    });
+    it('inlayHints (legacy)', async () => {
         const doc = {
-            uri: (0, test_utils_1.uri)('module.ts'),
+            uri: uri('module.ts'),
             languageId: 'typescript',
             version: 1,
             text: `
         export function foo() {
           return 3
         }
-      `
+      `,
         };
-        yield server.initialize({
-            processId: null,
-            capabilities: (0, test_utils_1.getDefaultClientCapabilities)(),
-            workspaceFolders: [],
-            rootUri: ''
-        });
-        server.didChangeConfiguration({
-            settings: {
-                typescript: {
-                    inlayHints: {
-                        includeInlayFunctionLikeReturnTypeHints: true
-                    }
-                }
-            }
-        });
-        server.didOpenTextDocument({
-            textDocument: doc
-        });
-        const { inlayHints } = yield server.inlayHints({
-            textDocument: doc
-        });
+        server.didOpenTextDocument({ textDocument: doc });
+        const { inlayHints } = await server.inlayHintsLegacy({ textDocument: doc });
         assert.isDefined(inlayHints);
         assert.strictEqual(inlayHints.length, 1);
         assert.strictEqual(inlayHints[0].text, ': number');
         assert.strictEqual(inlayHints[0].kind, 'Type');
         assert.deepStrictEqual(inlayHints[0].position, { line: 1, character: 29 });
-    })).timeout(10000);
+    });
+});
+describe('completions without client snippet support', () => {
+    let localServer;
+    before(async () => {
+        const clientCapabilitiesOverride = {
+            textDocument: {
+                completion: {
+                    completionItem: {
+                        snippetSupport: false,
+                    },
+                },
+            },
+        };
+        localServer = await createServer({
+            rootUri: null,
+            publishDiagnostics: args => diagnostics.set(args.uri, args),
+            clientCapabilitiesOverride,
+        });
+    });
+    beforeEach(() => {
+        localServer.closeAll();
+        // "closeAll" triggers final publishDiagnostics with an empty list so clear last.
+        diagnostics.clear();
+        localServer.workspaceEdits = [];
+    });
+    after(() => {
+        localServer.closeAll();
+        localServer.shutdown();
+    });
+    it('resolves completion for method completion does not contain snippet', async () => {
+        const doc = {
+            uri: uri('bar.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: `
+            import fs from 'fs'
+            fs.readFile
+        `,
+        };
+        localServer.didOpenTextDocument({ textDocument: doc });
+        const proposals = await localServer.completion({ textDocument: doc, position: positionAfter(doc, 'readFile') });
+        assert.isNotNull(proposals);
+        const completion = proposals.items.find(completion => completion.label === 'readFile');
+        assert.notEqual(completion.insertTextFormat, lsp.InsertTextFormat.Snippet);
+        assert.strictEqual(completion.label, 'readFile');
+        const resolvedItem = await localServer.completionResolve(completion);
+        assert.strictEqual(resolvedItem.label, 'readFile');
+        assert.strictEqual(resolvedItem.insertText, undefined);
+        assert.strictEqual(resolvedItem.insertTextFormat, undefined);
+        localServer.didCloseTextDocument({ textDocument: doc });
+    });
+    it('does not include snippet completions for element prop', async () => {
+        const doc = {
+            uri: uri('jsx', 'app.tsx'),
+            languageId: 'typescriptreact',
+            version: 1,
+            text: readContents(filePath('jsx', 'app.tsx')),
+        };
+        localServer.didOpenTextDocument({
+            textDocument: doc,
+        });
+        const completion = await localServer.completion({ textDocument: doc, position: position(doc, 'title') });
+        assert.isNotNull(completion);
+        const item = completion.items.find(i => i.label === 'title');
+        assert.isUndefined(item);
+    });
+    it('does not include snippet completions for object methods', async () => {
+        const doc = {
+            uri: uri('foo.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: `
+              interface IFoo {
+                bar(x: number): void;
+              }
+              const obj: IFoo = {
+                /*a*/
+              }
+            `,
+        };
+        localServer.didOpenTextDocument({ textDocument: doc });
+        const proposals = await localServer.completion({
+            textDocument: doc,
+            position: positionAfter(doc, '/*a*/'),
+        });
+        assert.isNotNull(proposals);
+        assert.lengthOf(proposals.items, 1);
+        assert.deepInclude(proposals.items[0], {
+            label: 'bar',
+            kind: 2,
+        });
+    });
 });
 //# sourceMappingURL=lsp-server.spec.js.map