chore: remove companion extension hooks

davidbarsky · davidbarsky · commit 354923c0d8a2 · 2024-05-29T13:16:21.000-07:00
***
vscode: remove companion extension hooks
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
@@ -3044,7 +3044,7 @@ fn doc_comment_to_string(doc: &[&str]) -> String {
 
 #[cfg(test)]
 mod tests {
-    use std::{env::temp_dir, fs};
+    use std::fs;
 
     use test_utils::{ensure_file_contents, project_root};
 
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
@@ -581,25 +581,6 @@ Reloads project information (that is, re-executes `cargo metadata`).
 
 Rebuilds build scripts and proc-macros, and runs the build scripts to reseed the build data.
 
-## Unindexed Project
-
-**Experimental Client Capability:** `{ "unindexedProject": boolean }`
-
-**Method:** `rust-analyzer/unindexedProject`
-
-**Notification:**
-
-```typescript
-interface UnindexedProjectParams {
-    /// A list of documents that rust-analyzer has determined are not indexed.
-    textDocuments: lc.TextDocumentIdentifier[]
-}
-```
-
-This notification is sent from the server to the client. The client is expected
-to determine the appropriate owners of `textDocuments` and update `linkedProjects`
-if an owner can be determined successfully.
-
 ## Server Status
 
 **Experimental Client Capability:** `{ "serverStatusNotification": boolean }`
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
@@ -819,11 +819,6 @@ Sets the LRU capacity of the specified queries.
 --
 Whether to show `can't find Cargo.toml` error message.
 --
-[[rust-analyzer.notifications.unindexedProject]]rust-analyzer.notifications.unindexedProject (default: `false`)::
-+
---
-Whether to send an UnindexedProject notification to the client.
---
 [[rust-analyzer.numThreads]]rust-analyzer.numThreads (default: `null`)::
 +
 --
diff --git a/editors/code/package.json b/editors/code/package.json
@@ -487,14 +487,6 @@
                     "default": false,
                     "type": "boolean"
                 },
-                "rust-analyzer.discoverProjectRunner": {
-                    "markdownDescription": "Sets the extension responsible for determining which extension the rust-analyzer extension uses to generate `rust-project.json` files. This should should only be used\n if a build system like Buck or Bazel is also in use.",
-                    "default": null,
-                    "type": [
-                        "null",
-                        "string"
-                    ]
-                },
                 "rust-analyzer.showUnlinkedFileNotification": {
                     "markdownDescription": "Whether to show a notification for unlinked files asking the user to add the corresponding Cargo.toml to the linked projects setting.",
                     "default": true,
@@ -1556,11 +1548,6 @@
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.notifications.unindexedProject": {
-                    "markdownDescription": "Whether to send an UnindexedProject notification to the client.",
-                    "default": false,
-                    "type": "boolean"
-                },
                 "rust-analyzer.numThreads": {
                     "markdownDescription": "How many worker threads in the main loop. The default `null` means to pick automatically.",
                     "default": null,
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
@@ -102,16 +102,7 @@ export async function createClient(
                     const resp = await next(params, token);
                     if (resp && Array.isArray(resp)) {
                         return resp.map((val) => {
-                            return prepareVSCodeConfig(val, (key, cfg) => {
-                                // we only want to set discovered workspaces on the right key
-                                // and if a workspace has been discovered.
-                                if (
-                                    key === "linkedProjects" &&
-                                    config.discoveredWorkspaces.length > 0
-                                ) {
-                                    cfg[key] = config.discoveredWorkspaces;
-                                }
-                            });
+                            return prepareVSCodeConfig(val);
                         });
                     } else {
                         return resp;
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
@@ -5,7 +5,6 @@ import * as vscode from "vscode";
 import type { Env } from "./client";
 import { log } from "./util";
 import { expectNotUndefined, unwrapUndefinable } from "./undefinable";
-import type { JsonProject } from "./rust_project";
 
 export type RunnableEnvCfgItem = {
     mask?: string;
@@ -41,7 +40,6 @@ export class Config {
 
     constructor(ctx: vscode.ExtensionContext) {
         this.globalStorageUri = ctx.globalStorageUri;
-        this.discoveredWorkspaces = [];
         vscode.workspace.onDidChangeConfiguration(
             this.onDidChangeConfiguration,
             this,
@@ -63,8 +61,6 @@ export class Config {
         log.info("Using configuration", Object.fromEntries(cfg));
     }
 
-    public discoveredWorkspaces: JsonProject[];
-
     private async onDidChangeConfiguration(event: vscode.ConfigurationChangeEvent) {
         this.refreshLogging();
 
@@ -357,18 +353,7 @@ export class Config {
     }
 }
 
-// the optional `cb?` parameter is meant to be used to add additional
-// key/value pairs to the VS Code configuration. This needed for, e.g.,
-// including a `rust-project.json` into the `linkedProjects` key as part
-// of the configuration/InitializationParams _without_ causing VS Code
-// configuration to be written out to workspace-level settings. This is
-// undesirable behavior because rust-project.json files can be tens of
-// thousands of lines of JSON, most of which is not meant for humans
-// to interact with.
-export function prepareVSCodeConfig<T>(
-    resp: T,
-    cb?: (key: Extract<keyof T, string>, res: { [key: string]: any }) => void,
-): T {
+export function prepareVSCodeConfig<T>(resp: T): T {
     if (Is.string(resp)) {
         return substituteVSCodeVariableInString(resp) as T;
     } else if (resp && Is.array<any>(resp)) {
@@ -380,9 +365,6 @@ export function prepareVSCodeConfig<T>(
         for (const key in resp) {
             const val = resp[key];
             res[key] = prepareVSCodeConfig(val);
-            if (cb) {
-                cb(key, res);
-            }
         }
         return res as T;
     }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
@@ -1,5 +1,5 @@
 import * as vscode from "vscode";
-import * as lc from "vscode-languageclient/node";
+import type * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 
 import { Config, prepareVSCodeConfig } from "./config";
@@ -22,8 +22,6 @@ import {
 import { execRevealDependency } from "./commands";
 import { PersistentState } from "./persistent_state";
 import { bootstrap } from "./bootstrap";
-import type { RustAnalyzerExtensionApi } from "./main";
-import type { JsonProject } from "./rust_project";
 import { prepareTestExplorer } from "./test_explorer";
 
 // We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
@@ -67,9 +65,9 @@ export type CtxInit = Ctx & {
     readonly client: lc.LanguageClient;
 };
 
-export class Ctx implements RustAnalyzerExtensionApi {
+export class Ctx {
     readonly statusBar: vscode.StatusBarItem;
-    config: Config;
+    readonly config: Config;
     readonly workspace: Workspace;
 
     private _client: lc.LanguageClient | undefined;
@@ -197,15 +195,6 @@ export class Ctx implements RustAnalyzerExtensionApi {
             };
 
             let rawInitializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
-            if (this.config.discoverProjectRunner) {
-                const command = `${this.config.discoverProjectRunner}.discoverWorkspaceCommand`;
-                log.info(`running command: ${command}`);
-                const uris = vscode.workspace.textDocuments
-                    .filter(isRustDocument)
-                    .map((document) => document.uri);
-                const projects: JsonProject[] = await vscode.commands.executeCommand(command, uris);
-                this.setWorkspaces(projects);
-            }
 
             if (this.workspace.kind === "Detached Files") {
                 rawInitializationOptions = {
@@ -214,16 +203,7 @@ export class Ctx implements RustAnalyzerExtensionApi {
                 };
             }
 
-            const initializationOptions = prepareVSCodeConfig(
-                rawInitializationOptions,
-                (key, obj) => {
-                    // we only want to set discovered workspaces on the right key
-                    // and if a workspace has been discovered.
-                    if (key === "linkedProjects" && this.config.discoveredWorkspaces.length > 0) {
-                        obj["linkedProjects"] = this.config.discoveredWorkspaces;
-                    }
-                },
-            );
+            const initializationOptions = prepareVSCodeConfig(rawInitializationOptions);
 
             this._client = await createClient(
                 this.traceOutputChannel,
@@ -243,23 +223,6 @@ export class Ctx implements RustAnalyzerExtensionApi {
                     this.outputChannel!.show();
                 }),
             );
-            this.pushClientCleanup(
-                this._client.onNotification(ra.unindexedProject, async (params) => {
-                    if (this.config.discoverProjectRunner) {
-                        const command = `${this.config.discoverProjectRunner}.discoverWorkspaceCommand`;
-                        log.info(`running command: ${command}`);
-                        const uris = params.textDocuments.map((doc) =>
-                            vscode.Uri.parse(doc.uri, true),
-                        );
-                        const projects: JsonProject[] = await vscode.commands.executeCommand(
-                            command,
-                            uris,
-                        );
-                        this.setWorkspaces(projects);
-                        await this.notifyRustAnalyzer();
-                    }
-                }),
-            );
         }
         return this._client;
     }
@@ -376,19 +339,6 @@ export class Ctx implements RustAnalyzerExtensionApi {
         return this._serverPath;
     }
 
-    setWorkspaces(workspaces: JsonProject[]) {
-        this.config.discoveredWorkspaces = workspaces;
-    }
-
-    async notifyRustAnalyzer(): Promise<void> {
-        // this is a workaround to avoid needing writing the `rust-project.json` into
-        // a workspace-level VS Code-specific settings folder. We'd like to keep the
-        // `rust-project.json` entirely in-memory.
-        await this.client?.sendNotification(lc.DidChangeConfigurationNotification.type, {
-            settings: "",
-        });
-    }
-
     private updateCommands(forceDisable?: "disable") {
         this.commandDisposables.forEach((disposable) => disposable.dispose());
         this.commandDisposables = [];
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
@@ -264,9 +264,3 @@ export type RecursiveMemoryLayoutNode = {
 export type RecursiveMemoryLayout = {
     nodes: RecursiveMemoryLayoutNode[];
 };
-
-export const unindexedProject = new lc.NotificationType<UnindexedProjectParams>(
-    "rust-analyzer/unindexedProject",
-);
-
-export type UnindexedProjectParams = { textDocuments: lc.TextDocumentIdentifier[] };
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
@@ -6,25 +6,14 @@ import { type CommandFactory, Ctx, fetchWorkspace } from "./ctx";
 import * as diagnostics from "./diagnostics";
 import { activateTaskProvider } from "./tasks";
 import { setContextValue } from "./util";
-import type { JsonProject } from "./rust_project";
 
 const RUST_PROJECT_CONTEXT_NAME = "inRustProject";
 
-// This API is not stable and may break in between minor releases.
-export interface RustAnalyzerExtensionApi {
-    readonly client?: lc.LanguageClient;
-
-    setWorkspaces(workspaces: JsonProject[]): void;
-    notifyRustAnalyzer(): Promise<void>;
-}
-
 export async function deactivate() {
     await setContextValue(RUST_PROJECT_CONTEXT_NAME, undefined);
 }
 
-export async function activate(
-    context: vscode.ExtensionContext,
-): Promise<RustAnalyzerExtensionApi> {
+export async function activate(context: vscode.ExtensionContext): Promise<Ctx> {
     checkConflictingExtensions();
 
     const ctx = new Ctx(context, createCommands(), fetchWorkspace());
@@ -40,7 +29,7 @@ export async function activate(
     return api;
 }
 
-async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
+async function activateServer(ctx: Ctx): Promise<Ctx> {
     if (ctx.workspace.kind === "Workspace Folder") {
         ctx.pushExtCleanup(activateTaskProvider(ctx.config));
     }
diff --git a/editors/code/src/rust_project.ts b/editors/code/src/rust_project.ts
