feat(lsp): start the TypeScript server lazily, repoint only on project switch

The server was spawned eagerly on app boot and repointed on every project switch,
regardless of language - so a Python-only project still ran vtsls and re-indexed
it on switch. Mirror VS Code's onLanguage model instead: start the server only
when a served-language (JS/TS/JSX/TSX) file is the active editor, and repoint
(workspace/didChangeWorkspaceFolders) only when a served file is active right
after a project switch - never on ordinary file switches. Once started the server
stays alive idle (no proactive shutdown).

- main.js: _ensureServerForActiveEditor() driven by activeEditorChange + an initial
  evaluation; a pendingRepoint flag (set on EVENT_PROJECT_OPEN) gates the repoint so
  file switches don't touch the workspace-folder/restart machinery. Report a start
  failure via window.logger.reportError, deduped (start is retried lazily). Drop the
  eager appReady start and the now-meaningless readiness flag.
- LSPClient.changeWorkspaceRoot: check same-root first so a redundant call is a no-op
  and never restarts a server that lacks live workspace-folder support.
- tests: the lazy "never started" state isn't observable in the reused integration
  window (keep-alive, no stop path), so don't assert it; drop the readiness-flag wait
  (window load already guarantees the extension's appReady ran).

Author: abose

src/extensions/default/TypeScriptSupport/main.js

@@ -33,6 +33,7 @@ define(function (require, exports, module) {
     const AppInit = brackets.getModule("utils/AppInit"),
         ProjectManager = brackets.getModule("project/ProjectManager"),
         DocumentManager = brackets.getModule("document/DocumentManager"),
+        EditorManager = brackets.getModule("editor/EditorManager"),
         FileSystem = brackets.getModule("filesystem/FileSystem"),
         NodeConnector = brackets.getModule("NodeConnector"),
         CodeIntelligence = require("./CodeIntelligence");
@@ -203,8 +204,7 @@ define(function (require, exports, module) {
      * @return {boolean}
      */
     function canRun() {
-        return typeof Phoenix !== "undefined" && Phoenix.isNativeApp &&
-            NodeConnector.isNodeAvailable && NodeConnector.isNodeAvailable();
+        return Phoenix.isNativeApp && NodeConnector.isNodeAvailable();
     }
 
     /**
@@ -252,23 +252,71 @@ define(function (require, exports, module) {
         }
     }
 
-    // Begin loading the LSP framework as soon as the (desktop-only) extension loads - the
-    // reliable moment for module loading - so it is ready by the time start() runs.
+    // Begin loading the LSP framework as soon as the (desktop-only) extension loads - the reliable
+    // moment for module loading - so it is ready by the time we first need it. This only loads the
+    // module; it does not spawn the server (that happens lazily, on the first served-language file).
     if (canRun()) {
         loadLSPClient();
     }
 
+    /**
+     * True when the active editor holds a language this server handles (JS/TS/JSX/TSX).
+     * @return {boolean}
+     */
+    function _isServedLanguageActive() {
+        const editor = EditorManager.getActiveEditor();
+        return !!(editor && SUPPORTED_LANGUAGES.indexOf(editor.getLanguageForSelection().getId()) !== -1);
+    }
+
+    let starting = false;
+    let pendingRepoint = false;     // a project switch happened; repoint once a served file is active there
+    let initErrorReported = false;  // start() is retried lazily, so report a failure to telemetry only once
+
+    /**
+     * Lazily start the language server when a served-language file is active, and - only right after a
+     * project switch - repoint the running server at the new root. Mirrors VS Code's onLanguage model:
+     * a project with no JS/TS file opened never spawns vtsls; switching to a non-JS project leaves the
+     * idle server where it was; and plain file switches within a project never touch the
+     * workspace-folder / restart machinery (so they can't interfere with a crash auto-restart).
+     */
+    function _ensureServerForActiveEditor() {
+        if (!canRun() || !_isServedLanguageActive()) {
+            return;
+        }
+
+        // Not running yet: lazily start it (a fresh start already points at the current project root).
+        if (!registered) {
+            if (starting) {
+                return; // a start kicked off by a previous activeEditorChange is still in flight
+            }
+            starting = true;
+            pendingRepoint = false;
+            start().catch(function (err) {
+                if (!initErrorReported) {
+                    initErrorReported = true;
+                    window.logger && window.logger.reportError(err, "[TypeScriptSupport] LSP init failed");
+                }
+            }).finally(function () {
+                starting = false;
+            });
+            return;
+        }
+
+        // Running: repoint at the current project, but only when a project switch armed it - never on
+        // ordinary file switches.
+        if (pendingRepoint) {
+            pendingRepoint = false;
+            loadLSPClient().then(function (LSPClient) {
+                LSPClient.changeWorkspaceRoot(SERVER_ID);
+            });
+        }
+    }
+
     AppInit.appReady(function () {
         if (!canRun()) {
             return;
         }
         _refreshCheckJs();
-        start().catch(function (err) {
-            console.error("[TypeScriptSupport] init failed", err && (err.message || err));
-        }).finally(function () {
-            // Signal for integration tests that the server start has been attempted/settled.
-            window._TypeScriptSupportReadyToIntegTest = true;
-        });
 
         // Offer project-wide code intelligence (creates a default ts/jsconfig) when a JS/TS file is
         // opened in a project that has no config yet. Projects that already carry one are silent.
@@ -283,17 +331,20 @@ define(function (require, exports, module) {
             }
         });
 
-        // Re-point the server at the new workspace root when the project changes, and re-evaluate
-        // whether the new project type-checks its JS. This uses workspace/didChangeWorkspaceFolders
-        // (no process restart, so no tsserver cold start) and only falls back to a full restart for
-        // servers that don't support live workspace-folder changes.
+        // Lazily start / repoint the server from the active editor's language (VS Code's onLanguage
+        // model). Evaluate the editor already open at startup (session restore), then track switches.
+        EditorManager.on("activeEditorChange", _ensureServerForActiveEditor);
+        _ensureServerForActiveEditor();
+
+        // On project switch: re-evaluate checkJs and arm a one-shot repoint. The actual repoint
+        // (workspace/didChangeWorkspaceFolders, no restart) happens the next time a served-language
+        // file is active - here if one already is, otherwise on the activeEditorChange as the new
+        // project's file opens. Plain file switches within a project never set this, so they don't
+        // repoint.
         ProjectManager.on(ProjectManager.EVENT_PROJECT_OPEN, function () {
             _refreshCheckJs();
-            if (registered) {
-                loadLSPClient().then(function (LSPClient) {
-                    LSPClient.changeWorkspaceRoot(SERVER_ID);
-                });
-            }
+            pendingRepoint = true;
+            _ensureServerForActiveEditor();
         });
 
         // Pick up a tsconfig/jsconfig being added, edited, or removed at the project root.

src/extensions/default/TypeScriptSupport/unittests.js

@@ -55,10 +55,10 @@ define(function (require, exports, module) {
             CodeInspection = testWindow.brackets.test.CodeInspection;
             QuickViewManager = testWindow.brackets.getModule("features/QuickViewManager");
             CodeInspection.toggleEnabled(true);
-            // Wait until the extension has attempted to start the language server.
-            await awaitsFor(function () {
-                return testWindow._TypeScriptSupportReadyToIntegTest;
-            }, "TypeScript LSP server to start", 30000);
+            // createTestWindowAndRun already waited for the app (and so the extension's appReady, which
+            // wires the lazy-start hooks) to finish loading. The server itself starts lazily on the
+            // first served-language file - the warm-up below opens a .ts, which starts it; waiting for
+            // its diagnostics ("not assignable") is the real readiness signal.
 
             // Warm up tsserver. Its very first request pays a large one-time cost - spawning node,
             // launching vtsls, and loading the TypeScript library + project - which on a slow/loaded

src/languageTools/LSPClient.js

@@ -742,6 +742,16 @@ define(function (require, exports, module) {
         if (!client) {
             return;
         }
+        // Resolve the target root FIRST: a redundant call for the same root must be a cheap no-op and
+        // must never restart (this can be called often - e.g. once per editor switch). This check has
+        // to precede the restart fallbacks below, or a same-root call to a server that lacks live
+        // workspace-folder support would pointlessly recycle the process.
+        const newVfsPath = (client.config.rootUriProvider && client.config.rootUriProvider()) || _projectRootPath();
+        const newUri = newVfsPath ? pathToServerUri(newVfsPath) : null;
+        const oldUri = client.rootUri || null;
+        if (newUri === oldUri) {
+            return; // same workspace - nothing to do
+        }
         // Not up yet (e.g. the project switched before init finished) - a (re)start picks up the
         // current root on its own.
         if (!client.capabilities) {
@@ -754,12 +764,6 @@ define(function (require, exports, module) {
         if (!supportsLiveChange) {
             return restartLanguageServer(serverId);
         }
-        const newVfsPath = (client.config.rootUriProvider && client.config.rootUriProvider()) || _projectRootPath();
-        const newUri = newVfsPath ? pathToServerUri(newVfsPath) : null;
-        const oldUri = client.rootUri || null;
-        if (newUri === oldUri) {
-            return; // same workspace - nothing to do
-        }
         const conn = await getConnector();
         const added = newUri ? [{ uri: newUri, name: FileUtils.getBaseName(newVfsPath) }] : [];
         const removed = oldUri ? [{ uri: oldUri, name: client.rootName || FileUtils.getBaseName(oldUri) }] : [];