feat: support communicating with tsserver using IPC (typescript-language-server#585)

Author: rchl

LICENSE

@@ -1,3 +1,42 @@
+Parts of the code copied from the https://github.com/microsoft/vscode repository are licensed under the following license:
+
+BEGIN LICENSE ----------------------------------------------------------------
+
+MIT License
+
+Copyright (c) 2015 - present Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+END LICESE -------------------------------------------------------------------
+
+This applies to files that include the following license header:
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+The rest of the code licensed under:
+
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/

src/lsp-server.spec.ts

@@ -158,7 +158,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 });
     });
 

src/lsp-server.ts

@@ -34,52 +34,13 @@ import { IServerOptions } from './utils/configuration.js';
 import { TypeScriptAutoFixProvider } from './features/fix-all.js';
 import { TypeScriptInlayHintsProvider } from './features/inlay-hints.js';
 import { SourceDefinitionCommand } from './features/source-definition.js';
-import { LspClient } from './lsp-client.js';
 import { TypeScriptVersion, TypeScriptVersionProvider } from './tsServer/versionProvider.js';
 import { Position, Range } from './utils/typeConverters.js';
 import { CodeActionKind } from './utils/types.js';
 import { ConfigurationManager } from './configuration-manager.js';
 
-class ServerInitializingIndicator {
-    private _loadingProjectName?: string;
-    private _progressReporter?: lsp.WorkDoneProgressReporter;
-
-    constructor(private lspClient: LspClient) {}
-
-    public reset(): void {
-        if (this._loadingProjectName) {
-            this._loadingProjectName = undefined;
-            if (this._progressReporter) {
-                this._progressReporter.done();
-                this._progressReporter = undefined;
-            }
-        }
-    }
-
-    public async startedLoadingProject(projectName: string): Promise<void> {
-        // TS projects are loaded sequentially. Cancel existing task because it should always be resolved before
-        // the incoming project loading task is.
-        this.reset();
-
-        this._loadingProjectName = projectName;
-        this._progressReporter = await this.lspClient.createProgressReporter();
-        this._progressReporter.begin('Initializing JS/TS language features…');
-    }
-
-    public finishedLoadingProject(projectName: string): void {
-        if (this._loadingProjectName === projectName) {
-            this._loadingProjectName = undefined;
-            if (this._progressReporter) {
-                this._progressReporter.done();
-                this._progressReporter = undefined;
-            }
-        }
-    }
-}
-
 export class LspServer {
     private _tspClient: TspClient | null = null;
-    private _loadingIndicator: ServerInitializingIndicator | null = null;
     private initializeParams: TypeScriptInitializeParams | null = null;
     private diagnosticQueue?: DiagnosticEventQueue;
     private configurationManager: ConfigurationManager;
@@ -106,10 +67,6 @@ export class LspServer {
             this._tspClient.shutdown();
             this._tspClient = null;
         }
-        if (this._loadingIndicator) {
-            this._loadingIndicator.reset();
-            this._loadingIndicator = null;
-        }
     }
 
     private get tspClient(): TspClient {
@@ -119,13 +76,6 @@ export class LspServer {
         return this._tspClient;
     }
 
-    private get loadingIndicator(): ServerInitializingIndicator {
-        if (!this._loadingIndicator) {
-            throw new Error('Loading indicator not created. Did you forget to send the "initialize" request?');
-        }
-        return this._loadingIndicator;
-    }
-
     private findTypescriptVersion(): TypeScriptVersion | null {
         const typescriptVersionProvider = new TypeScriptVersionProvider(this.options, this.logger);
         // User-provided tsserver path.
@@ -158,7 +108,6 @@ export class LspServer {
         }
         this.initializeParams = params;
         const clientCapabilities = this.initializeParams.capabilities;
-        this._loadingIndicator = new ServerInitializingIndicator(this.options.lspClient);
         this.workspaceRoot = this.initializeParams.rootUri ? uriToPath(this.initializeParams.rootUri) : this.initializeParams.rootPath || undefined;
 
         const userInitializationOptions: TypeScriptInitializationOptions = this.initializeParams.initializationOptions || {};
@@ -218,8 +167,8 @@ export class LspServer {
             this.logger,
         );
         this._tspClient = new TspClient({
-            apiVersion: typescriptVersion.version || API.defaultVersion,
-            tsserverPath: typescriptVersion.tsServerPath,
+            lspClient: this.options.lspClient,
+            typescriptVersion,
             logFile,
             logVerbosity,
             disableAutomaticTypingAcquisition,
@@ -400,7 +349,7 @@ export class LspServer {
 
         const { files } = this.documents;
         try {
-            return await this.tspClient.request(CommandTypes.Geterr, { delay: 0, files }, this.diagnosticsTokenSource.token);
+            return await this.tspClient.requestGeterr({ delay: 0, files }, this.diagnosticsTokenSource.token);
         } finally {
             if (this.diagnosticsTokenSource === geterrTokenSource) {
                 this.diagnosticsTokenSource = undefined;
@@ -1176,18 +1125,8 @@ export class LspServer {
     }
 
     protected async onTsEvent(event: protocol.Event): Promise<void> {
-        if (event.event === EventTypes.SementicDiag ||
-            event.event === EventTypes.SyntaxDiag ||
-            event.event === EventTypes.SuggestionDiag) {
+        if (event.event === EventTypes.SementicDiag || event.event === EventTypes.SyntaxDiag || event.event === EventTypes.SuggestionDiag) {
             this.diagnosticQueue?.updateDiagnostics(event.event, event as tsp.DiagnosticEvent);
-        } else if (event.event === EventTypes.ProjectLoadingStart) {
-            await this.loadingIndicator.startedLoadingProject((event as tsp.ProjectLoadingStartEvent).body.projectName);
-        } else if (event.event === EventTypes.ProjectLoadingFinish) {
-            this.loadingIndicator.finishedLoadingProject((event as tsp.ProjectLoadingFinishEvent).body.projectName);
-        } else {
-            this.logger.log('Ignored event', {
-                event: event.event,
-            });
         }
     }
 

src/test-utils.ts

@@ -106,7 +106,7 @@ export function toPlatformEOL(text: string): string {
     return text;
 }
 
-class TestLspClient implements LspClient {
+export class TestLspClient implements LspClient {
     private workspaceEditsListener: ((args: lsp.ApplyWorkspaceEditParams) => void) | null = null;
 
     constructor(protected options: TestLspServerOptions, protected logger: ConsoleLogger) {}
@@ -125,11 +125,11 @@ class TestLspClient implements LspClient {
         return await task(progress);
     }
 
-    publishDiagnostics(args: lsp.PublishDiagnosticsParams) {
+    publishDiagnostics(args: lsp.PublishDiagnosticsParams): void {
         return this.options.publishDiagnostics(args);
     }
 
-    showErrorMessage(message: string) {
+    showErrorMessage(message: string): void {
         this.logger.error(`[showErrorMessage] ${message}`);
     }
 
@@ -148,7 +148,7 @@ class TestLspClient implements LspClient {
         return { applied: true };
     }
 
-    async rename() {
+    rename(): Promise<void> {
         throw new Error('unsupported');
     }
 }

src/tsServer/callbackMap.ts

@@ -0,0 +1,57 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/*
+ * Copyright (C) 2022 TypeFox and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import type tsp from 'typescript/lib/protocol.d.js';
+import { ServerResponse } from './requests.js';
+
+export interface CallbackItem<R> {
+    readonly onSuccess: (value: R) => void;
+    readonly onError: (err: Error) => void;
+    readonly queuingStartTime: number;
+    readonly isAsync: boolean;
+}
+
+export class CallbackMap<R extends tsp.Response> {
+    private readonly _callbacks = new Map<number, CallbackItem<ServerResponse.Response<R> | undefined>>();
+    private readonly _asyncCallbacks = new Map<number, CallbackItem<ServerResponse.Response<R> | undefined>>();
+
+    public destroy(cause: string): void {
+        const cancellation = new ServerResponse.Cancelled(cause);
+        for (const callback of this._callbacks.values()) {
+            callback.onSuccess(cancellation);
+        }
+        this._callbacks.clear();
+        for (const callback of this._asyncCallbacks.values()) {
+            callback.onSuccess(cancellation);
+        }
+        this._asyncCallbacks.clear();
+    }
+
+    public add(seq: number, callback: CallbackItem<ServerResponse.Response<R> | undefined>, isAsync: boolean): void {
+        if (isAsync) {
+            this._asyncCallbacks.set(seq, callback);
+        } else {
+            this._callbacks.set(seq, callback);
+        }
+    }
+
+    public fetch(seq: number): CallbackItem<ServerResponse.Response<R> | undefined> | undefined {
+        const callback = this._callbacks.get(seq) || this._asyncCallbacks.get(seq);
+        this.delete(seq);
+        return callback;
+    }
+
+    private delete(seq: number) {
+        if (!this._callbacks.delete(seq)) {
+            this._asyncCallbacks.delete(seq);
+        }
+    }
+}

src/tsServer/cancellation.ts

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/*
+ * Copyright (C) 2022 TypeFox and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import fs from 'node:fs';
+import { temporaryFile } from 'tempy';
+// import Tracer from '../utils/tracer';
+
+export interface OngoingRequestCanceller {
+    readonly cancellationPipeName: string | undefined;
+    tryCancelOngoingRequest(seq: number): boolean;
+}
+
+export interface OngoingRequestCancellerFactory {
+    create(/*serverId: string, tracer: Tracer*/): OngoingRequestCanceller;
+}
+
+const noopRequestCanceller = new class implements OngoingRequestCanceller {
+    public readonly cancellationPipeName = undefined;
+
+    public tryCancelOngoingRequest(_seq: number): boolean {
+        return false;
+    }
+};
+
+export const noopRequestCancellerFactory = new class implements OngoingRequestCancellerFactory {
+    create(/*_serverId: string, _tracer: Tracer*/): OngoingRequestCanceller {
+        return noopRequestCanceller;
+    }
+};
+
+export class NodeRequestCanceller implements OngoingRequestCanceller {
+    public readonly cancellationPipeName: string;
+
+    public constructor(
+        // private readonly _serverId: string,
+        // private readonly _tracer: Tracer,
+    ) {
+        this.cancellationPipeName = temporaryFile({ name: 'tscancellation' });
+    }
+
+    public tryCancelOngoingRequest(seq: number): boolean {
+        if (!this.cancellationPipeName) {
+            return false;
+        }
+        // this._tracer.logTrace(this._serverId, `TypeScript Server: trying to cancel ongoing request with sequence number ${seq}`);
+        try {
+            fs.writeFileSync(this.cancellationPipeName + String(seq), '');
+        } catch {
+            // noop
+        }
+        return true;
+    }
+}
+
+export const nodeRequestCancellerFactory = new class implements OngoingRequestCancellerFactory {
+    create(/*serverId: string, tracer: Tracer*/): OngoingRequestCanceller {
+        return new NodeRequestCanceller(/*serverId, tracer*/);
+    }
+};