perf(lsp): switch projects via didChangeWorkspaceFolders instead of restart

Restarting the language server on every project switch re-paid tsserver's
cold start (spawning node + loading the TypeScript library) each time. When
the server advertises workspace.workspaceFolders.changeNotifications, re-point
it live with workspace/didChangeWorkspaceFolders (remove old root, add new)
instead - no process restart, no cold start. Generic in LSPClient: servers
without the capability transparently fall back to a full restart, and restart
remains the recovery path for crashes / server-version changes.

Verified: A->B project switch ~160ms with cross-file Find Usages working in
both projects and no vtsls respawn in the logs.

Author: abose

src/extensions/default/TypeScriptSupport/main.js

@@ -283,13 +283,15 @@ define(function (require, exports, module) {
             }
         });
 
-        // Restart the server against the new workspace root when the project changes, and
-        // re-evaluate whether the new project type-checks its JS.
+        // 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.
         ProjectManager.on(ProjectManager.EVENT_PROJECT_OPEN, function () {
             _refreshCheckJs();
             if (registered) {
                 loadLSPClient().then(function (LSPClient) {
-                    LSPClient.restartLanguageServer(SERVER_ID);
+                    LSPClient.changeWorkspaceRoot(SERVER_ID);
                 });
             }
         });

src/languageTools/LSPClient.js

@@ -539,6 +539,11 @@ define(function (require, exports, module) {
         const rootVfsPath = (config.rootUriProvider && config.rootUriProvider()) || _projectRootPath();
         const rootUri = rootVfsPath ? pathToServerUri(rootVfsPath) : null;
         const rootName = rootVfsPath ? FileUtils.getBaseName(rootVfsPath) : "root";
+        // Remember the active workspace folder so a later project switch can hand the server the
+        // delta (removed old, added new) via workspace/didChangeWorkspaceFolders - see
+        // changeWorkspaceRoot - instead of a full restart.
+        client.rootUri = rootUri;
+        client.rootName = rootName;
 
         await conn.execPeer("startServer", {
             serverId: client.serverId,
@@ -674,6 +679,53 @@ define(function (require, exports, module) {
         });
     }
 
+    /**
+     * Re-point a running server at the current project root WITHOUT restarting it, by sending
+     * `workspace/didChangeWorkspaceFolders` (remove the old folder, add the new one). This avoids
+     * the cold start a full restart pays on every project switch. Generic: servers that don't
+     * advertise live workspace-folder change support transparently fall back to a full restart.
+     * The open documents themselves are re-synced by DocumentSync's normal editor-change handling.
+     * @param {string} serverId
+     * @return {Promise<void>}
+     */
+    async function changeWorkspaceRoot(serverId) {
+        const client = clients.get(serverId);
+        if (!client) {
+            return;
+        }
+        // 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) {
+            return restartLanguageServer(serverId);
+        }
+        const wf = client.capabilities.workspace && client.capabilities.workspace.workspaceFolders;
+        // Per the LSP spec changeNotifications is `boolean | string` (a static flag or a dynamic
+        // registration id); either truthy form means the server accepts live folder changes.
+        const supportsLiveChange = !!(wf && wf.supported && wf.changeNotifications);
+        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) }] : [];
+        await conn.execPeer("sendNotification", {
+            serverId: serverId,
+            method: "workspace/didChangeWorkspaceFolders",
+            params: { event: { added: added, removed: removed } }
+        });
+        client.rootUri = newUri;
+        client.rootName = newVfsPath ? FileUtils.getBaseName(newVfsPath) : null;
+        // Capabilities are unchanged (no restart), but the active file is now in the new project -
+        // refresh the find-references menu state for that context.
+        FindReferencesManager.setMenuItemStateForLanguage();
+    }
+
     async function restartLanguageServer(serverId) {
         const client = clients.get(serverId);
         if (!client) {
@@ -723,6 +775,7 @@ define(function (require, exports, module) {
 
     exports.registerLanguageServer = registerLanguageServer;
     exports.restartLanguageServer = restartLanguageServer;
+    exports.changeWorkspaceRoot = changeWorkspaceRoot;
     exports.pathToServerUri = pathToServerUri;
     exports.serverUriToVfsUri = serverUriToVfsUri;
 });