Notify sourcekit-lsp of active document changes (#1404)

plemarquand · ahoppen · web-flow · commit 767fb08df7b9 · 2025-03-17T15:29:34.000-04:00
`sourcekit-lsp` recently added an LSP extension method to notify the server of the active documnent, so it doesn't need to infer it from information in other requests. This capability was added in swiftlang/sourcekit-lsp#1989. Co-authored-by: Alex Hoppen <alex@alexhoppen.de>
diff --git a/src/TestExplorer/LSPTestDiscovery.ts b/src/TestExplorer/LSPTestDiscovery.ts
@@ -20,7 +20,10 @@ import {
     WorkspaceTestsRequest,
 } from "../sourcekit-lsp/extensions";
 import { SwiftPackage, TargetType } from "../SwiftPackage";
-import { LanguageClientManager } from "../sourcekit-lsp/LanguageClientManager";
+import {
+    checkExperimentalCapability,
+    LanguageClientManager,
+} from "../sourcekit-lsp/LanguageClientManager";
 import { LanguageClient } from "vscode-languageclient/node";
 
 /**
@@ -45,7 +48,7 @@ export class LSPTestDiscovery {
         return await this.languageClient.useLanguageClient(async (client, token) => {
             // Only use the lsp for this request if it supports the
             // textDocument/tests method, and is at least version 2.
-            if (this.checkExperimentalCapability(client, TextDocumentTestsRequest.method, 2)) {
+            if (checkExperimentalCapability(client, TextDocumentTestsRequest.method, 2)) {
                 const testsInDocument = await client.sendRequest(
                     TextDocumentTestsRequest.type,
                     { textDocument: { uri: document.toString() } },
@@ -66,7 +69,7 @@ export class LSPTestDiscovery {
         return await this.languageClient.useLanguageClient(async (client, token) => {
             // Only use the lsp for this request if it supports the
             // workspace/tests method, and is at least version 2.
-            if (this.checkExperimentalCapability(client, WorkspaceTestsRequest.method, 2)) {
+            if (checkExperimentalCapability(client, WorkspaceTestsRequest.method, 2)) {
                 const tests = await client.sendRequest(WorkspaceTestsRequest.type, token);
                 return this.transformToTestClass(client, swiftPackage, tests);
             } else {
@@ -75,23 +78,6 @@ export class LSPTestDiscovery {
         });
     }
 
-    /**
-     * Returns `true` if the LSP supports the supplied `method` at or
-     * above the supplied `minVersion`.
-     */
-    private checkExperimentalCapability(
-        client: LanguageClient,
-        method: string,
-        minVersion: number
-    ) {
-        const experimentalCapability = client.initializeResult?.capabilities.experimental;
-        if (!experimentalCapability) {
-            throw new Error(`${method} requests not supported`);
-        }
-        const targetCapability = experimentalCapability[method];
-        return (targetCapability?.version ?? -1) >= minVersion;
-    }
-
     /**
      * Convert from `LSPTestItem[]` to `TestDiscovery.TestClass[]`,
      * updating the format of the location.
diff --git a/src/sourcekit-lsp/LanguageClientManager.ts b/src/sourcekit-lsp/LanguageClientManager.ts
@@ -47,6 +47,8 @@ import { activateGetReferenceDocument } from "./getReferenceDocument";
 import { uriConverters } from "./uriConverters";
 import { LanguageClientFactory } from "./LanguageClientFactory";
 import { SourceKitLogMessageNotification, SourceKitLogMessageParams } from "./extensions";
+import { LSPActiveDocumentManager } from "./didChangeActiveDocument";
+import { DidChangeActiveDocumentNotification } from "./extensions/DidChangeActiveDocumentRequest";
 
 /**
  * Manages the creation and destruction of Language clients as we move between
@@ -136,6 +138,7 @@ export class LanguageClientManager implements vscode.Disposable {
     private legacyInlayHints?: vscode.Disposable;
     private peekDocuments?: vscode.Disposable;
     private getReferenceDocument?: vscode.Disposable;
+    private didChangeActiveDocument?: vscode.Disposable;
     private restartedPromise?: Promise<void>;
     private currentWorkspaceFolder?: vscode.Uri;
     private waitingOnRestartCount: number;
@@ -151,6 +154,7 @@ export class LanguageClientManager implements vscode.Disposable {
     public subFolderWorkspaces: vscode.Uri[];
     private namedOutputChannels: Map<string, LSPOutputChannel> = new Map();
     private swiftVersion: Version;
+    private activeDocumentManager = new LSPActiveDocumentManager();
 
     /** Get the current state of the underlying LanguageClient */
     public get state(): State {
@@ -534,6 +538,8 @@ export class LanguageClientManager implements vscode.Disposable {
             workspaceFolder: workspaceFolder,
             outputChannel: new SwiftOutputChannel("SourceKit Language Server"),
             middleware: {
+                didOpen: this.activeDocumentManager.didOpen.bind(this.activeDocumentManager),
+                didClose: this.activeDocumentManager.didClose.bind(this.activeDocumentManager),
                 provideCodeLenses: async (document, token, next) => {
                     const result = await next(document, token);
                     return result?.map(codelens => {
@@ -666,6 +672,13 @@ export class LanguageClientManager implements vscode.Disposable {
             };
         }
 
+        if (this.swiftVersion.isGreaterThanOrEqual(new Version(6, 1, 0))) {
+            options = {
+                ...options,
+                "window/didChangeActiveDocument": true, // the client can send `window/didChangeActiveDocument` notifications
+            };
+        }
+
         if (configuration.swiftSDK !== "") {
             options = {
                 ...options,
@@ -715,6 +728,21 @@ export class LanguageClientManager implements vscode.Disposable {
                 this.peekDocuments = activatePeekDocuments(client);
                 this.getReferenceDocument = activateGetReferenceDocument(client);
                 this.workspaceContext.subscriptions.push(this.getReferenceDocument);
+                try {
+                    if (
+                        checkExperimentalCapability(
+                            client,
+                            DidChangeActiveDocumentNotification.method,
+                            1
+                        )
+                    ) {
+                        this.didChangeActiveDocument =
+                            this.activeDocumentManager.activateDidChangeActiveDocument(client);
+                        this.workspaceContext.subscriptions.push(this.didChangeActiveDocument);
+                    }
+                } catch {
+                    // do nothing
+                }
             })
             .catch(reason => {
                 this.workspaceContext.outputChannel.log(`${reason}`);
@@ -846,3 +874,20 @@ type SourceKitDocumentSelector = {
     scheme: string;
     language: string;
 }[];
+
+/**
+ * Returns `true` if the LSP supports the supplied `method` at or
+ * above the supplied `minVersion`.
+ */
+export function checkExperimentalCapability(
+    client: LanguageClient,
+    method: string,
+    minVersion: number
+) {
+    const experimentalCapability = client.initializeResult?.capabilities.experimental;
+    if (!experimentalCapability) {
+        throw new Error(`${method} requests not supported`);
+    }
+    const targetCapability = experimentalCapability[method];
+    return (targetCapability?.version ?? -1) >= minVersion;
+}
diff --git a/src/sourcekit-lsp/didChangeActiveDocument.ts b/src/sourcekit-lsp/didChangeActiveDocument.ts
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the VS Code Swift open source project
+//
+// Copyright (c) 2025 the VS Code Swift project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of VS Code Swift project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import * as vscode from "vscode";
+import * as langclient from "vscode-languageclient/node";
+import { checkExperimentalCapability } from "./LanguageClientManager";
+import { DidChangeActiveDocumentNotification } from "./extensions/DidChangeActiveDocumentRequest";
+
+/**
+ * Monitors the active document and notifies the LSP whenever it changes.
+ * Only sends notifications for documents that produce `textDocument/didOpen`/`textDocument/didClose`
+ * requests to the client.
+ */
+export class LSPActiveDocumentManager {
+    private openDocuments = new Set<vscode.Uri>();
+    private lastActiveDocument: langclient.TextDocumentIdentifier | null = null;
+
+    // These are LSP middleware functions that listen for document open and close events.
+    public async didOpen(
+        document: vscode.TextDocument,
+        next: (data: vscode.TextDocument) => Promise<void>
+    ) {
+        this.openDocuments.add(document.uri);
+        next(document);
+    }
+
+    public async didClose(
+        document: vscode.TextDocument,
+        next: (data: vscode.TextDocument) => Promise<void>
+    ) {
+        this.openDocuments.add(document.uri);
+        next(document);
+    }
+
+    public activateDidChangeActiveDocument(client: langclient.LanguageClient): vscode.Disposable {
+        // Fire an inital notification on startup if there is an open document.
+        this.sendNotification(client, vscode.window.activeTextEditor?.document);
+
+        // Listen for the active editor to change and send a notification.
+        return vscode.window.onDidChangeActiveTextEditor(event => {
+            this.sendNotification(client, event?.document);
+        });
+    }
+
+    private sendNotification(
+        client: langclient.LanguageClient,
+        document: vscode.TextDocument | undefined
+    ) {
+        if (checkExperimentalCapability(client, DidChangeActiveDocumentNotification.method, 1)) {
+            const textDocument =
+                document && this.openDocuments.has(document.uri)
+                    ? client.code2ProtocolConverter.asTextDocumentIdentifier(document)
+                    : null;
+
+            // Avoid sending multiple identical notifications in a row.
+            if (textDocument !== this.lastActiveDocument) {
+                client.sendNotification(DidChangeActiveDocumentNotification.method, {
+                    textDocument: textDocument,
+                });
+            }
+            this.lastActiveDocument = textDocument;
+        }
+    }
+}
diff --git a/src/sourcekit-lsp/extensions/DidChangeActiveDocumentRequest.ts b/src/sourcekit-lsp/extensions/DidChangeActiveDocumentRequest.ts
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the VS Code Swift open source project
+//
+// Copyright (c) 2025 the VS Code Swift project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of VS Code Swift project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import { MessageDirection, NotificationType, TextDocumentIdentifier } from "vscode-languageclient";
+
+// We use namespaces to store request information just like vscode-languageclient
+/* eslint-disable @typescript-eslint/no-namespace */
+
+export interface DidChangeActiveDocumentParams {
+    /**
+     * The document that is being displayed in the active editor.
+     */
+    textDocument?: TextDocumentIdentifier;
+}
+
+/**
+ * Notify the server that the active document has changed.
+ */
+export namespace DidChangeActiveDocumentNotification {
+    export const method = "window/didChangeActiveDocument" as const;
+    export const messageDirection: MessageDirection = MessageDirection.clientToServer;
+    export const type = new NotificationType<DidChangeActiveDocumentParams>(method);
+}
diff --git a/test/unit-tests/sourcekit-lsp/LanguageClientManager.test.ts b/test/unit-tests/sourcekit-lsp/LanguageClientManager.test.ts
@@ -43,6 +43,11 @@ import { LanguageClientManager } from "../../../src/sourcekit-lsp/LanguageClient
 import configuration from "../../../src/configuration";
 import { FolderContext } from "../../../src/FolderContext";
 import { LanguageClientFactory } from "../../../src/sourcekit-lsp/LanguageClientFactory";
+import { LSPActiveDocumentManager } from "../../../src/sourcekit-lsp/didChangeActiveDocument";
+import {
+    DidChangeActiveDocumentNotification,
+    DidChangeActiveDocumentParams,
+} from "../../../src/sourcekit-lsp/extensions/DidChangeActiveDocumentRequest";
 
 suite("LanguageClientManager Suite", () => {
     let languageClientFactoryMock: MockedObject<LanguageClientFactory>;
@@ -112,6 +117,7 @@ suite("LanguageClientManager Suite", () => {
         });
         mockedConverter = mockObject<Code2ProtocolConverter>({
             asUri: mockFn(s => s.callsFake(uri => uri.fsPath)),
+            asTextDocumentIdentifier: mockFn(s => s.callsFake(doc => ({ uri: doc.uri.fsPath }))),
         });
         changeStateEmitter = new AsyncEventEmitter();
         languageClientMock = mockObject<LanguageClient>({
@@ -123,6 +129,15 @@ suite("LanguageClientManager Suite", () => {
                     dispose: mockFn(),
                 })
             ),
+            initializeResult: {
+                capabilities: {
+                    experimental: {
+                        "window/didChangeActiveDocument": {
+                            version: 1,
+                        },
+                    },
+                },
+            },
             start: mockFn(s =>
                 s.callsFake(async () => {
                     const oldState = languageClientMock.state;
@@ -422,6 +437,77 @@ suite("LanguageClientManager Suite", () => {
         ]);
     });
 
+    suite("active document changes", () => {
+        const mockWindow = mockGlobalObject(vscode, "window");
+
+        setup(() => {
+            mockedWorkspace.swiftVersion = new Version(6, 1, 0);
+        });
+
+        test("Notifies when the active document changes", async () => {
+            const document: vscode.TextDocument = instance(
+                mockObject<vscode.TextDocument>({
+                    uri: vscode.Uri.file("/folder1/file.swift"),
+                })
+            );
+
+            let _listener: ((e: vscode.TextEditor | undefined) => any) | undefined;
+            mockWindow.onDidChangeActiveTextEditor.callsFake((listener, _2, _1) => {
+                _listener = listener;
+                return { dispose: () => {} };
+            });
+
+            new LanguageClientManager(instance(mockedWorkspace), languageClientFactoryMock);
+            await waitForReturnedPromises(languageClientMock.start);
+
+            const activeDocumentManager = new LSPActiveDocumentManager();
+            activeDocumentManager.activateDidChangeActiveDocument(instance(languageClientMock));
+            activeDocumentManager.didOpen(document, async () => {});
+
+            if (_listener) {
+                _listener(instance(mockObject<vscode.TextEditor>({ document })));
+            }
+
+            expect(languageClientMock.sendNotification).to.have.been.calledOnceWith(
+                DidChangeActiveDocumentNotification.method,
+                {
+                    textDocument: {
+                        uri: "/folder1/file.swift",
+                    },
+                } as DidChangeActiveDocumentParams
+            );
+        });
+
+        test("Notifies on startup with the active document", async () => {
+            const document: vscode.TextDocument = instance(
+                mockObject<vscode.TextDocument>({
+                    uri: vscode.Uri.file("/folder1/file.swift"),
+                })
+            );
+            mockWindow.activeTextEditor = instance(
+                mockObject<vscode.TextEditor>({
+                    document,
+                })
+            );
+            new LanguageClientManager(instance(mockedWorkspace), languageClientFactoryMock);
+            await waitForReturnedPromises(languageClientMock.start);
+
+            const activeDocumentManager = new LSPActiveDocumentManager();
+            activeDocumentManager.didOpen(document, async () => {});
+
+            activeDocumentManager.activateDidChangeActiveDocument(instance(languageClientMock));
+
+            expect(languageClientMock.sendNotification).to.have.been.calledOnceWith(
+                DidChangeActiveDocumentNotification.method,
+                {
+                    textDocument: {
+                        uri: "/folder1/file.swift",
+                    },
+                } as DidChangeActiveDocumentParams
+            );
+        });
+    });
+
     suite("SourceKit-LSP version doesn't support workspace folders", () => {
         let folder1: MockedObject<FolderContext>;
         let folder2: MockedObject<FolderContext>;
