internal: remove UnindexedProject notification

davidbarsky · davidbarsky · commit 7eff6416908d · 2024-07-23T09:29:19.000-04:00
Summary:

Test Plan:

Reviewers:

Subscribers:

Tasks:

Tags:
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
@@ -679,9 +679,6 @@ config_data! {
         /// Whether to show `can't find Cargo.toml` error message.
         notifications_cargoTomlNotFound: bool      = true,
 
-        /// Whether to send an UnindexedProject notification to the client.
-        notifications_unindexedProject: bool      = false,
-
         /// How many worker threads in the main loop. The default `null` means to pick automatically.
         numThreads: Option<NumThreads> = None,
 
@@ -1215,7 +1212,6 @@ pub enum FilesWatcher {
 #[derive(Debug, Clone)]
 pub struct NotificationsConfig {
     pub cargo_toml_not_found: bool,
-    pub unindexed_project: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -1776,7 +1772,6 @@ impl Config {
     pub fn notifications(&self) -> NotificationsConfig {
         NotificationsConfig {
             cargo_toml_not_found: self.notifications_cargoTomlNotFound().to_owned(),
-            unindexed_project: self.notifications_unindexedProject().to_owned(),
         }
     }
 
diff --git a/crates/rust-analyzer/src/handlers/notification.rs b/crates/rust-analyzer/src/handlers/notification.rs
@@ -73,9 +73,7 @@ pub(crate) fn handle_did_open_text_document(
 
         tracing::info!("New file content set {:?}", params.text_document.text);
         state.vfs.write().0.set_file_contents(path, Some(params.text_document.text.into_bytes()));
-        if state.config.discover_workspace_config().is_some()
-            || state.config.notifications().unindexed_project
-        {
+        if state.config.discover_workspace_config().is_some() {
             tracing::debug!("queuing task");
             let _ = state
                 .deferred_task_queue
diff --git a/crates/rust-analyzer/src/lsp/ext.rs b/crates/rust-analyzer/src/lsp/ext.rs
@@ -834,16 +834,3 @@ pub struct CompletionImport {
 pub struct ClientCommandOptions {
     pub commands: Vec<String>,
 }
-
-pub enum UnindexedProject {}
-
-impl Notification for UnindexedProject {
-    type Params = UnindexedProjectParams;
-    const METHOD: &'static str = "rust-analyzer/unindexedProject";
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct UnindexedProjectParams {
-    pub text_documents: Vec<TextDocumentIdentifier>,
-}
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
@@ -90,7 +90,6 @@ pub(crate) enum QueuedTask {
 pub(crate) enum Task {
     Response(lsp_server::Response),
     DiscoverLinkedProjects(DiscoverProjectParam),
-    ClientNotification(lsp_ext::UnindexedProjectParams),
     Retry(lsp_server::Request),
     Diagnostics(DiagnosticsGeneration, Vec<(FileId, Vec<lsp_types::Diagnostic>)>),
     DiscoverTest(lsp_ext::DiscoverTestResults),
@@ -642,9 +641,6 @@ impl GlobalState {
     fn handle_task(&mut self, prime_caches_progress: &mut Vec<PrimeCachesProgress>, task: Task) {
         match task {
             Task::Response(response) => self.respond(response),
-            Task::ClientNotification(params) => {
-                self.send_notification::<lsp_ext::UnindexedProject>(params)
-            }
             // Only retry requests that haven't been cancelled. Otherwise we do unnecessary work.
             Task::Retry(req) if !self.is_completed(&req) => self.on_request(req),
             Task::Retry(_) => (),
@@ -825,12 +821,7 @@ impl GlobalState {
                                     from_proto::abs_path(&uri).expect("Unable to get AbsPath");
                                 let arg = DiscoverProjectParam::Path(path);
                                 sender.send(Task::DiscoverLinkedProjects(arg)).unwrap();
-                            } else if snap.config.notifications().unindexed_project {
-                                let params = lsp_ext::UnindexedProjectParams {
-                                    text_documents: vec![lsp_types::TextDocumentIdentifier { uri }],
-                                };
-                                sender.send(Task::ClientNotification(params)).unwrap();
-                            };
+                            }
                         } else {
                             tracing::debug!(?uri, "is indexed");
                         }
diff --git a/crates/rust-analyzer/tests/slow-tests/main.rs b/crates/rust-analyzer/tests/slow-tests/main.rs
@@ -27,7 +27,7 @@ use lsp_types::{
     InlayHint, InlayHintLabel, InlayHintParams, PartialResultParams, Position, Range,
     RenameFilesParams, TextDocumentItem, TextDocumentPositionParams, WorkDoneProgressParams,
 };
-use rust_analyzer::lsp::ext::{OnEnter, Runnables, RunnablesParams, UnindexedProject};
+use rust_analyzer::lsp::ext::{OnEnter, Runnables, RunnablesParams};
 use serde_json::json;
 use stdx::format_to_acc;
 
@@ -811,66 +811,6 @@ fn main() {{}}
     );
 }
 
-#[test]
-fn test_opening_a_file_outside_of_indexed_workspace() {
-    if skip_slow_tests() {
-        return;
-    }
-
-    let tmp_dir = TestDir::new();
-    let path = tmp_dir.path();
-
-    let project = json!({
-        "roots": [path],
-        "crates": [ {
-            "root_module": path.join("src/crate_one/lib.rs"),
-            "deps": [],
-            "edition": "2015",
-            "cfg": [ "cfg_atom_1", "feature=\"cfg_1\""],
-        } ]
-    });
-
-    let code = format!(
-        r#"
-//- /rust-project.json
-{project}
-
-//- /src/crate_one/lib.rs
-mod bar;
-
-fn main() {{}}
-"#,
-    );
-
-    let server = Project::with_fixture(&code)
-        .tmp_dir(tmp_dir)
-        .with_config(serde_json::json!({
-            "notifications": {
-                "unindexedProject": true
-            },
-        }))
-        .server()
-        .wait_until_workspace_is_loaded();
-
-    let uri = server.doc_id("src/crate_two/lib.rs").uri;
-    server.notification::<DidOpenTextDocument>(DidOpenTextDocumentParams {
-        text_document: TextDocumentItem {
-            uri: uri.clone(),
-            language_id: "rust".to_owned(),
-            version: 0,
-            text: "/// Docs\nfn foo() {}".to_owned(),
-        },
-    });
-    let expected = json!({
-        "textDocuments": [
-            {
-                "uri": uri
-            }
-        ]
-    });
-    server.expect_notification::<UnindexedProject>(expected);
-}
-
 #[test]
 fn diagnostics_dont_block_typing() {
     if skip_slow_tests() {
diff --git a/crates/rust-analyzer/tests/slow-tests/support.rs b/crates/rust-analyzer/tests/slow-tests/support.rs
@@ -256,40 +256,6 @@ impl Server {
         self.send_notification(r)
     }
 
-    pub(crate) fn expect_notification<N>(&self, expected: Value)
-    where
-        N: lsp_types::notification::Notification,
-        N::Params: Serialize,
-    {
-        while let Some(Message::Notification(actual)) =
-            recv_timeout(&self.client.receiver).unwrap_or_else(|_| panic!("timed out"))
-        {
-            if actual.method == N::METHOD {
-                let actual = actual
-                    .clone()
-                    .extract::<Value>(N::METHOD)
-                    .expect("was not able to extract notification");
-
-                tracing::debug!(?actual, "got notification");
-                if let Some((expected_part, actual_part)) = find_mismatch(&expected, &actual) {
-                    panic!(
-                            "JSON mismatch\nExpected:\n{}\nWas:\n{}\nExpected part:\n{}\nActual part:\n{}\n",
-                            to_string_pretty(&expected).unwrap(),
-                            to_string_pretty(&actual).unwrap(),
-                            to_string_pretty(expected_part).unwrap(),
-                            to_string_pretty(actual_part).unwrap(),
-                        );
-                } else {
-                    tracing::debug!("successfully matched notification");
-                    return;
-                }
-            } else {
-                continue;
-            }
-        }
-        panic!("never got expected notification");
-    }
-
     #[track_caller]
     pub(crate) fn request<R>(&self, params: R::Params, expected_resp: Value)
     where
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
@@ -616,25 +616,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
@@ -830,11 +830,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
@@ -2267,16 +2267,6 @@
                     }
                 }
             },
-            {
-                "title": "notifications",
-                "properties": {
-                    "rust-analyzer.notifications.unindexedProject": {
-                        "markdownDescription": "Whether to send an UnindexedProject notification to the client.",
-                        "default": false,
-                        "type": "boolean"
-                    }
-                }
-            },
             {
                 "title": "general",
                 "properties": {
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
@@ -42,16 +42,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
@@ -2,9 +2,8 @@ import * as Is from "vscode-languageclient/lib/common/utils/is";
 import * as os from "os";
 import * as path from "path";
 import * as vscode from "vscode";
-import { type Env, log, unwrapUndefinable, expectNotUndefined } from "./util";
-import type { JsonProject } from "./rust_project";
-import type { Disposable } from "./ctx";
+import { Env, expectNotUndefined, log, unwrapUndefinable } from "./util";
+import { Disposable } from "vscode";
 
 export type RunnableEnvCfgItem = {
     mask?: string;
@@ -31,7 +30,6 @@ export class Config {
     );
 
     constructor(disposables: Disposable[]) {
-        this.discoveredWorkspaces = [];
         vscode.workspace.onDidChangeConfiguration(this.onDidChangeConfiguration, this, disposables);
         this.refreshLogging();
         this.configureLanguage();
@@ -52,8 +50,6 @@ export class Config {
         log.info("Using configuration", Object.fromEntries(cfg));
     }
 
-    public discoveredWorkspaces: JsonProject[];
-
     private async onDidChangeConfiguration(event: vscode.ConfigurationChangeEvent) {
         this.refreshLogging();
 
@@ -342,18 +338,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)) {
@@ -365,9 +350,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
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
diff --git a/editors/code/src/rust_project.ts b/editors/code/src/rust_project.ts

Original file line number	Diff line number	Diff line change
`@@ -2267,16 +2267,6 @@`
`2267`	`2267`	`}`
`2268`	`2268`	`}`
`2269`	`2269`	`},`
`2270`		`- {`
`2271`		`- "title": "notifications",`
`2272`		`- "properties": {`
`2273`		`- "rust-analyzer.notifications.unindexedProject": {`
`2274`		`- "markdownDescription": "Whether to send an UnindexedProject notification to the client.",`
`2275`		`- "default": false,`
`2276`		`- "type": "boolean"`
`2277`		`- }`
`2278`		`- }`
`2279`		`- },`
`2280`	`2270`	`{`
`2281`	`2271`	`"title": "general",`
`2282`	`2272`	`"properties": {`