typescript-language-server 1.0.0 → 1.1.0

package/lib/lsp-server.spec.js

@@ -4,39 +4,30 @@
  * 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 __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());
-    });
-};
 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, getDefaultClientCapabilities, positionAfter, readContents, toPlatformEOL } from './test-utils.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 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.
@@ -48,7 +39,7 @@ after(() => {
     server.shutdown();
 });
 describe('completion', () => {
-    it('simple test', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('simple test', async () => {
         const doc = {
             uri: uri('bar.ts'),
             languageId: 'typescript',
@@ -57,23 +48,23 @@ describe('completion', () => {
         export function foo(): void {
           console.log('test')
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
         const pos = position(doc, 'console');
-        const proposals = yield server.completion({ textDocument: doc, position: pos });
+        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 });
-    }));
-    it('simple JS test', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('simple JS test', async () => {
         const doc = {
             uri: uri('bar.js'),
             languageId: 'javascript',
@@ -82,18 +73,18 @@ describe('completion', () => {
         export function foo() {
           console.log('test')
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
         const pos = position(doc, 'console');
-        const proposals = yield server.completion({ textDocument: doc, position: pos });
+        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) {
@@ -105,8 +96,8 @@ describe('completion', () => {
         }, false);
         assert.isFalse(containsInvalidCompletions);
         server.didCloseTextDocument({ textDocument: doc });
-    }));
-    it('deprecated by JSDoc', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('deprecated by JSDoc', async () => {
         const doc = {
             uri: uri('bar.ts'),
             languageId: 'typescript',
@@ -121,23 +112,23 @@ describe('completion', () => {
             }
 
             foo(); // call me
-            `
+            `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
         const pos = position(doc, 'foo(); // call me');
-        const proposals = yield server.completion({ textDocument: doc, position: pos });
+        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 });
-    }));
-    it('incorrect source location', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('incorrect source location', async () => {
         const doc = {
             uri: uri('bar.ts'),
             languageId: 'typescript',
@@ -146,31 +137,31 @@ describe('completion', () => {
         export function foo(): void {
           console.log('test')
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
         const pos = position(doc, 'foo');
-        const proposals = yield server.completion({ textDocument: doc, position: pos });
+        const proposals = await server.completion({ textDocument: doc, position: pos });
         assert.isNull(proposals);
         server.didCloseTextDocument({ textDocument: doc });
-    }));
-    it('includes completions from global modules', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('includes completions from global modules', async () => {
         const doc = {
             uri: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'pathex'
+            text: 'pathex',
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: 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 });
-    }));
-    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: uri('bar.ts'),
             languageId: 'typescript',
@@ -182,117 +173,117 @@ describe('completion', () => {
 
                 const foo: Foo
                 foo.i
-            `
+            `,
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: 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 });
-    }));
-    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: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'readFile'
+            text: 'readFile',
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: 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 });
-    }));
-    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: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'readFile'
+            text: 'readFile',
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: 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 });
-    }));
-    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: uri('bar.ts'),
             languageId: 'typescript',
             version: 1,
-            text: 'readFile'
+            text: 'readFile',
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: 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,
+                    },
+                },
+            },
         });
-    }));
-    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: uri('bar.ts'),
             languageId: 'typescript',
@@ -300,21 +291,21 @@ describe('completion', () => {
             text: `
                 import fs from 'fs'
                 fs.readFile
-            `
+            `,
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({ textDocument: doc, position: 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 });
-    }));
-    it('includes textEdit for string completion', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('includes textEdit for string completion', async () => {
         const doc = {
             uri: uri('bar.ts'),
             languageId: 'typescript',
@@ -325,16 +316,16 @@ describe('completion', () => {
               }
 
               test("fs/")
-            `
+            `,
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({
+        const proposals = await server.completion({
             textDocument: doc,
             position: positionAfter(doc, 'test("fs/'),
             context: {
                 triggerCharacter: '/',
-                triggerKind: 2
-            }
+                triggerKind: 2,
+            },
         });
         assert.isNotNull(proposals);
         const completion = proposals.items.find(completion => completion.label === 'fs/read');
@@ -342,12 +333,12 @@ 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'
+            newText: 'fs/read',
         });
-    }));
-    it('includes labelDetails with useLabelDetailsInCompletionEntries enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('includes labelDetails with useLabelDetailsInCompletionEntries enabled', async () => {
         const doc = {
             uri: uri('foo.ts'),
             languageId: 'typescript',
@@ -359,33 +350,142 @@ describe('completion', () => {
               const obj: IFoo = {
                 /*a*/
               }
-            `
+            `,
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const proposals = yield server.completion({
+        const proposals = await server.completion({
             textDocument: doc,
-            position: positionAfter(doc, '/*a*/')
+            position: positionAfter(doc, '/*a*/'),
         });
         assert.isNotNull(proposals);
         assert.lengthOf(proposals.items, 2);
         assert.deepInclude(proposals.items[0], {
             label: 'bar',
             kind: 2,
-            insertTextFormat: 2
+            insertTextFormat: 2,
         });
         assert.deepInclude(proposals.items[1], {
             label: 'bar',
             labelDetails: {
-                detail: '(x)'
+                detail: '(x)',
             },
             kind: 2,
             insertTextFormat: 2,
-            insertText: toPlatformEOL('bar(x) {\n    $0\n},')
+            insertText: toPlatformEOL('bar(x) {\n    $0\n},'),
         });
-    }));
+    });
+});
+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: uri('diagnosticsBar.ts'),
             languageId: 'typescript',
@@ -394,20 +494,20 @@ describe('diagnostics', () => {
         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);
-    }));
-    it('supports diagnostic tags', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('supports diagnostic tags', async () => {
         const doc = {
             uri: uri('diagnosticsBar.ts'),
             languageId: 'typescript',
@@ -418,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;
@@ -435,8 +535,8 @@ describe('diagnostics', () => {
         const deprecatedDiagnostic = fileDiagnostics.find(d => d.code === 6387);
         assert.isDefined(deprecatedDiagnostic);
         assert.deepEqual(deprecatedDiagnostic.tags, [lsp.DiagnosticTag.Deprecated]);
-    }));
-    it('multiple files test', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('multiple files test', async () => {
         const doc = {
             uri: uri('multipleFileDiagnosticsBar.ts'),
             languageId: 'typescript',
@@ -445,7 +545,7 @@ describe('diagnostics', () => {
     export function bar(): void {
         missing('test')
     }
-`
+`,
         };
         const doc2 = {
             uri: uri('multipleFileDiagnosticsFoo.ts'),
@@ -455,16 +555,16 @@ describe('diagnostics', () => {
     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);
@@ -472,14 +572,14 @@ describe('diagnostics', () => {
         assert.isDefined(diagnosticsForDoc2);
         assert.equal(diagnosticsForDoc.diagnostics.length, 1, JSON.stringify(diagnostics));
         assert.equal(diagnosticsForDoc2.diagnostics.length, 1, JSON.stringify(diagnostics));
-    }));
-    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: uri('diagnosticsBar2.ts'),
@@ -490,21 +590,21 @@ 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));
-    }));
+    });
 });
 describe('document symbol', () => {
-    it('simple test', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('simple test', async () => {
         const doc = {
             uri: uri('bar.ts'),
             languageId: 'typescript',
@@ -515,22 +615,19 @@ 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');
-    }));
-    it('merges interfaces correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('merges interfaces correctly', async () => {
         const doc = {
             uri: uri('bar.ts'),
             languageId: 'typescript',
@@ -543,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
@@ -559,8 +653,8 @@ Box
 Box
   scale
 `, symbolsAsString(symbols) + '\n');
-    }));
-    it('duplication test', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('duplication test', async () => {
         const doc = {
             uri: uri('bar.ts'),
             languageId: 'typescript',
@@ -576,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
@@ -598,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 } });
-    }));
+    });
 });
 function symbolsAsString(symbols, indentation = '') {
     return symbols.map(symbol => {
@@ -617,7 +708,7 @@ 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: uri('openAndChangeBar.ts'),
             languageId: 'typescript',
@@ -625,10 +716,10 @@ describe('editing', () => {
             text: `
         export function foo(): void {
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
         server.didChangeTextDocument({
             textDocument: doc,
@@ -638,21 +729,21 @@ 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);
-    }));
+    });
 });
 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: uri('foo.ts'),
             languageId: 'typescript',
@@ -660,119 +751,119 @@ describe('references', () => {
             text: `
                 function foo() {};
                 foo();
-            `
+            `,
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
         // Without declaration/definition.
         const position = lastPosition(doc, 'function foo()');
-        let references = yield server.references({
+        let references = await server.references({
             context: { includeDeclaration: false },
             textDocument: doc,
-            position
+            position,
         });
         assert.strictEqual(references.length, 1);
         assert.strictEqual(references[0].range.start.line, 2);
         // With declaration/definition.
-        references = yield server.references({
+        references = await server.references({
             context: { includeDeclaration: true },
             textDocument: doc,
-            position
+            position,
         });
         assert.strictEqual(references.length, 2);
-    }));
-});
-describe('workspace configuration', () => {
-    it('receives workspace configuration notification', () => __awaiter(void 0, void 0, void 0, function* () {
-        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('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 = 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 = TextDocument.applyEdits(TextDocument.create(uriString, languageId, version, text), edits);
         assert.equal('export function foo(): void { }', result);
-    }));
-    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 = TextDocument.applyEdits(TextDocument.create(uriString, languageId, version, text), edits);
         assert.equal('function foo() {\n   // some code\n}', result);
-    }));
-    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 = TextDocument.applyEdits(TextDocument.create(uriString, languageId, version, text), edits);
         assert.equal('function foo() {\n\t// some code\n}', result);
-    }));
-    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({
@@ -780,73 +871,110 @@ 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 = TextDocument.applyEdits(TextDocument.create(uriString, languageId, version, text), edits);
         assert.equal('function foo()\n{\n\t// some code\n}', result);
-    }));
-    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 = 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);
-    }));
+    });
 });
 describe('signatureHelp', () => {
-    it('simple test', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('simple test', 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
+            textDocument: doc,
         });
-        let result = (yield server.signatureHelp({
+        let result = (await server.signatureHelp({
             textDocument: doc,
-            position: 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: position(doc, 'param2')
+            position: position(doc, 'param2'),
         }));
         assert.equal('baz?: boolean', result.signatures[result.activeSignature].parameters[result.activeParameter].label);
-    }));
+    });
+    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 = {
@@ -856,28 +984,28 @@ describe('code actions', () => {
         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');
@@ -893,29 +1021,29 @@ describe('code actions', () => {
                             {
                                 textDocument: {
                                     uri: uri('bar.ts'),
-                                    version: 1
+                                    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);
@@ -932,34 +1060,34 @@ describe('code actions', () => {
                         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',
         });
-    }));
-    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, [
             {
@@ -972,65 +1100,65 @@ describe('code actions', () => {
                             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',
+            },
         ]);
-    }));
-    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: [CodeActionKind.SourceOrganizeImportsTs.value]
-            }
+                only: [CodeActionKind.SourceOrganizeImportsTs.value],
+            },
         }));
         assert.deepEqual(result, []);
-    }));
-    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: 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: [CodeActionKind.SourceAddMissingImportsTs.value]
-            }
+                only: [CodeActionKind.SourceAddMissingImportsTs.value],
+            },
         }));
         assert.deepEqual(result, [
             {
@@ -1046,26 +1174,26 @@ describe('code actions', () => {
                                     range: {
                                         end: {
                                             character: 0,
-                                            line: 0
+                                            line: 0,
                                         },
                                         start: {
                                             character: 0,
-                                            line: 0
-                                        }
-                                    }
-                                }
+                                            line: 0,
+                                        },
+                                    },
+                                },
                             ],
                             textDocument: {
                                 uri: uri('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    }));
-    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: uri('bar.ts'),
             languageId: 'typescript',
@@ -1073,23 +1201,23 @@ describe('code actions', () => {
             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: [CodeActionKind.SourceFixAllTs.value]
-            }
+                only: [CodeActionKind.SourceFixAllTs.value],
+            },
         }));
         assert.deepEqual(result, [
             {
@@ -1104,54 +1232,54 @@ describe('code actions', () => {
                                     range: {
                                         end: {
                                             character: 0,
-                                            line: 3
+                                            line: 3,
                                         },
                                         start: {
                                             character: 0,
-                                            line: 2
-                                        }
-                                    }
-                                }
+                                            line: 2,
+                                        },
+                                    },
+                                },
                             ],
                             textDocument: {
                                 uri: uri('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    }));
-    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: 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: [CodeActionKind.SourceOrganizeImportsTs.value]
-            }
+                only: [CodeActionKind.SourceOrganizeImportsTs.value],
+            },
         }));
         assert.deepEqual(result, [
             {
@@ -1166,60 +1294,60 @@ 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: uri('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    }));
-    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: 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: position(doc, 'existsSync'),
-                end: positionAfter(doc, 'existsSync')
+                end: positionAfter(doc, 'existsSync'),
             },
             context: {
                 diagnostics: [],
-                only: [CodeActionKind.SourceRemoveUnusedTs.value]
-            }
+                only: [CodeActionKind.SourceRemoveUnusedTs.value],
+            },
         }));
         assert.deepEqual(result, [
             {
@@ -1234,26 +1362,26 @@ existsSync('t');`
                                     range: {
                                         end: {
                                             character: 32,
-                                            line: 0
+                                            line: 0,
                                         },
                                         start: {
                                             character: 0,
-                                            line: 0
-                                        }
-                                    }
-                                }
+                                            line: 0,
+                                        },
+                                    },
+                                },
                             ],
                             textDocument: {
                                 uri: uri('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    }));
-    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: uri('bar.ts'),
             languageId: 'typescript',
@@ -1264,23 +1392,23 @@ 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: lastPosition(doc, '}')
+                end: lastPosition(doc, '}'),
             },
             context: {
                 diagnostics: [],
-                only: [CodeActionKind.SourceFixAllTs.value]
-            }
+                only: [CodeActionKind.SourceFixAllTs.value],
+            },
         }));
         assert.strictEqual(result.length, 1, JSON.stringify(result, null, 2));
         assert.deepEqual(result, [
@@ -1296,55 +1424,55 @@ existsSync('t');`
                                     range: {
                                         start: {
                                             line: 4,
-                                            character: 0
+                                            character: 0,
                                         },
                                         end: {
                                             line: 5,
-                                            character: 0
-                                        }
-                                    }
-                                }
+                                            character: 0,
+                                        },
+                                    },
+                                },
                             ],
                             textDocument: {
                                 uri: uri('bar.ts'),
-                                version: 1
-                            }
-                        }
-                    ]
-                }
-            }
+                                version: 1,
+                            },
+                        },
+                    ],
+                },
+            },
         ]);
-    }));
+    });
 });
 describe('executeCommand', () => {
-    it('apply refactoring (move to new file)', () => __awaiter(void 0, void 0, void 0, function* () {
+    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 {}'
+            text: 'export function fn(): void {}\nexport function newFn(): void {}',
         };
         server.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        const codeActions = (yield server.codeAction({
+        const codeActions = (await server.codeAction({
             textDocument: doc,
             range: {
                 start: position(doc, 'newFn'),
-                end: position(doc, 'newFn')
+                end: position(doc, 'newFn'),
             },
             context: {
-                diagnostics: []
-            }
+                diagnostics: [],
+            },
         }));
         // Find refactoring code action.
-        const applyRefactoringAction = codeActions.find(action => { var _a; return ((_a = action.command) === null || _a === void 0 ? void 0 : _a.command) === Commands.APPLY_REFACTORING; });
+        const applyRefactoringAction = codeActions.find(action => action.command?.command === Commands.APPLY_REFACTORING);
         assert.isDefined(applyRefactoringAction);
         // Execute refactoring action.
-        yield server.executeCommand({
+        await server.executeCommand({
             command: applyRefactoringAction.command.command,
-            arguments: applyRefactoringAction.command.arguments
+            arguments: applyRefactoringAction.command.arguments,
         });
         assert.equal(1, server.workspaceEdits.length);
         const { changes } = server.workspaceEdits[0].edit;
@@ -1361,35 +1489,68 @@ describe('executeCommand', () => {
                 range: {
                     start: {
                         line: 1,
-                        character: 0
+                        character: 0,
                     },
                     end: {
                         line: 1,
-                        character: 32
-                    }
+                        character: 32,
+                    },
                 },
-                newText: ''
-            }
+                newText: '',
+            },
         ]);
         assert.deepEqual(change2, [
             {
                 range: {
                     start: {
                         line: 0,
-                        character: 0
+                        character: 0,
                     },
                     end: {
                         line: 0,
-                        character: 0
-                    }
+                        character: 0,
+                    },
                 },
-                newText: 'export function newFn(): void { }\n'
-            }
+                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: uri('bar.d.ts'),
             languageId: 'typescript',
@@ -1398,10 +1559,10 @@ describe('documentHighlight', () => {
         export declare const Bar: unique symbol;
         export interface Bar {
         }
-      `
+      `,
         };
         server.didOpenTextDocument({
-            textDocument: barDoc
+            textDocument: barDoc,
         });
         const fooDoc = {
             uri: uri('bar.ts'),
@@ -1411,17 +1572,17 @@ describe('documentHighlight', () => {
         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: lastPosition(fooDoc, 'Bar')
+            position: lastPosition(fooDoc, 'Bar'),
         });
         assert.equal(2, result.length, JSON.stringify(result, undefined, 2));
-    }));
+    });
 });
 describe('calls', () => {
     function resultToString(callsResult, direction) {
@@ -1456,7 +1617,7 @@ export function two() {
 export function three() {
     return "".toString();
 }
-`
+`,
     };
     const fooDoc = {
         uri: uri('foo.ts'),
@@ -1473,17 +1634,17 @@ class MyClass {
 export function factory() {
     new MyClass().doSomething();
 }
-`
+`,
     };
     function openDocuments() {
         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: position(fooDoc, 'doStuff();')
+            position: position(fooDoc, 'doStuff();'),
         });
         assert.equal(resultToString(callsResult, lspcalls.CallDirection.Incoming), `
 ↘ doStuff (do.ts#1)
@@ -1491,59 +1652,60 @@ export function factory() {
   ↘ doSomething (foo.ts#2) - foo.ts#3
   ↘ x (foo.ts#4) - foo.ts#4
             `.trim());
-    }));
-    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: position(fooDoc, 'doSomething() {')
+            position: position(fooDoc, 'doSomething() {'),
         });
         assert.equal(resultToString(callsResult, lspcalls.CallDirection.Incoming), `
 ↘ doSomething (foo.ts#2)
   ↘ factory (foo.ts#8) - foo.ts#9
             `.trim());
-    }));
-    it.skip('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: position(fooDoc, 'doStuff()')
+            position: position(fooDoc, 'doStuff()'),
         });
         assert.equal(resultToString(callsResult, direction), `
 ↖ doStuff (do.ts#1)
   ↖ two (do.ts#4) - do.ts#2
             `.trim());
-    }));
-    it.skip('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: position(doDoc, 'function two()')
+            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());
-    }));
+    });
 });
 describe('diagnostics (no client support)', () => {
     let localServer;
-    before(() => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
-        // Remove the "textDocument.publishDiagnostics" client capability.
-        const clientCapabilitiesOverride = getDefaultClientCapabilities();
-        (_a = clientCapabilitiesOverride.textDocument) === null || _a === void 0 ? true : delete _a.publishDiagnostics;
-        localServer = yield createServer({
+    before(async () => {
+        const clientCapabilitiesOverride = {
+            textDocument: {
+                publishDiagnostics: undefined,
+            },
+        };
+        localServer = await createServer({
             rootUri: null,
             publishDiagnostics: args => diagnostics.set(args.uri, args),
-            clientCapabilitiesOverride
+            clientCapabilitiesOverride,
         });
-    }));
+    });
     beforeEach(() => {
         localServer.closeAll();
         // "closeAll" triggers final publishDiagnostics with an empty list so clear last.
@@ -1554,7 +1716,7 @@ describe('diagnostics (no client support)', () => {
         localServer.closeAll();
         localServer.shutdown();
     });
-    it('diagnostics are published', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('diagnostic tags are not returned', async () => {
         const doc = {
             uri: uri('diagnosticsBar.ts'),
             languageId: 'typescript',
@@ -1563,26 +1725,27 @@ describe('diagnostics (no client support)', () => {
         export function foo(): void {
           missing('test')
         }
-      `
+      `,
         };
         localServer.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        yield localServer.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);
-    }));
+        assert.strictEqual(resultsForFile.diagnostics.length, 1);
+        assert.notProperty(resultsForFile.diagnostics[0], 'tags');
+    });
 });
 describe('jsx/tsx project', () => {
     let localServer;
-    before(() => __awaiter(void 0, void 0, void 0, function* () {
-        localServer = yield createServer({
+    before(async () => {
+        localServer = await createServer({
             rootUri: uri('jsx'),
-            publishDiagnostics: args => diagnostics.set(args.uri, args)
+            publishDiagnostics: args => diagnostics.set(args.uri, args),
         });
-    }));
+    });
     beforeEach(() => {
         localServer.closeAll();
         // "closeAll" triggers final publishDiagnostics with an empty list so clear last.
@@ -1593,47 +1756,47 @@ describe('jsx/tsx project', () => {
         localServer.closeAll();
         localServer.shutdown();
     });
-    it('includes snippet completion for element prop', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('includes snippet completion for element prop', async () => {
         const doc = {
             uri: uri('jsx', 'app.tsx'),
             languageId: 'typescriptreact',
             version: 1,
-            text: readContents(filePath('jsx', 'app.tsx'))
+            text: readContents(filePath('jsx', 'app.tsx')),
         };
         localServer.didOpenTextDocument({
-            textDocument: doc
+            textDocument: doc,
         });
-        const completion = yield localServer.completion({ textDocument: doc, position: 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);
-    }));
+        assert.strictEqual(item?.insertTextFormat, 2);
+    });
 });
 describe('inlayHints', () => {
-    before(() => __awaiter(void 0, void 0, void 0, function* () {
+    before(async () => {
         server.didChangeConfiguration({
             settings: {
                 typescript: {
                     inlayHints: {
-                        includeInlayFunctionLikeReturnTypeHints: true
-                    }
-                }
-            }
+                        includeInlayFunctionLikeReturnTypeHints: true,
+                    },
+                },
+            },
         });
-    }));
+    });
     after(() => {
         server.didChangeConfiguration({
             settings: {
                 typescript: {
                     inlayHints: {
-                        includeInlayFunctionLikeReturnTypeHints: false
-                    }
-                }
-            }
+                        includeInlayFunctionLikeReturnTypeHints: false,
+                    },
+                },
+            },
         });
     });
-    it('inlayHints', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('inlayHints', async () => {
         const doc = {
             uri: uri('module.ts'),
             languageId: 'typescript',
@@ -1642,15 +1805,129 @@ describe('inlayHints', () => {
         export function foo() {
           return 3
         }
-      `
+      `,
         };
         server.didOpenTextDocument({ textDocument: doc });
-        const { inlayHints } = yield server.inlayHints({ 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.deepEqual(inlayHints[0], {
+            label: ': number',
+            position: { line: 1, character: 29 },
+            kind: lsp.InlayHintKind.Type,
+            paddingLeft: true,
+        });
+    });
+    it('inlayHints (legacy)', async () => {
+        const doc = {
+            uri: uri('module.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: `
+        export function foo() {
+          return 3
+        }
+      `,
+        };
+        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 });
-    }));
+    });
+});
+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