typescript-language-server 1.1.2 → 2.0.0

package/lib/lsp-server.spec.js

@@ -7,10 +7,11 @@
 import * as chai from 'chai';
 import fs from 'fs-extra';
 import * as lsp from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
 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 { SemicolonPreference } from './ts-protocol.js';
 import { CodeActionKind } from './utils/types.js';
 const assert = chai.assert;
 const diagnostics = new Map();
@@ -20,13 +21,6 @@ before(async () => {
         rootUri: uri(),
         publishDiagnostics: args => diagnostics.set(args.uri, args),
     });
-    server.didChangeConfiguration({
-        settings: {
-            completions: {
-                completeFunctionCalls: true,
-            },
-        },
-    });
 });
 beforeEach(() => {
     server.closeAll();
@@ -144,7 +138,8 @@ describe('completion', () => {
         });
         const pos = position(doc, 'foo');
         const proposals = await server.completion({ textDocument: doc, position: pos });
-        assert.isNull(proposals);
+        assert.isNotNull(proposals);
+        assert.strictEqual(proposals?.items.length, 0);
         server.didCloseTextDocument({ textDocument: doc });
     });
     it('includes completions from global modules', async () => {
@@ -184,6 +179,125 @@ describe('completion', () => {
         assert.equal(completion.textEdit.newText, '["invalid-identifier-name"]');
         server.didCloseTextDocument({ textDocument: doc });
     });
+    it('completions for clients that support insertReplaceSupport', async () => {
+        const doc = {
+            uri: uri('bar.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: `
+                class Foo {
+                    getById() {};
+                }
+
+                const foo = new Foo()
+                foo.getById()
+            `,
+        };
+        server.didOpenTextDocument({ textDocument: doc });
+        const proposals = await server.completion({ textDocument: doc, position: positionAfter(doc, '.get') });
+        assert.isNotNull(proposals);
+        const completion = proposals.items.find(completion => completion.label === 'getById');
+        assert.isDefined(completion);
+        assert.deepInclude(completion, {
+            label: 'getById',
+            kind: lsp.CompletionItemKind.Method,
+            textEdit: {
+                newText: 'getById',
+                insert: {
+                    start: {
+                        line: 6,
+                        character: 20,
+                    },
+                    end: {
+                        line: 6,
+                        character: 23,
+                    },
+                },
+                replace: {
+                    start: {
+                        line: 6,
+                        character: 20,
+                    },
+                    end: {
+                        line: 6,
+                        character: 27,
+                    },
+                },
+            },
+        });
+        server.didCloseTextDocument({ textDocument: doc });
+    });
+    it('completions for clients that do not support insertReplaceSupport', async () => {
+        const clientCapabilitiesOverride = {
+            textDocument: {
+                completion: {
+                    completionItem: {
+                        insertReplaceSupport: false,
+                    },
+                },
+            },
+        };
+        const localServer = await createServer({
+            rootUri: null,
+            publishDiagnostics: () => { },
+            clientCapabilitiesOverride,
+        });
+        const doc = {
+            uri: uri('bar.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: `
+                class Foo {
+                    getById() {};
+                }
+
+                const foo = new Foo()
+                foo.getById()
+            `,
+        };
+        localServer.didOpenTextDocument({ textDocument: doc });
+        const proposals = await localServer.completion({ textDocument: doc, position: positionAfter(doc, '.get') });
+        assert.isNotNull(proposals);
+        const completion = proposals.items.find(completion => completion.label === 'getById');
+        assert.isDefined(completion);
+        assert.isUndefined(completion.textEdit);
+        localServer.didCloseTextDocument({ textDocument: doc });
+        localServer.closeAll();
+        localServer.shutdown();
+    });
+    it('provides snippet completion in import statement', async () => {
+        const doc = {
+            uri: uri('bar.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: 'import { readFile }',
+        };
+        server.didOpenTextDocument({ textDocument: doc });
+        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.deepInclude(completion, {
+            label: 'readFile',
+            kind: lsp.CompletionItemKind.Function,
+            insertTextFormat: lsp.InsertTextFormat.Snippet,
+            detail: 'fs',
+            textEdit: {
+                newText: 'import { readFile$1 } from "fs";',
+                range: {
+                    start: {
+                        line: 0,
+                        character: 0,
+                    },
+                    end: {
+                        line: 0,
+                        character: 19,
+                    },
+                },
+            },
+        });
+        server.didCloseTextDocument({ textDocument: doc });
+    });
     it('includes detail field with package name for auto-imports', async () => {
         const doc = {
             uri: uri('bar.ts'),
@@ -197,7 +311,6 @@ describe('completion', () => {
         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', async () => {
@@ -231,13 +344,11 @@ describe('completion', () => {
         server.didCloseTextDocument({ textDocument: doc });
     });
     it('resolves text edit for auto-import completion in right format', async () => {
-        server.didChangeConfiguration({
-            settings: {
-                typescript: {
-                    format: {
-                        semicolons: 'remove',
-                        insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: false,
-                    },
+        server.updateWorkspaceSettings({
+            typescript: {
+                format: {
+                    semicolons: SemicolonPreference.Remove,
+                    insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: false,
                 },
             },
         });
@@ -269,21 +380,21 @@ describe('completion', () => {
             },
         ]);
         server.didCloseTextDocument({ textDocument: doc });
-        server.didChangeConfiguration({
-            settings: {
-                completions: {
-                    completeFunctionCalls: true,
-                },
-                typescript: {
-                    format: {
-                        semicolons: 'ignore',
-                        insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
-                    },
+        server.updateWorkspaceSettings({
+            typescript: {
+                format: {
+                    semicolons: SemicolonPreference.Ignore,
+                    insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
                 },
             },
         });
     });
     it('resolves a snippet for method completion', async () => {
+        server.updateWorkspaceSettings({
+            completions: {
+                completeFunctionCalls: true,
+            },
+        });
         const doc = {
             uri: uri('bar.ts'),
             languageId: 'typescript',
@@ -297,13 +408,197 @@ describe('completion', () => {
         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 = 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');
+        assert.deepInclude(resolvedItem, {
+            label: 'readFile',
+            insertTextFormat: lsp.InsertTextFormat.Snippet,
+            // eslint-disable-next-line no-template-curly-in-string
+            insertText: 'readFile(${1:path}, ${2:options}, ${3:callback})$0',
+            textEdit: {
+                // eslint-disable-next-line no-template-curly-in-string
+                newText: 'readFile(${1:path}, ${2:options}, ${3:callback})$0',
+                insert: {
+                    start: {
+                        line: 2,
+                        character: 19,
+                    },
+                    end: {
+                        line: 2,
+                        character: 27,
+                    },
+                },
+                replace: {
+                    start: {
+                        line: 2,
+                        character: 19,
+                    },
+                    end: {
+                        line: 2,
+                        character: 27,
+                    },
+                },
+            },
+        });
         server.didCloseTextDocument({ textDocument: doc });
+        server.updateWorkspaceSettings({
+            completions: {
+                completeFunctionCalls: false,
+            },
+        });
+    });
+    it('does not provide snippet completion for "$" function when completeFunctionCalls disabled', async () => {
+        const doc = {
+            uri: uri('bar.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: `
+                function $(): void {}
+                /**/$
+            `,
+        };
+        server.didOpenTextDocument({ textDocument: doc });
+        const proposals = await server.completion({ textDocument: doc, position: positionAfter(doc, '/**/') });
+        assert.isNotNull(proposals);
+        const completion = proposals.items.find(completion => completion.label === '$');
+        assert.deepInclude(completion, {
+            label: '$',
+            textEdit: {
+                newText: '$',
+                insert: {
+                    start: {
+                        line: 2,
+                        character: 20,
+                    },
+                    end: {
+                        line: 2,
+                        character: 20,
+                    },
+                },
+                replace: {
+                    start: {
+                        line: 2,
+                        character: 20,
+                    },
+                    end: {
+                        line: 2,
+                        character: 21,
+                    },
+                },
+            },
+        });
+        const resolvedItem = await server.completionResolve(completion);
+        assert.deepInclude(resolvedItem, {
+            label: '$',
+            textEdit: {
+                newText: '$',
+                insert: {
+                    start: {
+                        line: 2,
+                        character: 20,
+                    },
+                    end: {
+                        line: 2,
+                        character: 20,
+                    },
+                },
+                replace: {
+                    start: {
+                        line: 2,
+                        character: 20,
+                    },
+                    end: {
+                        line: 2,
+                        character: 21,
+                    },
+                },
+            },
+        });
+        server.didCloseTextDocument({ textDocument: doc });
+    });
+    it('provides snippet completions for "$" function when completeFunctionCalls enabled', async () => {
+        server.updateWorkspaceSettings({
+            completions: {
+                completeFunctionCalls: true,
+            },
+        });
+        const doc = {
+            uri: uri('bar.ts'),
+            languageId: 'typescript',
+            version: 1,
+            text: `
+                function $(): void {}
+                /**/$
+            `,
+        };
+        server.didOpenTextDocument({ textDocument: doc });
+        const proposals = await server.completion({ textDocument: doc, position: positionAfter(doc, '/**/') });
+        assert.isNotNull(proposals);
+        const completion = proposals.items.find(completion => completion.label === '$');
+        // NOTE: Technically not valid until resolved.
+        assert.deepInclude(completion, {
+            label: '$',
+            insertTextFormat: lsp.InsertTextFormat.Snippet,
+            textEdit: {
+                newText: '$',
+                insert: {
+                    start: {
+                        line: 2,
+                        character: 20,
+                    },
+                    end: {
+                        line: 2,
+                        character: 20,
+                    },
+                },
+                replace: {
+                    start: {
+                        line: 2,
+                        character: 20,
+                    },
+                    end: {
+                        line: 2,
+                        character: 21,
+                    },
+                },
+            },
+        });
+        const resolvedItem = await server.completionResolve(completion);
+        assert.deepInclude(resolvedItem, {
+            label: '$',
+            insertTextFormat: lsp.InsertTextFormat.Snippet,
+            // eslint-disable-next-line no-template-curly-in-string
+            insertText: '\\$()$0',
+            textEdit: {
+                // eslint-disable-next-line no-template-curly-in-string
+                newText: '\\$()$0',
+                insert: {
+                    start: {
+                        line: 2,
+                        character: 20,
+                    },
+                    end: {
+                        line: 2,
+                        character: 20,
+                    },
+                },
+                replace: {
+                    start: {
+                        line: 2,
+                        character: 20,
+                    },
+                    end: {
+                        line: 2,
+                        character: 21,
+                    },
+                },
+            },
+        });
+        server.didCloseTextDocument({ textDocument: doc });
+        server.updateWorkspaceSettings({
+            completions: {
+                completeFunctionCalls: false,
+            },
+        });
     });
     it('includes textEdit for string completion', async () => {
         const doc = {
@@ -315,7 +610,7 @@ describe('completion', () => {
                 return true;
               }
 
-              test("fs/")
+              test("fs/r")
             `,
         };
         server.didOpenTextDocument({ textDocument: doc });
@@ -329,13 +624,21 @@ describe('completion', () => {
         });
         assert.isNotNull(proposals);
         const completion = proposals.items.find(completion => completion.label === 'fs/read');
-        assert.strictEqual(completion.label, 'fs/read');
-        assert.deepStrictEqual(completion.textEdit, {
-            range: {
-                start: { line: 5, character: 20 },
-                end: { line: 5, character: 23 },
+        assert.deepInclude(completion, {
+            label: 'fs/read',
+            textEdit: {
+                newText: 'fs/read',
+                range: {
+                    start: {
+                        line: 5,
+                        character: 20,
+                    },
+                    end: {
+                        line: 5,
+                        character: 24,
+                    },
+                },
             },
-            newText: 'fs/read',
         });
     });
     it('includes labelDetails with useLabelDetailsInCompletionEntries enabled', async () => {
@@ -361,16 +664,14 @@ describe('completion', () => {
         assert.lengthOf(proposals.items, 2);
         assert.deepInclude(proposals.items[0], {
             label: 'bar',
-            kind: 2,
-            insertTextFormat: 2,
+            kind: lsp.CompletionItemKind.Method,
         });
         assert.deepInclude(proposals.items[1], {
             label: 'bar',
             labelDetails: {
                 detail: '(x)',
             },
-            kind: 2,
-            insertTextFormat: 2,
+            kind: lsp.CompletionItemKind.Method,
             insertText: toPlatformEOL('bar(x) {\n    $0\n},'),
         });
     });
@@ -574,11 +875,9 @@ describe('diagnostics', () => {
         assert.equal(diagnosticsForDoc2.diagnostics.length, 1, JSON.stringify(diagnostics));
     });
     it('code 6133 (ununsed variable) is ignored', async () => {
-        server.didChangeConfiguration({
-            settings: {
-                diagnostics: {
-                    ignoredCodes: [6133],
-                },
+        server.updateWorkspaceSettings({
+            diagnostics: {
+                ignoredCodes: [6133],
             },
         });
         const doc = {
@@ -784,24 +1083,22 @@ describe('references', () => {
 //                 export function foo(): void {
 //                   console.log('test')
 //                 }
-//             `
+//             `,
 //         };
 //         server.didOpenTextDocument({
-//             textDocument: doc
+//             textDocument: doc,
 //         });
-//         server.didChangeConfiguration({
-//             settings: {
-//                 typescript: {
-//                     format: {
-//                         insertSpaceAfterCommaDelimiter: true
-//                     }
+//         server.updateWorkspaceSettingsttings({
+//             typescript: {
+//                 format: {
+//                     insertSpaceAfterCommaDelimiter: true,
 //                 },
-//                 javascript: {
-//                     format: {
-//                         insertSpaceAfterCommaDelimiter: false
-//                     }
-//                 }
-//             }
+//             },
+//             javascript: {
+//                 format: {
+//                     insertSpaceAfterCommaDelimiter: false,
+//                 },
+//             },
 //         });
 //         const file = filePath('bar.ts');
 //         const settings = server.getWorkspacePreferencesForDocument(file);
@@ -812,6 +1109,16 @@ describe('formatting', () => {
     const uriString = uri('bar.ts');
     const languageId = 'typescript';
     const version = 1;
+    before(async () => {
+        server.updateWorkspaceSettings({
+            typescript: {
+                format: {
+                    semicolons: SemicolonPreference.Ignore,
+                    insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+                },
+            },
+        });
+    });
     it('full document formatting', async () => {
         const text = 'export  function foo (     )   :  void   {   }';
         const textDocument = {
@@ -866,13 +1173,11 @@ describe('formatting', () => {
             uri: uriString, languageId, version, text,
         };
         server.didOpenTextDocument({ textDocument });
-        server.didChangeConfiguration({
-            settings: {
-                typescript: {
-                    format: {
-                        newLineCharacter: '\n',
-                        placeOpenBraceOnNewLineForFunctions: true,
-                    },
+        server.updateWorkspaceSettings({
+            typescript: {
+                format: {
+                    newLineCharacter: '\n',
+                    placeOpenBraceOnNewLineForFunctions: true,
                 },
             },
         });
@@ -1775,23 +2080,19 @@ describe('jsx/tsx project', () => {
 });
 describe('inlayHints', () => {
     before(async () => {
-        server.didChangeConfiguration({
-            settings: {
-                typescript: {
-                    inlayHints: {
-                        includeInlayFunctionLikeReturnTypeHints: true,
-                    },
+        server.updateWorkspaceSettings({
+            typescript: {
+                inlayHints: {
+                    includeInlayFunctionLikeReturnTypeHints: true,
                 },
             },
         });
     });
     after(() => {
-        server.didChangeConfiguration({
-            settings: {
-                typescript: {
-                    inlayHints: {
-                        includeInlayFunctionLikeReturnTypeHints: false,
-                    },
+        server.updateWorkspaceSettings({
+            typescript: {
+                inlayHints: {
+                    includeInlayFunctionLikeReturnTypeHints: false,
                 },
             },
         });