From b80bb583e43181bc4a4470a2c19481583edab10b Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 18 Dec 2024 00:57:38 +0200
Subject: Show substitution where hovering over generic things

There are few things to note in the implementation:

First, this is a best-effort implementation. Mainly, type aliases may not be shown (due to their eager nature it's harder) and partial pathes (aka. hovering over `Struct` in `Struct::method`) are not supported at all.

Second, we only need to show substitutions in expression and pattern position, because in type position all generic arguments always have to be written explicitly.
---
 src/tools/rust-analyzer/editors/code/package.json | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 469c1b458d5..b1daaff27a2 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -1530,6 +1530,29 @@
                     }
                 }
             },
+            {
+                "title": "hover",
+                "properties": {
+                    "rust-analyzer.hover.maxSubstitutionLength": {
+                        "markdownDescription": "Whether to show what types are used as generic arguments in calls etc. on hover, and what is their max length to show such types, beyond it they will be shown with ellipsis.\n\nThis can take three values: `null` means \"unlimited\", the string `\"hide\"` means to not show generic substitutions at all, and a number means to limit them to X characters.\n\nThe default is 20 characters.",
+                        "default": 20,
+                        "anyOf": [
+                            {
+                                "type": "null"
+                            },
+                            {
+                                "type": "string",
+                                "enum": [
+                                    "hide"
+                                ]
+                            },
+                            {
+                                "type": "integer"
+                            }
+                        ]
+                    }
+                }
+            },
             {
                 "title": "hover",
                 "properties": {
-- 
cgit 1.4.1-3-g733a5


From b35a8467b6da2178ceade881ab1b97f6a7bc12d0 Mon Sep 17 00:00:00 2001
From: Mark Murphy <mail@markmurphydev.com>
Date: Thu, 19 Dec 2024 16:41:35 -0500
Subject: change config rust-analyzer.statusBar.documentSelector to
 showStatusBar

---
 src/tools/rust-analyzer/editors/code/package.json  | 73 +++++++++++++---------
 src/tools/rust-analyzer/editors/code/src/config.ts | 11 +++-
 src/tools/rust-analyzer/editors/code/src/ctx.ts    | 13 ++--
 3 files changed, 62 insertions(+), 35 deletions(-)

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 469c1b458d5..bd1045f038f 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -426,40 +426,55 @@
                         "default": "openLogs",
                         "markdownDescription": "Action to run when clicking the extension status bar item."
                     },
-                    "rust-analyzer.statusBar.documentSelector": {
-                        "type": [
-                            "array",
-                            "null"
-                        ],
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "language": {
-                                    "type": [
-                                        "string",
-                                        "null"
-                                    ]
-                                },
-                                "pattern": {
-                                    "type": [
-                                        "string",
-                                        "null"
-                                    ]
-                                }
-                            }
-                        },
-                        "default": [
-                            {
-                                "language": "rust"
-                            },
+                    "rust-analyzer.statusBar.showStatusBar": {
+                        "markdownDescription": "When to show the extension status bar.\n\n`\"always\"` Always show the status bar.\n\n`\"never\"` Never show the status bar.\n\n`{ documentSelector: <DocumentSelector>[] }` Show the status bar if the open file matches any of the given document selectors.\n\nSee [VS Code -- DocumentSelector](https://code.visualstudio.com/api/references/document-selector) for more information.",
+                        "anyOf": [
                             {
-                                "pattern": "**/Cargo.toml"
+                                "type": "string",
+                                "enum": [
+                                    "always",
+                                    "never"
+                                ]
                             },
                             {
-                                "pattern": "**/Cargo.lock"
+                                "type": "object",
+                                "properties": {
+                                    "documentSelector": {
+                                        "type": "array",
+                                        "items": {
+                                            "type": "object",
+                                            "properties": {
+                                                "language": {
+                                                    "type": "string"
+                                                },
+                                                "notebookType": {
+                                                    "type": "string"
+                                                },
+                                                "scheme": {
+                                                    "type": "string"
+                                                },
+                                                "pattern": {
+                                                    "type": "string"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
                             }
                         ],
-                        "markdownDescription": "Determines when to show the extension status bar item based on the currently open file. Use `{ \"pattern\": \"**\" }` to always show. Use `null` to never show."
+                        "default": {
+                            "documentSelector": [
+                                {
+                                    "language": "rust"
+                                },
+                                {
+                                    "pattern": "**/Cargo.toml"
+                                },
+                                {
+                                    "pattern": "**/Cargo.lock"
+                                }
+                            ]
+                        }
                     }
                 }
             },
diff --git a/src/tools/rust-analyzer/editors/code/src/config.ts b/src/tools/rust-analyzer/editors/code/src/config.ts
index f7ef80df2ba..a97d4beab51 100644
--- a/src/tools/rust-analyzer/editors/code/src/config.ts
+++ b/src/tools/rust-analyzer/editors/code/src/config.ts
@@ -13,6 +13,13 @@ export type RunnableEnvCfgItem = {
 };
 export type RunnableEnvCfg = Record<string, string> | RunnableEnvCfgItem[];
 
+type ShowStatusBar =
+    | "always"
+    | "never"
+    | {
+          documentSelector: vscode.DocumentSelector;
+      };
+
 export class Config {
     readonly extensionId = "rust-lang.rust-analyzer";
     configureLang: vscode.Disposable | undefined;
@@ -348,8 +355,8 @@ export class Config {
         return this.get<string>("statusBar.clickAction");
     }
 
-    get statusBarDocumentSelector() {
-        return this.get<vscode.DocumentSelector>("statusBar.documentSelector");
+    get statusBarShowStatusBar() {
+        return this.get<ShowStatusBar>("statusBar.showStatusBar");
     }
 
     get initializeStopped() {
diff --git a/src/tools/rust-analyzer/editors/code/src/ctx.ts b/src/tools/rust-analyzer/editors/code/src/ctx.ts
index 4a3f66b00d0..4eecfc66f41 100644
--- a/src/tools/rust-analyzer/editors/code/src/ctx.ts
+++ b/src/tools/rust-analyzer/editors/code/src/ctx.ts
@@ -478,14 +478,19 @@ export class Ctx implements RustAnalyzerExtensionApi {
     }
 
     private updateStatusBarVisibility(editor: vscode.TextEditor | undefined) {
-        const documentSelector = this.config.statusBarDocumentSelector;
-        if (documentSelector != null) {
+        const showStatusBar = this.config.statusBarShowStatusBar;
+        if (showStatusBar == null || showStatusBar === "never") {
+            this.statusBar.hide();
+        } else if (showStatusBar === "always") {
+            this.statusBar.show();
+        } else {
+            const documentSelector = showStatusBar.documentSelector;
             if (editor != null && vscode.languages.match(documentSelector, editor.document) > 0) {
                 this.statusBar.show();
-                return;
+            } else {
+                this.statusBar.hide();
             }
         }
-        this.statusBar.hide();
     }
 
     pushExtCleanup(d: Disposable) {
-- 
cgit 1.4.1-3-g733a5


From 60b4ed5bd36e88b454c8833f76a7481e01cca66a Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Wed, 25 Dec 2024 15:56:06 +0800
Subject: feat: support UpdateTest in codelens

---
 .../rust-analyzer/crates/ide/src/annotations.rs    | 68 +++++++++++++++++-----
 .../rust-analyzer/crates/ide/src/hover/tests.rs    | 52 ++++++++++-------
 .../crates/rust-analyzer/src/config.rs             | 10 +++-
 .../crates/rust-analyzer/src/lsp/ext.rs            | 12 ++--
 .../crates/rust-analyzer/src/lsp/to_proto.rs       | 38 +++++++++++-
 src/tools/rust-analyzer/docs/dev/lsp-extensions.md |  2 +-
 .../rust-analyzer/docs/user/generated_config.adoc  |  6 ++
 src/tools/rust-analyzer/editors/code/package.json  | 15 +++++
 src/tools/rust-analyzer/editors/code/src/client.ts | 17 +++---
 .../rust-analyzer/editors/code/src/commands.ts     | 26 +++++++++
 src/tools/rust-analyzer/editors/code/src/config.ts |  7 +++
 src/tools/rust-analyzer/editors/code/src/main.ts   |  8 +--
 12 files changed, 204 insertions(+), 57 deletions(-)

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/crates/ide/src/annotations.rs b/src/tools/rust-analyzer/crates/ide/src/annotations.rs
index 121a463c9f1..6a4e5ba290e 100644
--- a/src/tools/rust-analyzer/crates/ide/src/annotations.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/annotations.rs
@@ -316,6 +316,11 @@ fn main() {
                                 },
                                 kind: Bin,
                                 cfg: None,
+                                update_test: UpdateTest {
+                                    expect_test: false,
+                                    insta: false,
+                                    snapbox: false,
+                                },
                             },
                         ),
                     },
@@ -401,6 +406,11 @@ fn main() {
                                 },
                                 kind: Bin,
                                 cfg: None,
+                                update_test: UpdateTest {
+                                    expect_test: false,
+                                    insta: false,
+                                    snapbox: false,
+                                },
                             },
                         ),
                     },
@@ -537,6 +547,11 @@ fn main() {
                                 },
                                 kind: Bin,
                                 cfg: None,
+                                update_test: UpdateTest {
+                                    expect_test: false,
+                                    insta: false,
+                                    snapbox: false,
+                                },
                             },
                         ),
                     },
@@ -597,6 +612,11 @@ fn main() {}
                                 },
                                 kind: Bin,
                                 cfg: None,
+                                update_test: UpdateTest {
+                                    expect_test: false,
+                                    insta: false,
+                                    snapbox: false,
+                                },
                             },
                         ),
                     },
@@ -709,6 +729,11 @@ fn main() {
                                 },
                                 kind: Bin,
                                 cfg: None,
+                                update_test: UpdateTest {
+                                    expect_test: false,
+                                    insta: false,
+                                    snapbox: false,
+                                },
                             },
                         ),
                     },
@@ -744,6 +769,20 @@ mod tests {
             "#,
             expect![[r#"
                 [
+                    Annotation {
+                        range: 3..7,
+                        kind: HasReferences {
+                            pos: FilePositionWrapper {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 3,
+                            },
+                            data: Some(
+                                [],
+                            ),
+                        },
+                    },
                     Annotation {
                         range: 3..7,
                         kind: Runnable(
@@ -760,23 +799,14 @@ mod tests {
                                 },
                                 kind: Bin,
                                 cfg: None,
+                                update_test: UpdateTest {
+                                    expect_test: false,
+                                    insta: false,
+                                    snapbox: false,
+                                },
                             },
                         ),
                     },
-                    Annotation {
-                        range: 3..7,
-                        kind: HasReferences {
-                            pos: FilePositionWrapper {
-                                file_id: FileId(
-                                    0,
-                                ),
-                                offset: 3,
-                            },
-                            data: Some(
-                                [],
-                            ),
-                        },
-                    },
                     Annotation {
                         range: 18..23,
                         kind: Runnable(
@@ -796,6 +826,11 @@ mod tests {
                                     path: "tests",
                                 },
                                 cfg: None,
+                                update_test: UpdateTest {
+                                    expect_test: false,
+                                    insta: false,
+                                    snapbox: false,
+                                },
                             },
                         ),
                     },
@@ -822,6 +857,11 @@ mod tests {
                                     },
                                 },
                                 cfg: None,
+                                update_test: UpdateTest {
+                                    expect_test: false,
+                                    insta: false,
+                                    snapbox: false,
+                                },
                             },
                         ),
                     },
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index ed8cd64cdbe..a7a5b8fb5a1 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -3213,6 +3213,11 @@ fn foo_$0test() {}
                             },
                         },
                         cfg: None,
+                        update_test: UpdateTest {
+                            expect_test: false,
+                            insta: false,
+                            snapbox: false,
+                        },
                     },
                 ),
             ]
@@ -3230,28 +3235,33 @@ mod tests$0 {
 }
 "#,
         expect![[r#"
-                [
-                    Runnable(
-                        Runnable {
-                            use_name_in_title: false,
-                            nav: NavigationTarget {
-                                file_id: FileId(
-                                    0,
-                                ),
-                                full_range: 0..46,
-                                focus_range: 4..9,
-                                name: "tests",
-                                kind: Module,
-                                description: "mod tests",
-                            },
-                            kind: TestMod {
-                                path: "tests",
-                            },
-                            cfg: None,
+            [
+                Runnable(
+                    Runnable {
+                        use_name_in_title: false,
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 0..46,
+                            focus_range: 4..9,
+                            name: "tests",
+                            kind: Module,
+                            description: "mod tests",
                         },
-                    ),
-                ]
-            "#]],
+                        kind: TestMod {
+                            path: "tests",
+                        },
+                        cfg: None,
+                        update_test: UpdateTest {
+                            expect_test: false,
+                            insta: false,
+                            snapbox: false,
+                        },
+                    },
+                ),
+            ]
+        "#]],
     );
 }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index c182952c731..1b37ab0aab2 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -243,6 +243,9 @@ config_data! {
         /// Whether to show `Run` lens. Only applies when
         /// `#rust-analyzer.lens.enable#` is set.
         lens_run_enable: bool              = true,
+        /// Whether to show `Update Test` lens. Only applies when
+        /// `#rust-analyzer.lens.enable#` and `#rust-analyzer.lens.run.enable#` are set.
+        lens_update_test_enable: bool = true,
 
         /// Disable project auto-discovery in favor of explicitly specified set
         /// of projects.
@@ -1161,6 +1164,7 @@ pub struct LensConfig {
     // runnables
     pub run: bool,
     pub debug: bool,
+    pub update_test: bool,
     pub interpret: bool,
 
     // implementations
@@ -1196,6 +1200,7 @@ impl LensConfig {
     pub fn any(&self) -> bool {
         self.run
             || self.debug
+            || self.update_test
             || self.implementations
             || self.method_refs
             || self.refs_adt
@@ -1208,7 +1213,7 @@ impl LensConfig {
     }
 
     pub fn runnable(&self) -> bool {
-        self.run || self.debug
+        self.run || self.debug || self.update_test
     }
 
     pub fn references(&self) -> bool {
@@ -2120,6 +2125,9 @@ impl Config {
         LensConfig {
             run: *self.lens_enable() && *self.lens_run_enable(),
             debug: *self.lens_enable() && *self.lens_debug_enable(),
+            update_test: *self.lens_enable()
+                && *self.lens_update_test_enable()
+                && *self.lens_run_enable(),
             interpret: *self.lens_enable() && *self.lens_run_enable() && *self.interpret_tests(),
             implementations: *self.lens_enable() && *self.lens_implementations_enable(),
             method_refs: *self.lens_enable() && *self.lens_references_method_enable(),
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/ext.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/ext.rs
index c0173d9c247..e1677cbcda8 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/ext.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/ext.rs
@@ -427,14 +427,14 @@ impl Request for Runnables {
     const METHOD: &'static str = "experimental/runnables";
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct RunnablesParams {
     pub text_document: TextDocumentIdentifier,
     pub position: Option<Position>,
 }
 
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct Runnable {
     pub label: String,
@@ -444,7 +444,7 @@ pub struct Runnable {
     pub args: RunnableArgs,
 }
 
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 #[serde(untagged)]
 pub enum RunnableArgs {
@@ -452,14 +452,14 @@ pub enum RunnableArgs {
     Shell(ShellRunnableArgs),
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum RunnableKind {
     Cargo,
     Shell,
 }
 
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct CargoRunnableArgs {
     #[serde(skip_serializing_if = "FxHashMap::is_empty")]
@@ -475,7 +475,7 @@ pub struct CargoRunnableArgs {
     pub executable_args: Vec<String>,
 }
 
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct ShellRunnableArgs {
     #[serde(skip_serializing_if = "FxHashMap::is_empty")]
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
index 05e93b4e6ac..091ac773323 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
@@ -20,6 +20,7 @@ use itertools::Itertools;
 use paths::{Utf8Component, Utf8Prefix};
 use semver::VersionReq;
 use serde_json::to_value;
+use syntax::SmolStr;
 use vfs::AbsPath;
 
 use crate::{
@@ -1567,6 +1568,7 @@ pub(crate) fn code_lens(
             let line_index = snap.file_line_index(run.nav.file_id)?;
             let annotation_range = range(&line_index, annotation.range);
 
+            let update_test = run.update_test;
             let title = run.title();
             let can_debug = match run.kind {
                 ide::RunnableKind::DocTest { .. } => false,
@@ -1602,6 +1604,17 @@ pub(crate) fn code_lens(
                             data: None,
                         })
                     }
+                    if lens_config.update_test && client_commands_config.run_single {
+                        let label = update_test.label();
+                        if let Some(r) = make_update_runnable(&r, &label) {
+                            let command = command::run_single(&r, label.unwrap().as_str());
+                            acc.push(lsp_types::CodeLens {
+                                range: annotation_range,
+                                command: Some(command),
+                                data: None,
+                            })
+                        }
+                    }
                 }
 
                 if lens_config.interpret {
@@ -1786,7 +1799,7 @@ pub(crate) mod command {
 
     pub(crate) fn debug_single(runnable: &lsp_ext::Runnable) -> lsp_types::Command {
         lsp_types::Command {
-            title: "Debug".into(),
+            title: "⚙\u{fe0e} Debug".into(),
             command: "rust-analyzer.debugSingle".into(),
             arguments: Some(vec![to_value(runnable).unwrap()]),
         }
@@ -1838,6 +1851,29 @@ pub(crate) mod command {
     }
 }
 
+fn make_update_runnable(
+    runnable: &lsp_ext::Runnable,
+    label: &Option<SmolStr>,
+) -> Option<lsp_ext::Runnable> {
+    if !matches!(runnable.args, lsp_ext::RunnableArgs::Cargo(_)) {
+        return None;
+    }
+    let label = label.as_ref()?;
+
+    let mut runnable = runnable.clone();
+    runnable.label = format!("{} + {}", runnable.label, label);
+
+    let lsp_ext::RunnableArgs::Cargo(r) = &mut runnable.args else {
+        unreachable!();
+    };
+
+    let environment_vars =
+        [("UPDATE_EXPECT", "1"), ("INSTA_UPDATE", "always"), ("SNAPSHOTS", "overwrite")];
+    r.environment.extend(environment_vars.into_iter().map(|(k, v)| (k.to_owned(), v.to_owned())));
+
+    Some(runnable)
+}
+
 pub(crate) fn implementation_title(count: usize) -> String {
     if count == 1 {
         "1 implementation".into()
diff --git a/src/tools/rust-analyzer/docs/dev/lsp-extensions.md b/src/tools/rust-analyzer/docs/dev/lsp-extensions.md
index 0e37611a549..826ce112448 100644
--- a/src/tools/rust-analyzer/docs/dev/lsp-extensions.md
+++ b/src/tools/rust-analyzer/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp/ext.rs hash: 9790509d87670c22
+lsp/ext.rs hash: 512c06cd8b46a21d
 
 If you need to change the above hash to make the test pass, please check if you
 need to adjust this doc as well and ping this issue:
diff --git a/src/tools/rust-analyzer/docs/user/generated_config.adoc b/src/tools/rust-analyzer/docs/user/generated_config.adoc
index 5056c7d977c..f5cdcc2b726 100644
--- a/src/tools/rust-analyzer/docs/user/generated_config.adoc
+++ b/src/tools/rust-analyzer/docs/user/generated_config.adoc
@@ -808,6 +808,12 @@ Only applies when `#rust-analyzer.lens.enable#` is set.
 Whether to show `Run` lens. Only applies when
 `#rust-analyzer.lens.enable#` is set.
 --
+[[rust-analyzer.lens.update.test.enable]]rust-analyzer.lens.update.test.enable (default: `true`)::
++
+--
+Whether to show `Update Test` lens. Only applies when
+`#rust-analyzer.lens.enable#` and `#rust-analyzer.lens.run.enable#` are set.
+--
 [[rust-analyzer.linkedProjects]]rust-analyzer.linkedProjects (default: `[]`)::
 +
 --
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index b9249e9ac8b..7dc26c44366 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -407,6 +407,11 @@
                             "$rustc"
                         ],
                         "markdownDescription": "Problem matchers to use for `rust-analyzer.run` command, eg `[\"$rustc\", \"$rust-panic\"]`."
+                    },
+                    "rust-analyzer.runnables.askBeforeUpdateTest": {
+                        "type": "boolean",
+                        "default": true,
+                        "markdownDescription": "Ask before updating the test when running it."
                     }
                 }
             },
@@ -2295,6 +2300,16 @@
                     }
                 }
             },
+            {
+                "title": "lens",
+                "properties": {
+                    "rust-analyzer.lens.update.test.enable": {
+                        "markdownDescription": "Whether to show `Update Test` lens. Only applies when\n`#rust-analyzer.lens.enable#` and `#rust-analyzer.lens.run.enable#` are set.",
+                        "default": true,
+                        "type": "boolean"
+                    }
+                }
+            },
             {
                 "title": "general",
                 "properties": {
diff --git a/src/tools/rust-analyzer/editors/code/src/client.ts b/src/tools/rust-analyzer/editors/code/src/client.ts
index eac7b849fdb..5d33d7a6adb 100644
--- a/src/tools/rust-analyzer/editors/code/src/client.ts
+++ b/src/tools/rust-analyzer/editors/code/src/client.ts
@@ -348,9 +348,9 @@ class ExperimentalFeatures implements lc.StaticFeature {
     initialize(
         _capabilities: lc.ServerCapabilities,
         _documentSelector: lc.DocumentSelector | undefined,
-    ): void {}
-    dispose(): void {}
-    clear(): void {}
+    ): void { }
+    dispose(): void { }
+    clear(): void { }
 }
 
 class OverrideFeatures implements lc.StaticFeature {
@@ -368,9 +368,9 @@ class OverrideFeatures implements lc.StaticFeature {
     initialize(
         _capabilities: lc.ServerCapabilities,
         _documentSelector: lc.DocumentSelector | undefined,
-    ): void {}
-    dispose(): void {}
-    clear(): void {}
+    ): void { }
+    dispose(): void { }
+    clear(): void { }
 }
 
 function isCodeActionWithoutEditsAndCommands(value: any): boolean {
@@ -398,9 +398,8 @@ export let HOVER_REFERENCE_COMMAND: ra.CommandLink[] = [];
 
 function renderCommand(cmd: ra.CommandLink): string {
     HOVER_REFERENCE_COMMAND.push(cmd);
-    return `[${cmd.title}](command:rust-analyzer.hoverRefCommandProxy?${
-        HOVER_REFERENCE_COMMAND.length - 1
-    } '${cmd.tooltip}')`;
+    return `[${cmd.title}](command:rust-analyzer.hoverRefCommandProxy?${HOVER_REFERENCE_COMMAND.length - 1
+        } '${cmd.tooltip}')`;
 }
 
 function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownString {
diff --git a/src/tools/rust-analyzer/editors/code/src/commands.ts b/src/tools/rust-analyzer/editors/code/src/commands.ts
index 7ebc186a3ea..dc35fddf49e 100644
--- a/src/tools/rust-analyzer/editors/code/src/commands.ts
+++ b/src/tools/rust-analyzer/editors/code/src/commands.ts
@@ -1139,11 +1139,37 @@ export function peekTests(ctx: CtxInit): Cmd {
     };
 }
 
+function isUpdatingTest(runnable: ra.Runnable): boolean {
+    if (!isCargoRunnableArgs(runnable.args)) {
+        return false;
+    }
+
+    const env = runnable.args.environment;
+    return env ? ['UPDATE_EXPECT', 'INSTA_UPDATE', 'SNAPSHOTS'].some(key => key in env) : false;
+}
+
 export function runSingle(ctx: CtxInit): Cmd {
     return async (runnable: ra.Runnable) => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
 
+        if (isUpdatingTest(runnable) && ctx.config.askBeforeUpdateTest) {
+            const selection = await vscode.window.showInformationMessage(
+                'rust-analyzer',
+                { detail: 'Do you want to update tests?', modal: true },
+                'Update Now',
+                'Update (and Don\'t ask again)',
+            );
+
+            if (selection !== 'Update Now' && selection !== 'Update (and Don\'t ask again)') {
+                return;
+            }
+
+            if (selection === 'Update (and Don\'t ask again)') {
+                ctx.config.setAskBeforeUpdateTest(false);
+            }
+        }
+
         const task = await createTaskFromRunnable(runnable, ctx.config);
         task.group = vscode.TaskGroup.Build;
         task.presentationOptions = {
diff --git a/src/tools/rust-analyzer/editors/code/src/config.ts b/src/tools/rust-analyzer/editors/code/src/config.ts
index a97d4beab51..720c473c5b4 100644
--- a/src/tools/rust-analyzer/editors/code/src/config.ts
+++ b/src/tools/rust-analyzer/editors/code/src/config.ts
@@ -362,6 +362,13 @@ export class Config {
     get initializeStopped() {
         return this.get<boolean>("initializeStopped");
     }
+
+    get askBeforeUpdateTest() {
+        return this.get<boolean>("runnables.askBeforeUpdateTest");
+    }
+    async setAskBeforeUpdateTest(value: boolean) {
+        await this.cfg.update("runnables.askBeforeUpdateTest", value, true);
+    }
 }
 
 export function prepareVSCodeConfig<T>(resp: T): T {
diff --git a/src/tools/rust-analyzer/editors/code/src/main.ts b/src/tools/rust-analyzer/editors/code/src/main.ts
index fdf43f66f94..478673d5915 100644
--- a/src/tools/rust-analyzer/editors/code/src/main.ts
+++ b/src/tools/rust-analyzer/editors/code/src/main.ts
@@ -148,7 +148,7 @@ function createCommands(): Record<string, CommandFactory> {
                     health: "stopped",
                 });
             },
-            disabled: (_) => async () => {},
+            disabled: (_) => async () => { },
         },
 
         analyzerStatus: { enabled: commands.analyzerStatus },
@@ -207,10 +207,10 @@ function checkConflictingExtensions() {
         vscode.window
             .showWarningMessage(
                 `You have both the rust-analyzer (rust-lang.rust-analyzer) and Rust (rust-lang.rust) ` +
-                    "plugins enabled. These are known to conflict and cause various functions of " +
-                    "both plugins to not work correctly. You should disable one of them.",
+                "plugins enabled. These are known to conflict and cause various functions of " +
+                "both plugins to not work correctly. You should disable one of them.",
                 "Got it",
             )
-            .then(() => {}, console.error);
+            .then(() => { }, console.error);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 2bfa83beb36e7aa9d55baffa1ab2d076157bba97 Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Wed, 25 Dec 2024 16:12:56 +0800
Subject: feat: add config `UpdateTest` to hover actions

---
 src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs     | 10 +++++++++-
 .../rust-analyzer/crates/rust-analyzer/src/handlers/request.rs |  2 +-
 src/tools/rust-analyzer/docs/user/generated_config.adoc        |  6 ++++++
 src/tools/rust-analyzer/editors/code/package.json              | 10 ++++++++++
 4 files changed, 26 insertions(+), 2 deletions(-)

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index 1b37ab0aab2..e240318a13a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -119,6 +119,9 @@ config_data! {
         /// Whether to show `Run` action. Only applies when
         /// `#rust-analyzer.hover.actions.enable#` is set.
         hover_actions_run_enable: bool             = true,
+        /// Whether to show `Update Test` action. Only applies when
+        /// `#rust-analyzer.hover.actions.enable#` and `#rust-analyzer.hover.actions.run.enable#` are set.
+        hover_actions_updateTest_enable: bool     = true,
 
         /// Whether to show documentation on hover.
         hover_documentation_enable: bool           = true,
@@ -1227,6 +1230,7 @@ pub struct HoverActionsConfig {
     pub references: bool,
     pub run: bool,
     pub debug: bool,
+    pub update_test: bool,
     pub goto_type_def: bool,
 }
 
@@ -1236,6 +1240,7 @@ impl HoverActionsConfig {
         references: false,
         run: false,
         debug: false,
+        update_test: false,
         goto_type_def: false,
     };
 
@@ -1248,7 +1253,7 @@ impl HoverActionsConfig {
     }
 
     pub fn runnable(&self) -> bool {
-        self.run || self.debug
+        self.run || self.debug || self.update_test
     }
 }
 
@@ -1522,6 +1527,9 @@ impl Config {
             references: enable && self.hover_actions_references_enable().to_owned(),
             run: enable && self.hover_actions_run_enable().to_owned(),
             debug: enable && self.hover_actions_debug_enable().to_owned(),
+            update_test: enable
+                && self.hover_actions_run_enable().to_owned()
+                && self.hover_actions_updateTest_enable().to_owned(),
             goto_type_def: enable && self.hover_actions_gotoTypeDef_enable().to_owned(),
         }
     }
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
index a152a0fd698..d18bc728b57 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
@@ -2158,7 +2158,7 @@ fn runnable_action_links(
         group.commands.push(to_command_link(dbg_command, r.label.clone()));
     }
 
-    if client_commands_config.update_single {
+    if hover_actions_config.update_test && client_commands_config.update_single {
         if let Some(update_command) = to_proto::command::update_single(&r, &update_test.label()) {
             group.commands.push(to_command_link(update_command, r.label.clone()));
         }
diff --git a/src/tools/rust-analyzer/docs/user/generated_config.adoc b/src/tools/rust-analyzer/docs/user/generated_config.adoc
index f5cdcc2b726..c78d577fff4 100644
--- a/src/tools/rust-analyzer/docs/user/generated_config.adoc
+++ b/src/tools/rust-analyzer/docs/user/generated_config.adoc
@@ -497,6 +497,12 @@ Whether to show `References` action. Only applies when
 Whether to show `Run` action. Only applies when
 `#rust-analyzer.hover.actions.enable#` is set.
 --
+[[rust-analyzer.hover.actions.updateTest.enable]]rust-analyzer.hover.actions.updateTest.enable (default: `true`)::
++
+--
+Whether to show `Update Test` action. Only applies when
+`#rust-analyzer.hover.actions.enable#` and `#rust-analyzer.hover.actions.run.enable#` are set.
+--
 [[rust-analyzer.hover.documentation.enable]]rust-analyzer.hover.documentation.enable (default: `true`)::
 +
 --
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 7dc26c44366..2c7b129618b 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -1520,6 +1520,16 @@
                     }
                 }
             },
+            {
+                "title": "hover",
+                "properties": {
+                    "rust-analyzer.hover.actions.updateTest.enable": {
+                        "markdownDescription": "Whether to show `Update Test` action. Only applies when\n`#rust-analyzer.hover.actions.enable#` and `#rust-analyzer.hover.actions.run.enable#` are set.",
+                        "default": true,
+                        "type": "boolean"
+                    }
+                }
+            },
             {
                 "title": "hover",
                 "properties": {
-- 
cgit 1.4.1-3-g733a5


From c8f29aad5e886a010a8175ee143e2feec9e46a35 Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Wed, 25 Dec 2024 22:24:22 +0800
Subject: fix incorrect name for UpdateTest config

---
 src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs | 4 ++--
 src/tools/rust-analyzer/docs/user/generated_config.adoc    | 2 +-
 src/tools/rust-analyzer/editors/code/package.json          | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index e240318a13a..0f8840a810c 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -248,7 +248,7 @@ config_data! {
         lens_run_enable: bool              = true,
         /// Whether to show `Update Test` lens. Only applies when
         /// `#rust-analyzer.lens.enable#` and `#rust-analyzer.lens.run.enable#` are set.
-        lens_update_test_enable: bool = true,
+        lens_updateTest_enable: bool = true,
 
         /// Disable project auto-discovery in favor of explicitly specified set
         /// of projects.
@@ -2134,7 +2134,7 @@ impl Config {
             run: *self.lens_enable() && *self.lens_run_enable(),
             debug: *self.lens_enable() && *self.lens_debug_enable(),
             update_test: *self.lens_enable()
-                && *self.lens_update_test_enable()
+                && *self.lens_updateTest_enable()
                 && *self.lens_run_enable(),
             interpret: *self.lens_enable() && *self.lens_run_enable() && *self.interpret_tests(),
             implementations: *self.lens_enable() && *self.lens_implementations_enable(),
diff --git a/src/tools/rust-analyzer/docs/user/generated_config.adoc b/src/tools/rust-analyzer/docs/user/generated_config.adoc
index c78d577fff4..fffbb94efab 100644
--- a/src/tools/rust-analyzer/docs/user/generated_config.adoc
+++ b/src/tools/rust-analyzer/docs/user/generated_config.adoc
@@ -814,7 +814,7 @@ Only applies when `#rust-analyzer.lens.enable#` is set.
 Whether to show `Run` lens. Only applies when
 `#rust-analyzer.lens.enable#` is set.
 --
-[[rust-analyzer.lens.update.test.enable]]rust-analyzer.lens.update.test.enable (default: `true`)::
+[[rust-analyzer.lens.updateTest.enable]]rust-analyzer.lens.updateTest.enable (default: `true`)::
 +
 --
 Whether to show `Update Test` lens. Only applies when
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 2c7b129618b..426414becb3 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -2313,7 +2313,7 @@
             {
                 "title": "lens",
                 "properties": {
-                    "rust-analyzer.lens.update.test.enable": {
+                    "rust-analyzer.lens.updateTest.enable": {
                         "markdownDescription": "Whether to show `Update Test` lens. Only applies when\n`#rust-analyzer.lens.enable#` and `#rust-analyzer.lens.run.enable#` are set.",
                         "default": true,
                         "type": "boolean"
-- 
cgit 1.4.1-3-g733a5


From bd6ea14002949c2b2fdf9ec51cce3634b7a15147 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 24 Sep 2024 19:24:15 +0300
Subject: Allow excluding specific traits from completion

To be accurate, only their methods are excluded, the trait themselves are still available.

I also excluded a bunch of std traits by default. Some less opinionated, like `AsRef`, which should never be used directly except in generic scenarios (and won't be excluded there), some more opinionated, like the ops traits, which I know some users sometimes want to use directly. Either way it's configurable.

It should be pretty easy to extend support to excluding only specific methods, but I didn't do that currently.

Traits configured to be excluded are resolved in each completion request from scratch. If this proves too expensive, it is easy enough to cache them in the DB.
---
 .../rust-analyzer/crates/hir-def/src/item_scope.rs |   7 +
 .../crates/hir-ty/src/method_resolution.rs         |  69 +++-
 src/tools/rust-analyzer/crates/hir/src/attrs.rs    |   2 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs      | 178 ++++++++--
 .../crates/ide-completion/src/completions/dot.rs   |  56 ++-
 .../crates/ide-completion/src/completions/expr.rs  |  80 ++++-
 .../ide-completion/src/completions/flyimport.rs    |  16 +
 .../crates/ide-completion/src/config.rs            |   6 +-
 .../crates/ide-completion/src/context.rs           |  91 ++++-
 .../rust-analyzer/crates/ide-completion/src/lib.rs |   4 +-
 .../crates/ide-completion/src/tests.rs             |  14 +-
 .../crates/ide-completion/src/tests/expression.rs  | 381 ++++++++++++++++++++-
 .../crates/ide-completion/src/tests/special.rs     |   2 +-
 src/tools/rust-analyzer/crates/ide/src/lib.rs      |   4 +-
 .../crates/rust-analyzer/src/config.rs             |  57 ++-
 .../rust-analyzer/src/integrated_benchmarks.rs     |   6 +
 .../rust-analyzer/docs/user/generated_config.adoc  |  64 ++++
 src/tools/rust-analyzer/editors/code/package.json  |  56 +++
 18 files changed, 1011 insertions(+), 82 deletions(-)

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
index 2c3eb5c8e5e..f600efea9f2 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
@@ -354,6 +354,13 @@ impl ItemScope {
             .chain(self.unnamed_trait_imports.keys().copied())
     }
 
+    pub fn trait_by_name(&self, name: &Name) -> Option<TraitId> {
+        self.types.get(name).and_then(|def| match def.def {
+            ModuleDefId::TraitId(it) => Some(it),
+            _ => None,
+        })
+    }
+
     pub(crate) fn resolutions(&self) -> impl Iterator<Item = (Option<Name>, PerNs)> + '_ {
         self.entries().map(|(name, res)| (Some(name.clone()), res)).chain(
             self.unnamed_trait_imports.iter().map(|(tr, trait_)| {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 952580c3b70..dd6104aec89 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -913,7 +913,7 @@ pub fn iterate_path_candidates(
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
-    callback: &mut dyn FnMut(AssocItemId) -> ControlFlow<()>,
+    callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
     iterate_method_candidates_dyn(
         ty,
@@ -924,7 +924,7 @@ pub fn iterate_path_candidates(
         name,
         LookupMode::Path,
         // the adjustments are not relevant for path lookup
-        &mut |_, id, _| callback(id),
+        callback,
     )
 }
 
@@ -936,7 +936,7 @@ pub fn iterate_method_candidates_dyn(
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
     mode: LookupMode,
-    callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
+    callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
     let _p = tracing::info_span!(
         "iterate_method_candidates_dyn",
@@ -1006,7 +1006,7 @@ fn iterate_method_candidates_with_autoref(
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
-    mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
+    callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
     if receiver_ty.value.is_general_var(Interner, &receiver_ty.binders) {
         // don't try to resolve methods on unknown types
@@ -1021,7 +1021,7 @@ fn iterate_method_candidates_with_autoref(
             traits_in_scope,
             visible_from_module,
             name,
-            &mut callback,
+            callback,
         )
     };
 
@@ -1051,6 +1051,45 @@ fn iterate_method_candidates_with_autoref(
     iterate_method_candidates_by_receiver(ref_muted, first_adjustment.with_autoref(Mutability::Mut))
 }
 
+pub trait MethodCandidateCallback {
+    fn on_inherent_method(
+        &mut self,
+        adjustments: ReceiverAdjustments,
+        item: AssocItemId,
+        is_visible: bool,
+    ) -> ControlFlow<()>;
+
+    fn on_trait_method(
+        &mut self,
+        adjustments: ReceiverAdjustments,
+        item: AssocItemId,
+        is_visible: bool,
+    ) -> ControlFlow<()>;
+}
+
+impl<F> MethodCandidateCallback for F
+where
+    F: FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
+{
+    fn on_inherent_method(
+        &mut self,
+        adjustments: ReceiverAdjustments,
+        item: AssocItemId,
+        is_visible: bool,
+    ) -> ControlFlow<()> {
+        self(adjustments, item, is_visible)
+    }
+
+    fn on_trait_method(
+        &mut self,
+        adjustments: ReceiverAdjustments,
+        item: AssocItemId,
+        is_visible: bool,
+    ) -> ControlFlow<()> {
+        self(adjustments, item, is_visible)
+    }
+}
+
 #[tracing::instrument(skip_all, fields(name = ?name))]
 fn iterate_method_candidates_by_receiver(
     table: &mut InferenceTable<'_>,
@@ -1059,7 +1098,7 @@ fn iterate_method_candidates_by_receiver(
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
-    mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
+    callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
     let receiver_ty = table.instantiate_canonical(receiver_ty);
     // We're looking for methods with *receiver* type receiver_ty. These could
@@ -1075,7 +1114,9 @@ fn iterate_method_candidates_by_receiver(
                 Some(&receiver_ty),
                 Some(receiver_adjustments.clone()),
                 visible_from_module,
-                &mut callback,
+                &mut |adjustments, item, is_visible| {
+                    callback.on_inherent_method(adjustments, item, is_visible)
+                },
             )?
         }
         ControlFlow::Continue(())
@@ -1095,7 +1136,9 @@ fn iterate_method_candidates_by_receiver(
                 name,
                 Some(&receiver_ty),
                 Some(receiver_adjustments.clone()),
-                &mut callback,
+                &mut |adjustments, item, is_visible| {
+                    callback.on_trait_method(adjustments, item, is_visible)
+                },
             )?
         }
         ControlFlow::Continue(())
@@ -1110,7 +1153,7 @@ fn iterate_method_candidates_for_self_ty(
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
-    mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
+    callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
     let mut table = InferenceTable::new(db, env);
     let self_ty = table.instantiate_canonical(self_ty.clone());
@@ -1121,7 +1164,9 @@ fn iterate_method_candidates_for_self_ty(
         None,
         None,
         visible_from_module,
-        &mut callback,
+        &mut |adjustments, item, is_visible| {
+            callback.on_inherent_method(adjustments, item, is_visible)
+        },
     )?;
     iterate_trait_method_candidates(
         &self_ty,
@@ -1130,7 +1175,9 @@ fn iterate_method_candidates_for_self_ty(
         name,
         None,
         None,
-        callback,
+        &mut |adjustments, item, is_visible| {
+            callback.on_trait_method(adjustments, item, is_visible)
+        },
     )
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir/src/attrs.rs b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
index af60c233e55..a23fdf1b393 100644
--- a/src/tools/rust-analyzer/crates/hir/src/attrs.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
@@ -258,7 +258,7 @@ fn resolve_impl_trait_item(
         &traits_in_scope,
         method_resolution::VisibleFromModule::None,
         Some(name),
-        &mut |assoc_item_id| {
+        &mut |_, assoc_item_id: AssocItemId, _| {
             // If two traits in scope define the same item, Rustdoc links to no specific trait (for
             // instance, given two methods `a`, Rustdoc simply links to `method.a` with no
             // disambiguation) so we just pick the first one we find as well.
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index f8af04302f0..4c5f9d2a5a1 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -5219,28 +5219,49 @@ impl Type {
         traits_in_scope: &FxHashSet<TraitId>,
         with_local_impls: Option<Module>,
         name: Option<&Name>,
-        mut callback: impl FnMut(Function) -> Option<T>,
+        callback: impl FnMut(Function) -> Option<T>,
     ) -> Option<T> {
+        struct Callback<T, F> {
+            f: F,
+            slot: Option<T>,
+        }
+        impl<T, F> MethodCandidateCallback for &'_ mut Callback<T, F>
+        where
+            F: FnMut(Function) -> Option<T>,
+        {
+            fn on_inherent_method(&mut self, f: Function) -> ControlFlow<()> {
+                match (self.f)(f) {
+                    it @ Some(_) => {
+                        self.slot = it;
+                        ControlFlow::Break(())
+                    }
+                    None => ControlFlow::Continue(()),
+                }
+            }
+
+            fn on_trait_method(&mut self, f: Function) -> ControlFlow<()> {
+                match (self.f)(f) {
+                    it @ Some(_) => {
+                        self.slot = it;
+                        ControlFlow::Break(())
+                    }
+                    None => ControlFlow::Continue(()),
+                }
+            }
+        }
+
         let _p = tracing::info_span!("iterate_method_candidates_with_traits").entered();
-        let mut slot = None;
+        let mut callback = Callback { slot: None, f: callback };
 
-        self.iterate_method_candidates_dyn(
+        self.iterate_method_candidates_split_inherent(
             db,
             scope,
             traits_in_scope,
             with_local_impls,
             name,
-            &mut |assoc_item_id| {
-                if let AssocItemId::FunctionId(func) = assoc_item_id {
-                    if let Some(res) = callback(func.into()) {
-                        slot = Some(res);
-                        return ControlFlow::Break(());
-                    }
-                }
-                ControlFlow::Continue(())
-            },
+            &mut callback,
         );
-        slot
+        callback.slot
     }
 
     pub fn iterate_method_candidates<T>(
@@ -5261,15 +5282,49 @@ impl Type {
         )
     }
 
-    fn iterate_method_candidates_dyn(
+    /// Allows you to treat inherent and non-inherent methods differently.
+    ///
+    /// Note that inherent methods may actually be trait methods! For example, in `dyn Trait`, the trait's methods
+    /// are considered inherent methods.
+    pub fn iterate_method_candidates_split_inherent(
         &self,
         db: &dyn HirDatabase,
         scope: &SemanticsScope<'_>,
         traits_in_scope: &FxHashSet<TraitId>,
         with_local_impls: Option<Module>,
         name: Option<&Name>,
-        callback: &mut dyn FnMut(AssocItemId) -> ControlFlow<()>,
+        callback: impl MethodCandidateCallback,
     ) {
+        struct Callback<T>(T);
+
+        impl<T: MethodCandidateCallback> method_resolution::MethodCandidateCallback for Callback<T> {
+            fn on_inherent_method(
+                &mut self,
+                _adjustments: method_resolution::ReceiverAdjustments,
+                item: AssocItemId,
+                _is_visible: bool,
+            ) -> ControlFlow<()> {
+                if let AssocItemId::FunctionId(func) = item {
+                    self.0.on_inherent_method(func.into())
+                } else {
+                    ControlFlow::Continue(())
+                }
+            }
+
+            fn on_trait_method(
+                &mut self,
+                _adjustments: method_resolution::ReceiverAdjustments,
+                item: AssocItemId,
+                _is_visible: bool,
+            ) -> ControlFlow<()> {
+                if let AssocItemId::FunctionId(func) = item {
+                    self.0.on_trait_method(func.into())
+                } else {
+                    ControlFlow::Continue(())
+                }
+            }
+        }
+
         let _p = tracing::info_span!(
             "iterate_method_candidates_dyn",
             with_local_impls = traits_in_scope.len(),
@@ -5294,7 +5349,7 @@ impl Type {
             with_local_impls.and_then(|b| b.id.containing_block()).into(),
             name,
             method_resolution::LookupMode::MethodCall,
-            &mut |_adj, id, _| callback(id),
+            &mut Callback(callback),
         );
     }
 
@@ -5306,37 +5361,88 @@ impl Type {
         traits_in_scope: &FxHashSet<TraitId>,
         with_local_impls: Option<Module>,
         name: Option<&Name>,
-        mut callback: impl FnMut(AssocItem) -> Option<T>,
+        callback: impl FnMut(AssocItem) -> Option<T>,
     ) -> Option<T> {
+        struct Callback<T, F> {
+            f: F,
+            slot: Option<T>,
+        }
+        impl<T, F> PathCandidateCallback for &'_ mut Callback<T, F>
+        where
+            F: FnMut(AssocItem) -> Option<T>,
+        {
+            fn on_inherent_item(&mut self, item: AssocItem) -> ControlFlow<()> {
+                match (self.f)(item) {
+                    it @ Some(_) => {
+                        self.slot = it;
+                        ControlFlow::Break(())
+                    }
+                    None => ControlFlow::Continue(()),
+                }
+            }
+
+            fn on_trait_item(&mut self, item: AssocItem) -> ControlFlow<()> {
+                match (self.f)(item) {
+                    it @ Some(_) => {
+                        self.slot = it;
+                        ControlFlow::Break(())
+                    }
+                    None => ControlFlow::Continue(()),
+                }
+            }
+        }
+
         let _p = tracing::info_span!("iterate_path_candidates").entered();
-        let mut slot = None;
-        self.iterate_path_candidates_dyn(
+        let mut callback = Callback { slot: None, f: callback };
+
+        self.iterate_path_candidates_split_inherent(
             db,
             scope,
             traits_in_scope,
             with_local_impls,
             name,
-            &mut |assoc_item_id| {
-                if let Some(res) = callback(assoc_item_id.into()) {
-                    slot = Some(res);
-                    return ControlFlow::Break(());
-                }
-                ControlFlow::Continue(())
-            },
+            &mut callback,
         );
-        slot
+        callback.slot
     }
 
+    /// Iterates over inherent methods.
+    ///
+    /// In some circumstances, inherent methods methods may actually be trait methods!
+    /// For example, when `dyn Trait` is a receiver, _trait_'s methods would be considered
+    /// to be inherent methods.
     #[tracing::instrument(skip_all, fields(name = ?name))]
-    fn iterate_path_candidates_dyn(
+    pub fn iterate_path_candidates_split_inherent(
         &self,
         db: &dyn HirDatabase,
         scope: &SemanticsScope<'_>,
         traits_in_scope: &FxHashSet<TraitId>,
         with_local_impls: Option<Module>,
         name: Option<&Name>,
-        callback: &mut dyn FnMut(AssocItemId) -> ControlFlow<()>,
+        callback: impl PathCandidateCallback,
     ) {
+        struct Callback<T>(T);
+
+        impl<T: PathCandidateCallback> method_resolution::MethodCandidateCallback for Callback<T> {
+            fn on_inherent_method(
+                &mut self,
+                _adjustments: method_resolution::ReceiverAdjustments,
+                item: AssocItemId,
+                _is_visible: bool,
+            ) -> ControlFlow<()> {
+                self.0.on_inherent_item(item.into())
+            }
+
+            fn on_trait_method(
+                &mut self,
+                _adjustments: method_resolution::ReceiverAdjustments,
+                item: AssocItemId,
+                _is_visible: bool,
+            ) -> ControlFlow<()> {
+                self.0.on_trait_item(item.into())
+            }
+        }
+
         let canonical = hir_ty::replace_errors_with_variables(&self.ty);
 
         let krate = scope.krate();
@@ -5352,7 +5458,7 @@ impl Type {
             traits_in_scope,
             with_local_impls.and_then(|b| b.id.containing_block()).into(),
             name,
-            callback,
+            &mut Callback(callback),
         );
     }
 
@@ -6054,3 +6160,15 @@ fn push_ty_diagnostics(
         );
     }
 }
+
+pub trait MethodCandidateCallback {
+    fn on_inherent_method(&mut self, f: Function) -> ControlFlow<()>;
+
+    fn on_trait_method(&mut self, f: Function) -> ControlFlow<()>;
+}
+
+pub trait PathCandidateCallback {
+    fn on_inherent_item(&mut self, item: AssocItem) -> ControlFlow<()>;
+
+    fn on_trait_item(&mut self, item: AssocItem) -> ControlFlow<()>;
+}
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
index 229ce7723b5..26074672ba9 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
@@ -1,6 +1,8 @@
 //! Completes references after dot (fields and method calls).
 
-use hir::{sym, Name};
+use std::ops::ControlFlow;
+
+use hir::{sym, HasContainer, ItemContainer, MethodCandidateCallback, Name};
 use ide_db::FxHashSet;
 use syntax::SmolStr;
 
@@ -158,21 +160,55 @@ fn complete_fields(
 fn complete_methods(
     ctx: &CompletionContext<'_>,
     receiver: &hir::Type,
-    mut f: impl FnMut(hir::Function),
+    f: impl FnMut(hir::Function),
 ) {
-    let mut seen_methods = FxHashSet::default();
-    receiver.iterate_method_candidates_with_traits(
+    struct Callback<'a, F> {
+        ctx: &'a CompletionContext<'a>,
+        f: F,
+        seen_methods: FxHashSet<Name>,
+    }
+
+    impl<F> MethodCandidateCallback for Callback<'_, F>
+    where
+        F: FnMut(hir::Function),
+    {
+        // We don't want to exclude inherent trait methods - that is, methods of traits available from
+        // `where` clauses or `dyn Trait`.
+        fn on_inherent_method(&mut self, func: hir::Function) -> ControlFlow<()> {
+            if func.self_param(self.ctx.db).is_some()
+                && self.seen_methods.insert(func.name(self.ctx.db))
+            {
+                (self.f)(func);
+            }
+            ControlFlow::Continue(())
+        }
+
+        fn on_trait_method(&mut self, func: hir::Function) -> ControlFlow<()> {
+            // This needs to come before the `seen_methods` test, so that if we see the same method twice,
+            // once as inherent and once not, we will include it.
+            if let ItemContainer::Trait(trait_) = func.container(self.ctx.db) {
+                if self.ctx.exclude_traits.contains(&trait_) {
+                    return ControlFlow::Continue(());
+                }
+            }
+
+            if func.self_param(self.ctx.db).is_some()
+                && self.seen_methods.insert(func.name(self.ctx.db))
+            {
+                (self.f)(func);
+            }
+
+            ControlFlow::Continue(())
+        }
+    }
+
+    receiver.iterate_method_candidates_split_inherent(
         ctx.db,
         &ctx.scope,
         &ctx.traits_in_scope(),
         Some(ctx.module),
         None,
-        |func| {
-            if func.self_param(ctx.db).is_some() && seen_methods.insert(func.name(ctx.db)) {
-                f(func);
-            }
-            None::<()>
-        },
+        Callback { ctx, f, seen_methods: FxHashSet::default() },
     );
 }
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
index ff2c8da4213..e9eb3fc8428 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
@@ -1,6 +1,9 @@
 //! Completion of names from the current scope in expression position.
 
-use hir::{sym, Name, ScopeDef};
+use std::ops::ControlFlow;
+
+use hir::{sym, Name, PathCandidateCallback, ScopeDef};
+use ide_db::FxHashSet;
 use syntax::ast;
 
 use crate::{
@@ -9,6 +12,39 @@ use crate::{
     CompletionContext, Completions,
 };
 
+struct PathCallback<'a, F> {
+    ctx: &'a CompletionContext<'a>,
+    acc: &'a mut Completions,
+    add_assoc_item: F,
+    seen: FxHashSet<hir::AssocItem>,
+}
+
+impl<F> PathCandidateCallback for PathCallback<'_, F>
+where
+    F: FnMut(&mut Completions, hir::AssocItem),
+{
+    fn on_inherent_item(&mut self, item: hir::AssocItem) -> ControlFlow<()> {
+        if self.seen.insert(item) {
+            (self.add_assoc_item)(self.acc, item);
+        }
+        ControlFlow::Continue(())
+    }
+
+    #[allow(unstable_name_collisions)] // FIXME: Remove this when `is_none_or()` reaches stable.
+    fn on_trait_item(&mut self, item: hir::AssocItem) -> ControlFlow<()> {
+        // The excluded check needs to come before the `seen` test, so that if we see the same method twice,
+        // once as inherent and once not, we will include it.
+        if item
+            .container_trait(self.ctx.db)
+            .is_none_or(|trait_| !self.ctx.exclude_traits.contains(&trait_))
+            && self.seen.insert(item)
+        {
+            (self.add_assoc_item)(self.acc, item);
+        }
+        ControlFlow::Continue(())
+    }
+}
+
 pub(crate) fn complete_expr_path(
     acc: &mut Completions,
     ctx: &CompletionContext<'_>,
@@ -50,12 +86,18 @@ pub(crate) fn complete_expr_path(
     };
 
     match qualified {
+        // We exclude associated types/consts of excluded traits here together with methods,
+        // even though we don't exclude them when completing in type position, because it's easier.
         Qualified::TypeAnchor { ty: None, trait_: None } => ctx
             .traits_in_scope()
             .iter()
-            .flat_map(|&it| hir::Trait::from(it).items(ctx.sema.db))
+            .copied()
+            .map(hir::Trait::from)
+            .filter(|it| !ctx.exclude_traits.contains(it))
+            .flat_map(|it| it.items(ctx.sema.db))
             .for_each(|item| add_assoc_item(acc, item)),
         Qualified::TypeAnchor { trait_: Some(trait_), .. } => {
+            // Don't filter excluded traits here, user requested this specific trait.
             trait_.items(ctx.sema.db).into_iter().for_each(|item| add_assoc_item(acc, item))
         }
         Qualified::TypeAnchor { ty: Some(ty), trait_: None } => {
@@ -64,9 +106,14 @@ pub(crate) fn complete_expr_path(
                 acc.add_enum_variants(ctx, path_ctx, e);
             }
 
-            ctx.iterate_path_candidates(ty, |item| {
-                add_assoc_item(acc, item);
-            });
+            ty.iterate_path_candidates_split_inherent(
+                ctx.db,
+                &ctx.scope,
+                &ctx.traits_in_scope(),
+                Some(ctx.module),
+                None,
+                PathCallback { ctx, acc, add_assoc_item, seen: FxHashSet::default() },
+            );
 
             // Iterate assoc types separately
             ty.iterate_assoc_items(ctx.db, ctx.krate, |item| {
@@ -121,9 +168,14 @@ pub(crate) fn complete_expr_path(
                     // XXX: For parity with Rust bug #22519, this does not complete Ty::AssocType.
                     // (where AssocType is defined on a trait, not an inherent impl)
 
-                    ctx.iterate_path_candidates(&ty, |item| {
-                        add_assoc_item(acc, item);
-                    });
+                    ty.iterate_path_candidates_split_inherent(
+                        ctx.db,
+                        &ctx.scope,
+                        &ctx.traits_in_scope(),
+                        Some(ctx.module),
+                        None,
+                        PathCallback { ctx, acc, add_assoc_item, seen: FxHashSet::default() },
+                    );
 
                     // Iterate assoc types separately
                     ty.iterate_assoc_items(ctx.db, ctx.krate, |item| {
@@ -134,6 +186,7 @@ pub(crate) fn complete_expr_path(
                     });
                 }
                 hir::PathResolution::Def(hir::ModuleDef::Trait(t)) => {
+                    // Don't filter excluded traits here, user requested this specific trait.
                     // Handles `Trait::assoc` as well as `<Ty as Trait>::assoc`.
                     for item in t.items(ctx.db) {
                         add_assoc_item(acc, item);
@@ -151,9 +204,14 @@ pub(crate) fn complete_expr_path(
                         acc.add_enum_variants(ctx, path_ctx, e);
                     }
 
-                    ctx.iterate_path_candidates(&ty, |item| {
-                        add_assoc_item(acc, item);
-                    });
+                    ty.iterate_path_candidates_split_inherent(
+                        ctx.db,
+                        &ctx.scope,
+                        &ctx.traits_in_scope(),
+                        Some(ctx.module),
+                        None,
+                        PathCallback { ctx, acc, add_assoc_item, seen: FxHashSet::default() },
+                    );
                 }
                 _ => (),
             }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs
index 2a6b310d3a2..3f74e361018 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs
@@ -267,6 +267,15 @@ fn import_on_the_fly(
                 && !ctx.is_item_hidden(original_item)
                 && ctx.check_stability(original_item.attrs(ctx.db).as_deref())
         })
+        .filter(|import| {
+            if let ModuleDef::Trait(trait_) = import.item_to_import.into_module_def() {
+                let excluded = ctx.exclude_flyimport_traits.contains(&trait_);
+                let trait_itself_imported = import.item_to_import == import.original_item;
+                !excluded || trait_itself_imported
+            } else {
+                true
+            }
+        })
         .sorted_by(|a, b| {
             let key = |import_path| {
                 (
@@ -352,6 +361,13 @@ fn import_on_the_fly_method(
             !ctx.is_item_hidden(&import.item_to_import)
                 && !ctx.is_item_hidden(&import.original_item)
         })
+        .filter(|import| {
+            if let ModuleDef::Trait(trait_) = import.item_to_import.into_module_def() {
+                !ctx.exclude_flyimport_traits.contains(&trait_)
+            } else {
+                true
+            }
+        })
         .sorted_by(|a, b| {
             let key = |import_path| {
                 (
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/config.rs b/src/tools/rust-analyzer/crates/ide-completion/src/config.rs
index 1d05419c96d..ed36fe8d028 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/config.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/config.rs
@@ -10,7 +10,7 @@ use ide_db::{imports::insert_use::InsertUseConfig, SnippetCap};
 use crate::{snippet::Snippet, CompletionFieldsToResolve};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct CompletionConfig {
+pub struct CompletionConfig<'a> {
     pub enable_postfix_completions: bool,
     pub enable_imports_on_the_fly: bool,
     pub enable_self_on_the_fly: bool,
@@ -28,6 +28,8 @@ pub struct CompletionConfig {
     pub snippets: Vec<Snippet>,
     pub limit: Option<usize>,
     pub fields_to_resolve: CompletionFieldsToResolve,
+    pub exclude_flyimport_traits: &'a [String],
+    pub exclude_traits: &'a [String],
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -36,7 +38,7 @@ pub enum CallableSnippets {
     AddParentheses,
 }
 
-impl CompletionConfig {
+impl CompletionConfig<'_> {
     pub fn postfix_snippets(&self) -> impl Iterator<Item = (&str, &Snippet)> {
         self.snippets
             .iter()
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
index f8d403122d1..db909874dfe 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
@@ -7,8 +7,8 @@ mod tests;
 use std::{iter, ops::ControlFlow};
 
 use hir::{
-    HasAttrs, Local, ModuleSource, Name, PathResolution, ScopeDef, Semantics, SemanticsScope,
-    Symbol, Type, TypeInfo,
+    db::DefDatabase, HasAttrs, Local, ModuleSource, Name, PathResolution, ScopeDef, Semantics,
+    SemanticsScope, Symbol, Type, TypeInfo,
 };
 use ide_db::{
     base_db::SourceDatabase, famous_defs::FamousDefs, helpers::is_editable_crate, FilePosition,
@@ -429,7 +429,7 @@ pub(crate) struct CompletionContext<'a> {
     pub(crate) sema: Semantics<'a, RootDatabase>,
     pub(crate) scope: SemanticsScope<'a>,
     pub(crate) db: &'a RootDatabase,
-    pub(crate) config: &'a CompletionConfig,
+    pub(crate) config: &'a CompletionConfig<'a>,
     pub(crate) position: FilePosition,
 
     /// The token before the cursor, in the original file.
@@ -462,6 +462,17 @@ pub(crate) struct CompletionContext<'a> {
     /// Here depth will be 2
     pub(crate) depth_from_crate_root: usize,
 
+    /// Traits whose methods will be excluded from flyimport. Flyimport should not suggest
+    /// importing those traits.
+    ///
+    /// Note the trait *themselves* are not excluded, only their methods are.
+    pub(crate) exclude_flyimport_traits: FxHashSet<hir::Trait>,
+    /// Traits whose methods should always be excluded, even when in scope (compare `exclude_flyimport_traits`).
+    /// They will *not* be excluded, however, if they are available as a generic bound.
+    ///
+    /// Note the trait *themselves* are not excluded, only their methods are.
+    pub(crate) exclude_traits: FxHashSet<hir::Trait>,
+
     /// Whether and how to complete semicolon for unit-returning functions.
     pub(crate) complete_semicolon: CompleteSemicolon,
 }
@@ -670,7 +681,7 @@ impl<'a> CompletionContext<'a> {
     pub(crate) fn new(
         db: &'a RootDatabase,
         position @ FilePosition { file_id, offset }: FilePosition,
-        config: &'a CompletionConfig,
+        config: &'a CompletionConfig<'a>,
     ) -> Option<(CompletionContext<'a>, CompletionAnalysis)> {
         let _p = tracing::info_span!("CompletionContext::new").entered();
         let sema = Semantics::new(db);
@@ -753,6 +764,11 @@ impl<'a> CompletionContext<'a> {
             // exclude `m` itself
             .saturating_sub(1);
 
+        let exclude_traits = resolve_exclude_traits_list(db, config.exclude_traits);
+        let mut exclude_flyimport_traits =
+            resolve_exclude_traits_list(db, config.exclude_flyimport_traits);
+        exclude_flyimport_traits.extend(exclude_traits.iter().copied());
+
         let complete_semicolon = if config.add_semicolon_to_unit {
             let inside_closure_ret = token.parent_ancestors().try_for_each(|ancestor| {
                 match_ast! {
@@ -817,12 +833,79 @@ impl<'a> CompletionContext<'a> {
             qualifier_ctx,
             locals,
             depth_from_crate_root,
+            exclude_flyimport_traits,
+            exclude_traits,
             complete_semicolon,
         };
         Some((ctx, analysis))
     }
 }
 
+fn resolve_exclude_traits_list(db: &RootDatabase, traits: &[String]) -> FxHashSet<hir::Trait> {
+    let _g = tracing::debug_span!("resolve_exclude_trait_list", ?traits).entered();
+    let crate_graph = db.crate_graph();
+    let mut crate_name_to_def_map = FxHashMap::default();
+    let mut result = FxHashSet::default();
+    'process_traits: for trait_ in traits {
+        let mut segments = trait_.split("::").peekable();
+        let Some(crate_name) = segments.next() else {
+            tracing::error!(
+                ?trait_,
+                "error resolving trait from traits exclude list: invalid path"
+            );
+            continue;
+        };
+        let Some(def_map) = crate_name_to_def_map.entry(crate_name).or_insert_with(|| {
+            let krate = crate_graph
+                .iter()
+                .find(|&krate| crate_graph[krate].display_name.as_deref() == Some(crate_name));
+            let def_map = krate.map(|krate| db.crate_def_map(krate));
+            if def_map.is_none() {
+                tracing::error!(
+                    "error resolving `{trait_}` from trait exclude lists: crate could not be found"
+                );
+            }
+            def_map
+        }) else {
+            // Do not report more than one error for the same crate.
+            continue;
+        };
+        let mut module = &def_map[hir::DefMap::ROOT];
+        let trait_name = 'lookup_mods: {
+            while let Some(segment) = segments.next() {
+                if segments.peek().is_none() {
+                    break 'lookup_mods segment;
+                }
+
+                let Some(&inner) =
+                    module.children.get(&Name::new_symbol_root(hir::Symbol::intern(segment)))
+                else {
+                    tracing::error!(
+                        "error resolving `{trait_}` from trait exclude lists: could not find module `{segment}`"
+                    );
+                    continue 'process_traits;
+                };
+                module = &def_map[inner];
+            }
+
+            tracing::error!("error resolving `{trait_}` from trait exclude lists: invalid path");
+            continue 'process_traits;
+        };
+        let resolved_trait = module
+            .scope
+            .trait_by_name(&Name::new_symbol_root(hir::Symbol::intern(trait_name)))
+            .map(hir::Trait::from);
+        let Some(resolved_trait) = resolved_trait else {
+            tracing::error!(
+                "error resolving `{trait_}` from trait exclude lists: trait could not be found"
+            );
+            continue;
+        };
+        result.insert(resolved_trait);
+    }
+    result
+}
+
 const OP_TRAIT_LANG_NAMES: &[&str] = &[
     "add_assign",
     "add",
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs b/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
index 14f42b40055..05563bc912d 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
@@ -184,7 +184,7 @@ impl CompletionFieldsToResolve {
 /// analysis.
 pub fn completions(
     db: &RootDatabase,
-    config: &CompletionConfig,
+    config: &CompletionConfig<'_>,
     position: FilePosition,
     trigger_character: Option<char>,
 ) -> Option<Vec<CompletionItem>> {
@@ -269,7 +269,7 @@ pub fn completions(
 /// This is used for import insertion done via completions like flyimport and custom user snippets.
 pub fn resolve_completion_edits(
     db: &RootDatabase,
-    config: &CompletionConfig,
+    config: &CompletionConfig<'_>,
     FilePosition { file_id, offset }: FilePosition,
     imports: impl IntoIterator<Item = (String, String)>,
 ) -> Option<Vec<TextEdit>> {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
index e01097a9105..3b2d3fbbfc1 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
@@ -61,7 +61,7 @@ fn function() {}
 union Union { field: i32 }
 "#;
 
-pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
+pub(crate) const TEST_CONFIG: CompletionConfig<'_> = CompletionConfig {
     enable_postfix_completions: true,
     enable_imports_on_the_fly: true,
     enable_self_on_the_fly: true,
@@ -85,6 +85,8 @@ pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
     snippets: Vec::new(),
     limit: None,
     fields_to_resolve: CompletionFieldsToResolve::empty(),
+    exclude_flyimport_traits: &[],
+    exclude_traits: &[],
 };
 
 pub(crate) fn completion_list(ra_fixture: &str) -> String {
@@ -109,7 +111,7 @@ pub(crate) fn completion_list_with_trigger_character(
 }
 
 fn completion_list_with_config_raw(
-    config: CompletionConfig,
+    config: CompletionConfig<'_>,
     ra_fixture: &str,
     include_keywords: bool,
     trigger_character: Option<char>,
@@ -132,7 +134,7 @@ fn completion_list_with_config_raw(
 }
 
 fn completion_list_with_config(
-    config: CompletionConfig,
+    config: CompletionConfig<'_>,
     ra_fixture: &str,
     include_keywords: bool,
     trigger_character: Option<char>,
@@ -161,7 +163,7 @@ pub(crate) fn do_completion(code: &str, kind: CompletionItemKind) -> Vec<Complet
 }
 
 pub(crate) fn do_completion_with_config(
-    config: CompletionConfig,
+    config: CompletionConfig<'_>,
     code: &str,
     kind: CompletionItemKind,
 ) -> Vec<CompletionItem> {
@@ -220,7 +222,7 @@ pub(crate) fn check_edit(what: &str, ra_fixture_before: &str, ra_fixture_after:
 
 #[track_caller]
 pub(crate) fn check_edit_with_config(
-    config: CompletionConfig,
+    config: CompletionConfig<'_>,
     what: &str,
     ra_fixture_before: &str,
     ra_fixture_after: &str,
@@ -257,7 +259,7 @@ fn check_empty(ra_fixture: &str, expect: Expect) {
 }
 
 pub(crate) fn get_all_items(
-    config: CompletionConfig,
+    config: CompletionConfig<'_>,
     code: &str,
     trigger_character: Option<char>,
 ) -> Vec<CompletionItem> {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index ea1b7ad7871..6c95980507c 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -1,13 +1,29 @@
 //! Completion tests for expressions.
 use expect_test::{expect, Expect};
 
-use crate::tests::{check_edit, check_empty, completion_list, BASE_ITEMS_FIXTURE};
+use crate::{
+    tests::{
+        check_edit, check_empty, completion_list, completion_list_with_config, BASE_ITEMS_FIXTURE,
+        TEST_CONFIG,
+    },
+    CompletionConfig,
+};
 
 fn check(ra_fixture: &str, expect: Expect) {
     let actual = completion_list(&format!("{BASE_ITEMS_FIXTURE}{ra_fixture}"));
     expect.assert_eq(&actual)
 }
 
+fn check_with_config(config: CompletionConfig<'_>, ra_fixture: &str, expect: Expect) {
+    let actual = completion_list_with_config(
+        config,
+        &format!("{BASE_ITEMS_FIXTURE}{ra_fixture}"),
+        true,
+        None,
+    );
+    expect.assert_eq(&actual)
+}
+
 #[test]
 fn complete_literal_struct_with_a_private_field() {
     // `FooDesc.bar` is private, the completion should not be triggered.
@@ -1390,3 +1406,366 @@ fn main() {
         "#]],
     );
 }
+
+#[test]
+fn excluded_trait_method_is_excluded() {
+    check_with_config(
+        CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
+        r#"
+trait ExcludedTrait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+    fn baz(&self) {}
+}
+
+impl<T> ExcludedTrait for T {}
+
+struct Foo;
+impl Foo {
+    fn inherent(&self) {}
+}
+
+fn foo() {
+    Foo.$0
+}
+        "#,
+        expect![[r#"
+            me inherent() fn(&self)
+            sn box        Box::new(expr)
+            sn call       function(expr)
+            sn dbg        dbg!(expr)
+            sn dbgr       dbg!(&expr)
+            sn deref      *expr
+            sn let        let
+            sn letm       let mut
+            sn match      match expr {}
+            sn ref        &expr
+            sn refm       &mut expr
+            sn return     return expr
+            sn unsafe     unsafe {}
+        "#]],
+    );
+}
+
+#[test]
+fn excluded_trait_not_excluded_when_inherent() {
+    check_with_config(
+        CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
+        r#"
+trait ExcludedTrait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+    fn baz(&self) {}
+}
+
+impl<T> ExcludedTrait for T {}
+
+fn foo(v: &dyn ExcludedTrait) {
+    v.$0
+}
+        "#,
+        expect![[r#"
+            me bar() (as ExcludedTrait) fn(&self)
+            me baz() (as ExcludedTrait) fn(&self)
+            me foo() (as ExcludedTrait) fn(&self)
+            sn box                    Box::new(expr)
+            sn call                   function(expr)
+            sn dbg                    dbg!(expr)
+            sn dbgr                   dbg!(&expr)
+            sn deref                  *expr
+            sn let                    let
+            sn letm                   let mut
+            sn match                  match expr {}
+            sn ref                    &expr
+            sn refm                   &mut expr
+            sn return                 return expr
+            sn unsafe                 unsafe {}
+        "#]],
+    );
+    check_with_config(
+        CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
+        r#"
+trait ExcludedTrait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+    fn baz(&self) {}
+}
+
+impl<T> ExcludedTrait for T {}
+
+fn foo(v: impl ExcludedTrait) {
+    v.$0
+}
+        "#,
+        expect![[r#"
+            me bar() (as ExcludedTrait) fn(&self)
+            me baz() (as ExcludedTrait) fn(&self)
+            me foo() (as ExcludedTrait) fn(&self)
+            sn box                    Box::new(expr)
+            sn call                   function(expr)
+            sn dbg                    dbg!(expr)
+            sn dbgr                   dbg!(&expr)
+            sn deref                  *expr
+            sn let                    let
+            sn letm                   let mut
+            sn match                  match expr {}
+            sn ref                    &expr
+            sn refm                   &mut expr
+            sn return                 return expr
+            sn unsafe                 unsafe {}
+        "#]],
+    );
+    check_with_config(
+        CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
+        r#"
+trait ExcludedTrait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+    fn baz(&self) {}
+}
+
+impl<T> ExcludedTrait for T {}
+
+fn foo<T: ExcludedTrait>(v: T) {
+    v.$0
+}
+        "#,
+        expect![[r#"
+            me bar() (as ExcludedTrait) fn(&self)
+            me baz() (as ExcludedTrait) fn(&self)
+            me foo() (as ExcludedTrait) fn(&self)
+            sn box                    Box::new(expr)
+            sn call                   function(expr)
+            sn dbg                    dbg!(expr)
+            sn dbgr                   dbg!(&expr)
+            sn deref                  *expr
+            sn let                    let
+            sn letm                   let mut
+            sn match                  match expr {}
+            sn ref                    &expr
+            sn refm                   &mut expr
+            sn return                 return expr
+            sn unsafe                 unsafe {}
+        "#]],
+    );
+}
+
+#[test]
+fn excluded_trait_method_is_excluded_from_flyimport() {
+    check_with_config(
+        CompletionConfig {
+            exclude_traits: &["test::module2::ExcludedTrait".to_owned()],
+            ..TEST_CONFIG
+        },
+        r#"
+mod module2 {
+    pub trait ExcludedTrait {
+        fn foo(&self) {}
+        fn bar(&self) {}
+        fn baz(&self) {}
+    }
+
+    impl<T> ExcludedTrait for T {}
+}
+
+struct Foo;
+impl Foo {
+    fn inherent(&self) {}
+}
+
+fn foo() {
+    Foo.$0
+}
+        "#,
+        expect![[r#"
+            me inherent() fn(&self)
+            sn box        Box::new(expr)
+            sn call       function(expr)
+            sn dbg        dbg!(expr)
+            sn dbgr       dbg!(&expr)
+            sn deref      *expr
+            sn let        let
+            sn letm       let mut
+            sn match      match expr {}
+            sn ref        &expr
+            sn refm       &mut expr
+            sn return     return expr
+            sn unsafe     unsafe {}
+        "#]],
+    );
+}
+
+#[test]
+fn flyimport_excluded_trait_method_is_excluded_from_flyimport() {
+    check_with_config(
+        CompletionConfig {
+            exclude_flyimport_traits: &["test::module2::ExcludedTrait".to_owned()],
+            ..TEST_CONFIG
+        },
+        r#"
+mod module2 {
+    pub trait ExcludedTrait {
+        fn foo(&self) {}
+        fn bar(&self) {}
+        fn baz(&self) {}
+    }
+
+    impl<T> ExcludedTrait for T {}
+}
+
+struct Foo;
+impl Foo {
+    fn inherent(&self) {}
+}
+
+fn foo() {
+    Foo.$0
+}
+        "#,
+        expect![[r#"
+            me inherent() fn(&self)
+            sn box        Box::new(expr)
+            sn call       function(expr)
+            sn dbg        dbg!(expr)
+            sn dbgr       dbg!(&expr)
+            sn deref      *expr
+            sn let        let
+            sn letm       let mut
+            sn match      match expr {}
+            sn ref        &expr
+            sn refm       &mut expr
+            sn return     return expr
+            sn unsafe     unsafe {}
+        "#]],
+    );
+}
+
+#[test]
+fn excluded_trait_method_is_excluded_from_path_completion() {
+    check_with_config(
+        CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
+        r#"
+pub trait ExcludedTrait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+    fn baz(&self) {}
+}
+
+impl<T> ExcludedTrait for T {}
+
+struct Foo;
+impl Foo {
+    fn inherent(&self) {}
+}
+
+fn foo() {
+    Foo::$0
+}
+        "#,
+        expect![[r#"
+                me inherent(…) fn(&self)
+            "#]],
+    );
+}
+
+#[test]
+fn excluded_trait_method_is_not_excluded_when_trait_is_specified() {
+    check_with_config(
+        CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
+        r#"
+pub trait ExcludedTrait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+    fn baz(&self) {}
+}
+
+impl<T> ExcludedTrait for T {}
+
+struct Foo;
+impl Foo {
+    fn inherent(&self) {}
+}
+
+fn foo() {
+    ExcludedTrait::$0
+}
+        "#,
+        expect![[r#"
+                me bar(…) (as ExcludedTrait) fn(&self)
+                me baz(…) (as ExcludedTrait) fn(&self)
+                me foo(…) (as ExcludedTrait) fn(&self)
+            "#]],
+    );
+    check_with_config(
+        CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
+        r#"
+pub trait ExcludedTrait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+    fn baz(&self) {}
+}
+
+impl<T> ExcludedTrait for T {}
+
+struct Foo;
+impl Foo {
+    fn inherent(&self) {}
+}
+
+fn foo() {
+    <Foo as ExcludedTrait>::$0
+}
+        "#,
+        expect![[r#"
+                me bar(…) (as ExcludedTrait) fn(&self)
+                me baz(…) (as ExcludedTrait) fn(&self)
+                me foo(…) (as ExcludedTrait) fn(&self)
+            "#]],
+    );
+}
+
+#[test]
+fn excluded_trait_not_excluded_when_inherent_path() {
+    check_with_config(
+        CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
+        r#"
+trait ExcludedTrait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+    fn baz(&self) {}
+}
+
+impl<T> ExcludedTrait for T {}
+
+fn foo() {
+    <dyn ExcludedTrait>::$0
+}
+        "#,
+        expect![[r#"
+            me bar(…) (as ExcludedTrait) fn(&self)
+            me baz(…) (as ExcludedTrait) fn(&self)
+            me foo(…) (as ExcludedTrait) fn(&self)
+        "#]],
+    );
+    check_with_config(
+        CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
+        r#"
+trait ExcludedTrait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+    fn baz(&self) {}
+}
+
+impl<T> ExcludedTrait for T {}
+
+fn foo<T: ExcludedTrait>() {
+    T::$0
+}
+        "#,
+        expect![[r#"
+            me bar(…) (as ExcludedTrait) fn(&self)
+            me baz(…) (as ExcludedTrait) fn(&self)
+            me foo(…) (as ExcludedTrait) fn(&self)
+        "#]],
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
index 388af48c68b..6cfb2231a99 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
@@ -1345,7 +1345,7 @@ struct Foo<T: PartialOrd
 }
 
 fn check_signatures(src: &str, kind: CompletionItemKind, reduced: Expect, full: Expect) {
-    const FULL_SIGNATURES_CONFIG: crate::CompletionConfig = {
+    const FULL_SIGNATURES_CONFIG: crate::CompletionConfig<'_> = {
         let mut x = TEST_CONFIG;
         x.full_function_signatures = true;
         x
diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index 1637d578fdf..22a9ee52079 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -671,7 +671,7 @@ impl Analysis {
     /// Computes completions at the given position.
     pub fn completions(
         &self,
-        config: &CompletionConfig,
+        config: &CompletionConfig<'_>,
         position: FilePosition,
         trigger_character: Option<char>,
     ) -> Cancellable<Option<Vec<CompletionItem>>> {
@@ -683,7 +683,7 @@ impl Analysis {
     /// Resolves additional completion data at the position given.
     pub fn resolve_completion_edits(
         &self,
-        config: &CompletionConfig,
+        config: &CompletionConfig<'_>,
         position: FilePosition,
         imports: impl IntoIterator<Item = (String, String)> + std::panic::UnwindSafe,
     ) -> Cancellable<Vec<TextEdit>> {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index c182952c731..c53ca230409 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -440,11 +440,64 @@ config_data! {
         /// Toggles the additional completions that automatically add imports when completed.
         /// Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
         completion_autoimport_enable: bool       = true,
+        /// A list of full paths to traits to exclude from flyimport.
+        ///
+        /// Traits in this list won't be suggested to be imported by flyimport for their methods. Methods from them won't be available in flyimport completion. They will still be available if in scope.
+        ///
+        /// Note that the trait themselves can still be suggested by flyimport.
+        ///
+        /// This setting also inherits `#rust-analyzer.completion.excludeTraits#`.
+        ///
+        /// This setting defaults to:
+        ///
+        ///  - [`core::borrow::Borrow`](https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html)
+        ///  - [`core::borrow::BorrowMut`](https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html)
+        ///  - [`core::cmp::PartialEq`](https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html)
+        ///  - All operator traits (in [`core::ops`](https://doc.rust-lang.org/nightly/core/ops))
+        ///
+        /// Note that if you override this setting, those traits won't be automatically inserted, so you may want to insert them manually.
+        completion_autoimport_excludeTraits: Vec<String> = vec![
+            "core::borrow::Borrow".to_owned(),
+            "core::borrow::BorrowMut".to_owned(),
+            "core::cmp::PartialEq".to_owned(),
+            "core::ops::Add".to_owned(),
+            "core::ops::AddAssign".to_owned(),
+            "core::ops::BitAnd".to_owned(),
+            "core::ops::BitAndAssign".to_owned(),
+            "core::ops::BitOr".to_owned(),
+            "core::ops::BitOrAssign".to_owned(),
+            "core::ops::BitXor".to_owned(),
+            "core::ops::BitXorAssign".to_owned(),
+            "core::ops::Div".to_owned(),
+            "core::ops::DivAssign".to_owned(),
+            "core::ops::Mul".to_owned(),
+            "core::ops::MulAssign".to_owned(),
+            "core::ops::Rem".to_owned(),
+            "core::ops::RemAssign".to_owned(),
+            "core::ops::Shl".to_owned(),
+            "core::ops::ShlAssign".to_owned(),
+            "core::ops::Shr".to_owned(),
+            "core::ops::ShrAssign".to_owned(),
+            "core::ops::Sub".to_owned(),
+            "core::ops::SubAssign".to_owned(),
+            "core::ops::Neg".to_owned(),
+            "core::ops::Not".to_owned(),
+            "core::ops::Index".to_owned(),
+            "core::ops::IndexMut".to_owned(),
+            "core::ops::Deref".to_owned(),
+            "core::ops::DerefMut".to_owned(),
+        ],
         /// Toggles the additional completions that automatically show method calls and field accesses
         /// with `self` prefixed to them when inside a method.
         completion_autoself_enable: bool        = true,
         /// Whether to add parenthesis and argument snippets when completing function.
         completion_callable_snippets: CallableCompletionDef  = CallableCompletionDef::FillArguments,
+        /// A list of full paths to traits to exclude from completion.
+        ///
+        /// Methods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.
+        ///
+        /// Note that the trait themselves can still be completed.
+        completion_excludeTraits: Vec<String> = Vec::new(),
         /// Whether to show full function/method signatures in completion docs.
         completion_fullFunctionSignatures_enable: bool = false,
         /// Whether to omit deprecated items from autocompletion. By default they are marked as deprecated but not hidden.
@@ -1431,7 +1484,7 @@ impl Config {
         CallHierarchyConfig { exclude_tests: self.references_excludeTests().to_owned() }
     }
 
-    pub fn completion(&self, source_root: Option<SourceRootId>) -> CompletionConfig {
+    pub fn completion(&self, source_root: Option<SourceRootId>) -> CompletionConfig<'_> {
         let client_capability_fields = self.completion_resolve_support_properties();
         CompletionConfig {
             enable_postfix_completions: self.completion_postfix_enable(source_root).to_owned(),
@@ -1462,6 +1515,8 @@ impl Config {
             } else {
                 CompletionFieldsToResolve::from_client_capabilities(&client_capability_fields)
             },
+            exclude_flyimport_traits: self.completion_autoimport_excludeTraits(source_root),
+            exclude_traits: self.completion_excludeTraits(source_root),
         }
     }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs
index 8946c7acb93..bd164fe4408 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs
@@ -174,6 +174,8 @@ fn integrated_completion_benchmark() {
             limit: None,
             add_semicolon_to_unit: true,
             fields_to_resolve: CompletionFieldsToResolve::empty(),
+            exclude_flyimport_traits: &[],
+            exclude_traits: &[],
         };
         let position =
             FilePosition { file_id, offset: TextSize::try_from(completion_offset).unwrap() };
@@ -222,6 +224,8 @@ fn integrated_completion_benchmark() {
             limit: None,
             add_semicolon_to_unit: true,
             fields_to_resolve: CompletionFieldsToResolve::empty(),
+            exclude_flyimport_traits: &[],
+            exclude_traits: &[],
         };
         let position =
             FilePosition { file_id, offset: TextSize::try_from(completion_offset).unwrap() };
@@ -268,6 +272,8 @@ fn integrated_completion_benchmark() {
             limit: None,
             add_semicolon_to_unit: true,
             fields_to_resolve: CompletionFieldsToResolve::empty(),
+            exclude_flyimport_traits: &[],
+            exclude_traits: &[],
         };
         let position =
             FilePosition { file_id, offset: TextSize::try_from(completion_offset).unwrap() };
diff --git a/src/tools/rust-analyzer/docs/user/generated_config.adoc b/src/tools/rust-analyzer/docs/user/generated_config.adoc
index 5056c7d977c..27ade71b331 100644
--- a/src/tools/rust-analyzer/docs/user/generated_config.adoc
+++ b/src/tools/rust-analyzer/docs/user/generated_config.adoc
@@ -285,6 +285,61 @@ In `match` arms it completes a comma instead.
 --
 Toggles the additional completions that automatically add imports when completed.
 Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
+--
+[[rust-analyzer.completion.autoimport.excludeTraits]]rust-analyzer.completion.autoimport.excludeTraits::
++
+--
+Default:
+----
+[
+  "core::borrow::Borrow",
+  "core::borrow::BorrowMut",
+  "core::cmp::PartialEq",
+  "core::ops::Add",
+  "core::ops::AddAssign",
+  "core::ops::BitAnd",
+  "core::ops::BitAndAssign",
+  "core::ops::BitOr",
+  "core::ops::BitOrAssign",
+  "core::ops::BitXor",
+  "core::ops::BitXorAssign",
+  "core::ops::Div",
+  "core::ops::DivAssign",
+  "core::ops::Mul",
+  "core::ops::MulAssign",
+  "core::ops::Rem",
+  "core::ops::RemAssign",
+  "core::ops::Shl",
+  "core::ops::ShlAssign",
+  "core::ops::Shr",
+  "core::ops::ShrAssign",
+  "core::ops::Sub",
+  "core::ops::SubAssign",
+  "core::ops::Neg",
+  "core::ops::Not",
+  "core::ops::Index",
+  "core::ops::IndexMut",
+  "core::ops::Deref",
+  "core::ops::DerefMut"
+]
+----
+A list of full paths to traits to exclude from flyimport.
+
+Traits in this list won't be suggested to be imported by flyimport for their methods. Methods from them won't be available in flyimport completion. They will still be available if in scope.
+
+Note that the trait themselves can still be suggested by flyimport.
+
+This setting also inherits `#rust-analyzer.completion.excludeTraits#`.
+
+This setting defaults to:
+
+ - [`core::borrow::Borrow`](https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html)
+ - [`core::borrow::BorrowMut`](https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html)
+ - [`core::cmp::PartialEq`](https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html)
+ - All operator traits (in [`core::ops`](https://doc.rust-lang.org/nightly/core/ops))
+
+Note that if you override this setting, those traits won't be automatically inserted, so you may want to insert them manually.
+
 --
 [[rust-analyzer.completion.autoself.enable]]rust-analyzer.completion.autoself.enable (default: `true`)::
 +
@@ -297,6 +352,15 @@ with `self` prefixed to them when inside a method.
 --
 Whether to add parenthesis and argument snippets when completing function.
 --
+[[rust-analyzer.completion.excludeTraits]]rust-analyzer.completion.excludeTraits (default: `[]`)::
++
+--
+A list of full paths to traits to exclude from completion.
+
+Methods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.
+
+Note that the trait themselves can still be completed.
+--
 [[rust-analyzer.completion.fullFunctionSignatures.enable]]rust-analyzer.completion.fullFunctionSignatures.enable (default: `false`)::
 +
 --
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index b9249e9ac8b..a6e92838a06 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -1139,6 +1139,49 @@
                     }
                 }
             },
+            {
+                "title": "completion",
+                "properties": {
+                    "rust-analyzer.completion.autoimport.excludeTraits": {
+                        "markdownDescription": "A list of full paths to traits to exclude from flyimport.\n\nTraits in this list won't be suggested to be imported by flyimport for their methods. Methods from them won't be available in flyimport completion. They will still be available if in scope.\n\nNote that the trait themselves can still be suggested by flyimport.\n\nThis setting also inherits `#rust-analyzer.completion.excludeTraits#`.\n\nThis setting defaults to:\n\n - [`core::borrow::Borrow`](https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html)\n - [`core::borrow::BorrowMut`](https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html)\n - [`core::cmp::PartialEq`](https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html)\n - All operator traits (in [`core::ops`](https://doc.rust-lang.org/nightly/core/ops))\n\nNote that if you override this setting, those traits won't be automatically inserted, so you may want to insert them manually.",
+                        "default": [
+                            "core::borrow::Borrow",
+                            "core::borrow::BorrowMut",
+                            "core::cmp::PartialEq",
+                            "core::ops::Add",
+                            "core::ops::AddAssign",
+                            "core::ops::BitAnd",
+                            "core::ops::BitAndAssign",
+                            "core::ops::BitOr",
+                            "core::ops::BitOrAssign",
+                            "core::ops::BitXor",
+                            "core::ops::BitXorAssign",
+                            "core::ops::Div",
+                            "core::ops::DivAssign",
+                            "core::ops::Mul",
+                            "core::ops::MulAssign",
+                            "core::ops::Rem",
+                            "core::ops::RemAssign",
+                            "core::ops::Shl",
+                            "core::ops::ShlAssign",
+                            "core::ops::Shr",
+                            "core::ops::ShrAssign",
+                            "core::ops::Sub",
+                            "core::ops::SubAssign",
+                            "core::ops::Neg",
+                            "core::ops::Not",
+                            "core::ops::Index",
+                            "core::ops::IndexMut",
+                            "core::ops::Deref",
+                            "core::ops::DerefMut"
+                        ],
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        }
+                    }
+                }
+            },
             {
                 "title": "completion",
                 "properties": {
@@ -1169,6 +1212,19 @@
                     }
                 }
             },
+            {
+                "title": "completion",
+                "properties": {
+                    "rust-analyzer.completion.excludeTraits": {
+                        "markdownDescription": "A list of full paths to traits to exclude from completion.\n\nMethods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.\n\nNote that the trait themselves can still be completed.",
+                        "default": [],
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        }
+                    }
+                }
+            },
             {
                 "title": "completion",
                 "properties": {
-- 
cgit 1.4.1-3-g733a5


From 13af22df98c790875d0a31f49c19cfd84e14d424 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Wed, 1 Jan 2025 14:09:05 +0100
Subject: Reduce the default autoimport exclusion list

---
 .../rust-analyzer/crates/hir-def/src/item_scope.rs |   7 -
 .../crates/ide-completion/src/tests/expression.rs  | 154 +++++++++++----------
 .../crates/rust-analyzer/src/config.rs             |  41 +-----
 .../rust-analyzer/docs/user/generated_config.adoc  |  43 +-----
 src/tools/rust-analyzer/editors/code/package.json  |  31 +----
 5 files changed, 90 insertions(+), 186 deletions(-)

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
index f600efea9f2..2c3eb5c8e5e 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
@@ -354,13 +354,6 @@ impl ItemScope {
             .chain(self.unnamed_trait_imports.keys().copied())
     }
 
-    pub fn trait_by_name(&self, name: &Name) -> Option<TraitId> {
-        self.types.get(name).and_then(|def| match def.def {
-            ModuleDefId::TraitId(it) => Some(it),
-            _ => None,
-        })
-    }
-
     pub(crate) fn resolutions(&self) -> impl Iterator<Item = (Option<Name>, PerNs)> + '_ {
         self.entries().map(|(name, res)| (Some(name.clone()), res)).chain(
             self.unnamed_trait_imports.iter().map(|(tr, trait_)| {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index 6c95980507c..d1bbf1e8d0b 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -1430,19 +1430,22 @@ fn foo() {
 }
         "#,
         expect![[r#"
-            me inherent() fn(&self)
-            sn box        Box::new(expr)
-            sn call       function(expr)
-            sn dbg        dbg!(expr)
-            sn dbgr       dbg!(&expr)
-            sn deref      *expr
-            sn let        let
-            sn letm       let mut
-            sn match      match expr {}
-            sn ref        &expr
-            sn refm       &mut expr
-            sn return     return expr
-            sn unsafe     unsafe {}
+            me bar() (as ExcludedTrait) fn(&self)
+            me baz() (as ExcludedTrait) fn(&self)
+            me foo() (as ExcludedTrait) fn(&self)
+            me inherent()               fn(&self)
+            sn box                 Box::new(expr)
+            sn call                function(expr)
+            sn dbg                     dbg!(expr)
+            sn dbgr                   dbg!(&expr)
+            sn deref                        *expr
+            sn let                            let
+            sn letm                       let mut
+            sn match                match expr {}
+            sn ref                          &expr
+            sn refm                     &mut expr
+            sn return                 return expr
+            sn unsafe                   unsafe {}
         "#]],
     );
 }
@@ -1468,18 +1471,18 @@ fn foo(v: &dyn ExcludedTrait) {
             me bar() (as ExcludedTrait) fn(&self)
             me baz() (as ExcludedTrait) fn(&self)
             me foo() (as ExcludedTrait) fn(&self)
-            sn box                    Box::new(expr)
-            sn call                   function(expr)
-            sn dbg                    dbg!(expr)
+            sn box                 Box::new(expr)
+            sn call                function(expr)
+            sn dbg                     dbg!(expr)
             sn dbgr                   dbg!(&expr)
-            sn deref                  *expr
-            sn let                    let
-            sn letm                   let mut
-            sn match                  match expr {}
-            sn ref                    &expr
-            sn refm                   &mut expr
+            sn deref                        *expr
+            sn let                            let
+            sn letm                       let mut
+            sn match                match expr {}
+            sn ref                          &expr
+            sn refm                     &mut expr
             sn return                 return expr
-            sn unsafe                 unsafe {}
+            sn unsafe                   unsafe {}
         "#]],
     );
     check_with_config(
@@ -1501,18 +1504,18 @@ fn foo(v: impl ExcludedTrait) {
             me bar() (as ExcludedTrait) fn(&self)
             me baz() (as ExcludedTrait) fn(&self)
             me foo() (as ExcludedTrait) fn(&self)
-            sn box                    Box::new(expr)
-            sn call                   function(expr)
-            sn dbg                    dbg!(expr)
+            sn box                 Box::new(expr)
+            sn call                function(expr)
+            sn dbg                     dbg!(expr)
             sn dbgr                   dbg!(&expr)
-            sn deref                  *expr
-            sn let                    let
-            sn letm                   let mut
-            sn match                  match expr {}
-            sn ref                    &expr
-            sn refm                   &mut expr
+            sn deref                        *expr
+            sn let                            let
+            sn letm                       let mut
+            sn match                match expr {}
+            sn ref                          &expr
+            sn refm                     &mut expr
             sn return                 return expr
-            sn unsafe                 unsafe {}
+            sn unsafe                   unsafe {}
         "#]],
     );
     check_with_config(
@@ -1534,18 +1537,18 @@ fn foo<T: ExcludedTrait>(v: T) {
             me bar() (as ExcludedTrait) fn(&self)
             me baz() (as ExcludedTrait) fn(&self)
             me foo() (as ExcludedTrait) fn(&self)
-            sn box                    Box::new(expr)
-            sn call                   function(expr)
-            sn dbg                    dbg!(expr)
+            sn box                 Box::new(expr)
+            sn call                function(expr)
+            sn dbg                     dbg!(expr)
             sn dbgr                   dbg!(&expr)
-            sn deref                  *expr
-            sn let                    let
-            sn letm                   let mut
-            sn match                  match expr {}
-            sn ref                    &expr
-            sn refm                   &mut expr
+            sn deref                        *expr
+            sn let                            let
+            sn letm                       let mut
+            sn match                match expr {}
+            sn ref                          &expr
+            sn refm                     &mut expr
             sn return                 return expr
-            sn unsafe                 unsafe {}
+            sn unsafe                   unsafe {}
         "#]],
     );
 }
@@ -1578,19 +1581,22 @@ fn foo() {
 }
         "#,
         expect![[r#"
-            me inherent() fn(&self)
-            sn box        Box::new(expr)
-            sn call       function(expr)
-            sn dbg        dbg!(expr)
-            sn dbgr       dbg!(&expr)
-            sn deref      *expr
-            sn let        let
-            sn letm       let mut
-            sn match      match expr {}
-            sn ref        &expr
-            sn refm       &mut expr
-            sn return     return expr
-            sn unsafe     unsafe {}
+            me bar() (use module2::ExcludedTrait) fn(&self)
+            me baz() (use module2::ExcludedTrait) fn(&self)
+            me foo() (use module2::ExcludedTrait) fn(&self)
+            me inherent()                         fn(&self)
+            sn box                           Box::new(expr)
+            sn call                          function(expr)
+            sn dbg                               dbg!(expr)
+            sn dbgr                             dbg!(&expr)
+            sn deref                                  *expr
+            sn let                                      let
+            sn letm                                 let mut
+            sn match                          match expr {}
+            sn ref                                    &expr
+            sn refm                               &mut expr
+            sn return                           return expr
+            sn unsafe                             unsafe {}
         "#]],
     );
 }
@@ -1623,19 +1629,22 @@ fn foo() {
 }
         "#,
         expect![[r#"
-            me inherent() fn(&self)
-            sn box        Box::new(expr)
-            sn call       function(expr)
-            sn dbg        dbg!(expr)
-            sn dbgr       dbg!(&expr)
-            sn deref      *expr
-            sn let        let
-            sn letm       let mut
-            sn match      match expr {}
-            sn ref        &expr
-            sn refm       &mut expr
-            sn return     return expr
-            sn unsafe     unsafe {}
+            me bar() (use module2::ExcludedTrait) fn(&self)
+            me baz() (use module2::ExcludedTrait) fn(&self)
+            me foo() (use module2::ExcludedTrait) fn(&self)
+            me inherent()                         fn(&self)
+            sn box                           Box::new(expr)
+            sn call                          function(expr)
+            sn dbg                               dbg!(expr)
+            sn dbgr                             dbg!(&expr)
+            sn deref                                  *expr
+            sn let                                      let
+            sn letm                                 let mut
+            sn match                          match expr {}
+            sn ref                                    &expr
+            sn refm                               &mut expr
+            sn return                           return expr
+            sn unsafe                             unsafe {}
         "#]],
     );
 }
@@ -1663,8 +1672,11 @@ fn foo() {
 }
         "#,
         expect![[r#"
-                me inherent(…) fn(&self)
-            "#]],
+            me bar(…) (as ExcludedTrait) fn(&self)
+            me baz(…) (as ExcludedTrait) fn(&self)
+            me foo(…) (as ExcludedTrait) fn(&self)
+            me inherent(…)               fn(&self)
+        "#]],
     );
 }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index c53ca230409..b6678c12c70 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -442,50 +442,13 @@ config_data! {
         completion_autoimport_enable: bool       = true,
         /// A list of full paths to traits to exclude from flyimport.
         ///
-        /// Traits in this list won't be suggested to be imported by flyimport for their methods. Methods from them won't be available in flyimport completion. They will still be available if in scope.
-        ///
-        /// Note that the trait themselves can still be suggested by flyimport.
+        /// Traits in this list won't have their methods suggested in completions unless the trait
+        /// is in scope.
         ///
         /// This setting also inherits `#rust-analyzer.completion.excludeTraits#`.
-        ///
-        /// This setting defaults to:
-        ///
-        ///  - [`core::borrow::Borrow`](https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html)
-        ///  - [`core::borrow::BorrowMut`](https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html)
-        ///  - [`core::cmp::PartialEq`](https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html)
-        ///  - All operator traits (in [`core::ops`](https://doc.rust-lang.org/nightly/core/ops))
-        ///
-        /// Note that if you override this setting, those traits won't be automatically inserted, so you may want to insert them manually.
         completion_autoimport_excludeTraits: Vec<String> = vec![
             "core::borrow::Borrow".to_owned(),
             "core::borrow::BorrowMut".to_owned(),
-            "core::cmp::PartialEq".to_owned(),
-            "core::ops::Add".to_owned(),
-            "core::ops::AddAssign".to_owned(),
-            "core::ops::BitAnd".to_owned(),
-            "core::ops::BitAndAssign".to_owned(),
-            "core::ops::BitOr".to_owned(),
-            "core::ops::BitOrAssign".to_owned(),
-            "core::ops::BitXor".to_owned(),
-            "core::ops::BitXorAssign".to_owned(),
-            "core::ops::Div".to_owned(),
-            "core::ops::DivAssign".to_owned(),
-            "core::ops::Mul".to_owned(),
-            "core::ops::MulAssign".to_owned(),
-            "core::ops::Rem".to_owned(),
-            "core::ops::RemAssign".to_owned(),
-            "core::ops::Shl".to_owned(),
-            "core::ops::ShlAssign".to_owned(),
-            "core::ops::Shr".to_owned(),
-            "core::ops::ShrAssign".to_owned(),
-            "core::ops::Sub".to_owned(),
-            "core::ops::SubAssign".to_owned(),
-            "core::ops::Neg".to_owned(),
-            "core::ops::Not".to_owned(),
-            "core::ops::Index".to_owned(),
-            "core::ops::IndexMut".to_owned(),
-            "core::ops::Deref".to_owned(),
-            "core::ops::DerefMut".to_owned(),
         ],
         /// Toggles the additional completions that automatically show method calls and field accesses
         /// with `self` prefixed to them when inside a method.
diff --git a/src/tools/rust-analyzer/docs/user/generated_config.adoc b/src/tools/rust-analyzer/docs/user/generated_config.adoc
index 27ade71b331..bce26f7dd74 100644
--- a/src/tools/rust-analyzer/docs/user/generated_config.adoc
+++ b/src/tools/rust-analyzer/docs/user/generated_config.adoc
@@ -293,53 +293,16 @@ Default:
 ----
 [
   "core::borrow::Borrow",
-  "core::borrow::BorrowMut",
-  "core::cmp::PartialEq",
-  "core::ops::Add",
-  "core::ops::AddAssign",
-  "core::ops::BitAnd",
-  "core::ops::BitAndAssign",
-  "core::ops::BitOr",
-  "core::ops::BitOrAssign",
-  "core::ops::BitXor",
-  "core::ops::BitXorAssign",
-  "core::ops::Div",
-  "core::ops::DivAssign",
-  "core::ops::Mul",
-  "core::ops::MulAssign",
-  "core::ops::Rem",
-  "core::ops::RemAssign",
-  "core::ops::Shl",
-  "core::ops::ShlAssign",
-  "core::ops::Shr",
-  "core::ops::ShrAssign",
-  "core::ops::Sub",
-  "core::ops::SubAssign",
-  "core::ops::Neg",
-  "core::ops::Not",
-  "core::ops::Index",
-  "core::ops::IndexMut",
-  "core::ops::Deref",
-  "core::ops::DerefMut"
+  "core::borrow::BorrowMut"
 ]
 ----
 A list of full paths to traits to exclude from flyimport.
 
-Traits in this list won't be suggested to be imported by flyimport for their methods. Methods from them won't be available in flyimport completion. They will still be available if in scope.
-
-Note that the trait themselves can still be suggested by flyimport.
+Traits in this list won't have their methods suggested in completions unless the trait
+is in scope.
 
 This setting also inherits `#rust-analyzer.completion.excludeTraits#`.
 
-This setting defaults to:
-
- - [`core::borrow::Borrow`](https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html)
- - [`core::borrow::BorrowMut`](https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html)
- - [`core::cmp::PartialEq`](https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html)
- - All operator traits (in [`core::ops`](https://doc.rust-lang.org/nightly/core/ops))
-
-Note that if you override this setting, those traits won't be automatically inserted, so you may want to insert them manually.
-
 --
 [[rust-analyzer.completion.autoself.enable]]rust-analyzer.completion.autoself.enable (default: `true`)::
 +
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index a6e92838a06..31419a1942d 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -1143,37 +1143,10 @@
                 "title": "completion",
                 "properties": {
                     "rust-analyzer.completion.autoimport.excludeTraits": {
-                        "markdownDescription": "A list of full paths to traits to exclude from flyimport.\n\nTraits in this list won't be suggested to be imported by flyimport for their methods. Methods from them won't be available in flyimport completion. They will still be available if in scope.\n\nNote that the trait themselves can still be suggested by flyimport.\n\nThis setting also inherits `#rust-analyzer.completion.excludeTraits#`.\n\nThis setting defaults to:\n\n - [`core::borrow::Borrow`](https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html)\n - [`core::borrow::BorrowMut`](https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html)\n - [`core::cmp::PartialEq`](https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html)\n - All operator traits (in [`core::ops`](https://doc.rust-lang.org/nightly/core/ops))\n\nNote that if you override this setting, those traits won't be automatically inserted, so you may want to insert them manually.",
+                        "markdownDescription": "A list of full paths to traits to exclude from flyimport.\n\nTraits in this list won't have their methods suggested in completions unless the trait\nis in scope.\n\nThis setting also inherits `#rust-analyzer.completion.excludeTraits#`.",
                         "default": [
                             "core::borrow::Borrow",
-                            "core::borrow::BorrowMut",
-                            "core::cmp::PartialEq",
-                            "core::ops::Add",
-                            "core::ops::AddAssign",
-                            "core::ops::BitAnd",
-                            "core::ops::BitAndAssign",
-                            "core::ops::BitOr",
-                            "core::ops::BitOrAssign",
-                            "core::ops::BitXor",
-                            "core::ops::BitXorAssign",
-                            "core::ops::Div",
-                            "core::ops::DivAssign",
-                            "core::ops::Mul",
-                            "core::ops::MulAssign",
-                            "core::ops::Rem",
-                            "core::ops::RemAssign",
-                            "core::ops::Shl",
-                            "core::ops::ShlAssign",
-                            "core::ops::Shr",
-                            "core::ops::ShrAssign",
-                            "core::ops::Sub",
-                            "core::ops::SubAssign",
-                            "core::ops::Neg",
-                            "core::ops::Not",
-                            "core::ops::Index",
-                            "core::ops::IndexMut",
-                            "core::ops::Deref",
-                            "core::ops::DerefMut"
+                            "core::borrow::BorrowMut"
                         ],
                         "type": "array",
                         "items": {
-- 
cgit 1.4.1-3-g733a5


From c84d09a7c37711533311f99397189de148a79a58 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Wed, 1 Jan 2025 15:05:24 +0100
Subject: Revamp auto-import exclude config

---
 .../ide-completion/src/completions/flyimport.rs    | 42 ++++++------
 .../crates/ide-completion/src/config.rs            |  8 ++-
 .../crates/ide-completion/src/context.rs           | 19 +++---
 .../rust-analyzer/crates/ide-completion/src/lib.rs |  2 +-
 .../crates/ide-completion/src/tests.rs             |  2 +-
 .../crates/ide-completion/src/tests/expression.rs  |  6 +-
 .../crates/rust-analyzer/src/config.rs             | 77 ++++++++++++++++++++--
 .../rust-analyzer/src/integrated_benchmarks.rs     |  6 +-
 .../rust-analyzer/docs/user/generated_config.adoc  | 21 ++++--
 src/tools/rust-analyzer/editors/code/package.json  | 41 ++++++++++--
 10 files changed, 169 insertions(+), 55 deletions(-)

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs
index afa94affb3b..3b2b2fd706e 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs
@@ -8,6 +8,7 @@ use itertools::Itertools;
 use syntax::{ast, AstNode, SyntaxNode, ToSmolStr, T};
 
 use crate::{
+    config::AutoImportExclusionType,
     context::{
         CompletionContext, DotAccess, PathCompletionCtx, PathKind, PatternContext, Qualified,
         TypeLocation,
@@ -258,8 +259,6 @@ fn import_on_the_fly(
 
     let import_cfg = ctx.config.import_path_config();
 
-    let completed_name = ctx.token.to_string();
-
     import_assets
         .search_for_imports(&ctx.sema, import_cfg, ctx.config.insert_use.prefix_kind)
         .filter(ns_filter)
@@ -270,19 +269,17 @@ fn import_on_the_fly(
                 && ctx.check_stability(original_item.attrs(ctx.db).as_deref())
         })
         .filter(|import| {
-            if let ModuleDef::Trait(trait_) = import.item_to_import.into_module_def() {
-                let excluded = ctx.exclude_flyimport_traits.contains(&trait_);
-                let trait_itself_imported = import.item_to_import == import.original_item;
-                if !excluded || trait_itself_imported {
-                    return true;
+            let def = import.item_to_import.into_module_def();
+            if let Some(&kind) = ctx.exclude_flyimport.get(&def) {
+                if kind == AutoImportExclusionType::Always {
+                    return false;
+                }
+                let method_imported = import.item_to_import != import.original_item;
+                if method_imported {
+                    return false;
                 }
-
-                let item = import.original_item.into_module_def();
-                // Filter that item out, unless its name matches the name the user wrote exactly - in which case preserve it.
-                item.name(ctx.db).is_some_and(|name| name.eq_ident(&completed_name))
-            } else {
-                true
             }
+            true
         })
         .sorted_by(|a, b| {
             let key = |import_path| {
@@ -363,8 +360,6 @@ fn import_on_the_fly_method(
 
     let cfg = ctx.config.import_path_config();
 
-    let completed_name = ctx.token.to_string();
-
     import_assets
         .search_for_imports(&ctx.sema, cfg, ctx.config.insert_use.prefix_kind)
         .filter(|import| {
@@ -372,14 +367,19 @@ fn import_on_the_fly_method(
                 && !ctx.is_item_hidden(&import.original_item)
         })
         .filter(|import| {
-            if let ModuleDef::Trait(trait_) = import.item_to_import.into_module_def() {
-                if !ctx.exclude_flyimport_traits.contains(&trait_) {
-                    return true;
+            let def = import.item_to_import.into_module_def();
+            if let Some(&kind) = ctx.exclude_flyimport.get(&def) {
+                if kind == AutoImportExclusionType::Always {
+                    return false;
                 }
+                let method_imported = import.item_to_import != import.original_item;
+                if method_imported {
+                    return false;
+                }
+            }
 
-                let item = import.original_item.into_module_def();
-                // Filter that method out, unless its name matches the name the user wrote exactly - in which case preserve it.
-                item.name(ctx.db).is_some_and(|name| name.eq_ident(&completed_name))
+            if let ModuleDef::Trait(_) = import.item_to_import.into_module_def() {
+                !ctx.exclude_flyimport.contains_key(&def)
             } else {
                 true
             }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/config.rs b/src/tools/rust-analyzer/crates/ide-completion/src/config.rs
index ed36fe8d028..8b1ce11e8a4 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/config.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/config.rs
@@ -28,10 +28,16 @@ pub struct CompletionConfig<'a> {
     pub snippets: Vec<Snippet>,
     pub limit: Option<usize>,
     pub fields_to_resolve: CompletionFieldsToResolve,
-    pub exclude_flyimport_traits: &'a [String],
+    pub exclude_flyimport: Vec<(String, AutoImportExclusionType)>,
     pub exclude_traits: &'a [String],
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum AutoImportExclusionType {
+    Always,
+    Methods,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum CallableSnippets {
     FillArguments,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
index c4365284251..183490c2ed8 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
@@ -22,6 +22,7 @@ use syntax::{
 };
 
 use crate::{
+    config::AutoImportExclusionType,
     context::analysis::{expand_and_analyze, AnalysisResult},
     CompletionConfig,
 };
@@ -466,7 +467,7 @@ pub(crate) struct CompletionContext<'a> {
     /// importing those traits.
     ///
     /// Note the trait *themselves* are not excluded, only their methods are.
-    pub(crate) exclude_flyimport_traits: FxHashSet<hir::Trait>,
+    pub(crate) exclude_flyimport: FxHashMap<ModuleDef, AutoImportExclusionType>,
     /// Traits whose methods should always be excluded, even when in scope (compare `exclude_flyimport_traits`).
     /// They will *not* be excluded, however, if they are available as a generic bound.
     ///
@@ -780,22 +781,20 @@ impl<'a> CompletionContext<'a> {
             })
             .collect();
 
-        let mut exclude_flyimport_traits: FxHashSet<_> = config
-            .exclude_flyimport_traits
+        let mut exclude_flyimport: FxHashMap<_, _> = config
+            .exclude_flyimport
             .iter()
-            .filter_map(|path| {
+            .flat_map(|(path, kind)| {
                 scope
                     .resolve_mod_path(&ModPath::from_segments(
                         hir::PathKind::Plain,
                         path.split("::").map(Symbol::intern).map(Name::new_symbol_root),
                     ))
-                    .find_map(|it| match it {
-                        hir::ItemInNs::Types(ModuleDef::Trait(t)) => Some(t),
-                        _ => None,
-                    })
+                    .map(|it| (it.into_module_def(), *kind))
             })
             .collect();
-        exclude_flyimport_traits.extend(exclude_traits.iter().copied());
+        exclude_flyimport
+            .extend(exclude_traits.iter().map(|&t| (t.into(), AutoImportExclusionType::Always)));
 
         let complete_semicolon = if config.add_semicolon_to_unit {
             let inside_closure_ret = token.parent_ancestors().try_for_each(|ancestor| {
@@ -861,7 +860,7 @@ impl<'a> CompletionContext<'a> {
             qualifier_ctx,
             locals,
             depth_from_crate_root,
-            exclude_flyimport_traits,
+            exclude_flyimport,
             exclude_traits,
             complete_semicolon,
         };
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs b/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
index 05563bc912d..ca6c9ad9f08 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
@@ -31,7 +31,7 @@ use crate::{
 };
 
 pub use crate::{
-    config::{CallableSnippets, CompletionConfig},
+    config::{AutoImportExclusionType, CallableSnippets, CompletionConfig},
     item::{
         CompletionItem, CompletionItemKind, CompletionRelevance, CompletionRelevancePostfixMatch,
         CompletionRelevanceReturnType, CompletionRelevanceTypeMatch,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
index 3b2d3fbbfc1..1815f340532 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
@@ -85,7 +85,7 @@ pub(crate) const TEST_CONFIG: CompletionConfig<'_> = CompletionConfig {
     snippets: Vec::new(),
     limit: None,
     fields_to_resolve: CompletionFieldsToResolve::empty(),
-    exclude_flyimport_traits: &[],
+    exclude_flyimport: vec![],
     exclude_traits: &[],
 };
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index d1bbf1e8d0b..a9db1d95318 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -2,6 +2,7 @@
 use expect_test::{expect, Expect};
 
 use crate::{
+    config::AutoImportExclusionType,
     tests::{
         check_edit, check_empty, completion_list, completion_list_with_config, BASE_ITEMS_FIXTURE,
         TEST_CONFIG,
@@ -1605,7 +1606,10 @@ fn foo() {
 fn flyimport_excluded_trait_method_is_excluded_from_flyimport() {
     check_with_config(
         CompletionConfig {
-            exclude_flyimport_traits: &["test::module2::ExcludedTrait".to_owned()],
+            exclude_flyimport: vec![(
+                "test::module2::ExcludedTrait".to_owned(),
+                AutoImportExclusionType::Methods,
+            )],
             ..TEST_CONFIG
         },
         r#"
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index b6678c12c70..b7297d0c02a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -440,22 +440,27 @@ config_data! {
         /// Toggles the additional completions that automatically add imports when completed.
         /// Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
         completion_autoimport_enable: bool       = true,
-        /// A list of full paths to traits to exclude from flyimport.
+        /// A list of full paths to items to exclude from auto-importing completions.
         ///
         /// Traits in this list won't have their methods suggested in completions unless the trait
         /// is in scope.
         ///
+        /// You can either specify a string path which defaults to type "always" or use the more verbose
+        /// form `{ "path": "path::to::item", type: "always" }`.
+        ///
+        /// For traits the type "methods" can be used to only exclude the methods but not the trait itself.
+        ///
         /// This setting also inherits `#rust-analyzer.completion.excludeTraits#`.
-        completion_autoimport_excludeTraits: Vec<String> = vec![
-            "core::borrow::Borrow".to_owned(),
-            "core::borrow::BorrowMut".to_owned(),
+        completion_autoimport_exclude: Vec<AutoImportExclusion> = vec![
+            AutoImportExclusion::Verbose { path: "core::borrow::Borrow".to_owned(), r#type: AutoImportExclusionType::Methods },
+            AutoImportExclusion::Verbose { path: "core::borrow::BorrowMut".to_owned(), r#type: AutoImportExclusionType::Methods },
         ],
         /// Toggles the additional completions that automatically show method calls and field accesses
         /// with `self` prefixed to them when inside a method.
         completion_autoself_enable: bool        = true,
         /// Whether to add parenthesis and argument snippets when completing function.
         completion_callable_snippets: CallableCompletionDef  = CallableCompletionDef::FillArguments,
-        /// A list of full paths to traits to exclude from completion.
+        /// A list of full paths to traits whose methods to exclude from completion.
         ///
         /// Methods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.
         ///
@@ -1478,7 +1483,26 @@ impl Config {
             } else {
                 CompletionFieldsToResolve::from_client_capabilities(&client_capability_fields)
             },
-            exclude_flyimport_traits: self.completion_autoimport_excludeTraits(source_root),
+            exclude_flyimport: self
+                .completion_autoimport_exclude(source_root)
+                .iter()
+                .map(|it| match it {
+                    AutoImportExclusion::Path(path) => {
+                        (path.clone(), ide_completion::AutoImportExclusionType::Always)
+                    }
+                    AutoImportExclusion::Verbose { path, r#type } => (
+                        path.clone(),
+                        match r#type {
+                            AutoImportExclusionType::Always => {
+                                ide_completion::AutoImportExclusionType::Always
+                            }
+                            AutoImportExclusionType::Methods => {
+                                ide_completion::AutoImportExclusionType::Methods
+                            }
+                        },
+                    ),
+                })
+                .collect(),
             exclude_traits: self.completion_excludeTraits(source_root),
         }
     }
@@ -2419,6 +2443,21 @@ enum ExprFillDefaultDef {
     Default,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+#[serde(rename_all = "snake_case")]
+pub enum AutoImportExclusion {
+    Path(String),
+    Verbose { path: String, r#type: AutoImportExclusionType },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum AutoImportExclusionType {
+    Always,
+    Methods,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "snake_case")]
 enum ImportGranularityDef {
@@ -3490,6 +3529,32 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json
                 }
             ]
         },
+        "Vec<AutoImportExclusion>" => set! {
+            "type": "array",
+            "items": {
+                "anyOf": [
+                    {
+                        "type": "string",
+                    },
+                    {
+                        "type": "object",
+                        "properties": {
+                            "path": {
+                                "type": "string",
+                            },
+                            "type": {
+                                "type": "string",
+                                "enum": ["always", "methods"],
+                                "enumDescriptions": [
+                                    "Do not show this item or its methods (if it is a trait) in auto-import completions.",
+                                    "Do not show this traits methods in auto-import completions."
+                                ],
+                            },
+                        }
+                    }
+                ]
+             }
+        },
         _ => panic!("missing entry for {ty}: {default} (field {field})"),
     }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs
index bd164fe4408..fcfd06679bf 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs
@@ -174,7 +174,7 @@ fn integrated_completion_benchmark() {
             limit: None,
             add_semicolon_to_unit: true,
             fields_to_resolve: CompletionFieldsToResolve::empty(),
-            exclude_flyimport_traits: &[],
+            exclude_flyimport: vec![],
             exclude_traits: &[],
         };
         let position =
@@ -224,7 +224,7 @@ fn integrated_completion_benchmark() {
             limit: None,
             add_semicolon_to_unit: true,
             fields_to_resolve: CompletionFieldsToResolve::empty(),
-            exclude_flyimport_traits: &[],
+            exclude_flyimport: vec![],
             exclude_traits: &[],
         };
         let position =
@@ -272,7 +272,7 @@ fn integrated_completion_benchmark() {
             limit: None,
             add_semicolon_to_unit: true,
             fields_to_resolve: CompletionFieldsToResolve::empty(),
-            exclude_flyimport_traits: &[],
+            exclude_flyimport: vec![],
             exclude_traits: &[],
         };
         let position =
diff --git a/src/tools/rust-analyzer/docs/user/generated_config.adoc b/src/tools/rust-analyzer/docs/user/generated_config.adoc
index bce26f7dd74..a44f5a12b28 100644
--- a/src/tools/rust-analyzer/docs/user/generated_config.adoc
+++ b/src/tools/rust-analyzer/docs/user/generated_config.adoc
@@ -286,21 +286,32 @@ In `match` arms it completes a comma instead.
 Toggles the additional completions that automatically add imports when completed.
 Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
 --
-[[rust-analyzer.completion.autoimport.excludeTraits]]rust-analyzer.completion.autoimport.excludeTraits::
+[[rust-analyzer.completion.autoimport.exclude]]rust-analyzer.completion.autoimport.exclude::
 +
 --
 Default:
 ----
 [
-  "core::borrow::Borrow",
-  "core::borrow::BorrowMut"
+  {
+    "path": "core::borrow::Borrow",
+    "type": "methods"
+  },
+  {
+    "path": "core::borrow::BorrowMut",
+    "type": "methods"
+  }
 ]
 ----
-A list of full paths to traits to exclude from flyimport.
+A list of full paths to items to exclude from auto-importing completions.
 
 Traits in this list won't have their methods suggested in completions unless the trait
 is in scope.
 
+You can either specify a string path which defaults to type "always" or use the more verbose
+form `{ "path": "path::to::item", type: "always" }`.
+
+For traits the type "methods" can be used to only exclude the methods but not the trait itself.
+
 This setting also inherits `#rust-analyzer.completion.excludeTraits#`.
 
 --
@@ -318,7 +329,7 @@ Whether to add parenthesis and argument snippets when completing function.
 [[rust-analyzer.completion.excludeTraits]]rust-analyzer.completion.excludeTraits (default: `[]`)::
 +
 --
-A list of full paths to traits to exclude from completion.
+A list of full paths to traits whose methods to exclude from completion.
 
 Methods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.
 
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 31419a1942d..03c00a37fb1 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -1142,15 +1142,44 @@
             {
                 "title": "completion",
                 "properties": {
-                    "rust-analyzer.completion.autoimport.excludeTraits": {
-                        "markdownDescription": "A list of full paths to traits to exclude from flyimport.\n\nTraits in this list won't have their methods suggested in completions unless the trait\nis in scope.\n\nThis setting also inherits `#rust-analyzer.completion.excludeTraits#`.",
+                    "rust-analyzer.completion.autoimport.exclude": {
+                        "markdownDescription": "A list of full paths to items to exclude from auto-importing completions.\n\nTraits in this list won't have their methods suggested in completions unless the trait\nis in scope.\n\nYou can either specify a string path which defaults to type \"always\" or use the more verbose\nform `{ \"path\": \"path::to::item\", type: \"always\" }`.\n\nFor traits the type \"methods\" can be used to only exclude the methods but not the trait itself.\n\nThis setting also inherits `#rust-analyzer.completion.excludeTraits#`.",
                         "default": [
-                            "core::borrow::Borrow",
-                            "core::borrow::BorrowMut"
+                            {
+                                "path": "core::borrow::Borrow",
+                                "type": "methods"
+                            },
+                            {
+                                "path": "core::borrow::BorrowMut",
+                                "type": "methods"
+                            }
                         ],
                         "type": "array",
                         "items": {
-                            "type": "string"
+                            "anyOf": [
+                                {
+                                    "type": "string"
+                                },
+                                {
+                                    "type": "object",
+                                    "properties": {
+                                        "path": {
+                                            "type": "string"
+                                        },
+                                        "type": {
+                                            "type": "string",
+                                            "enum": [
+                                                "always",
+                                                "methods"
+                                            ],
+                                            "enumDescriptions": [
+                                                "Do not show this item or its methods (if it is a trait) in auto-import completions.",
+                                                "Do not show this traits methods in auto-import completions."
+                                            ]
+                                        }
+                                    }
+                                }
+                            ]
                         }
                     }
                 }
@@ -1189,7 +1218,7 @@
                 "title": "completion",
                 "properties": {
                     "rust-analyzer.completion.excludeTraits": {
-                        "markdownDescription": "A list of full paths to traits to exclude from completion.\n\nMethods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.\n\nNote that the trait themselves can still be completed.",
+                        "markdownDescription": "A list of full paths to traits whose methods to exclude from completion.\n\nMethods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.\n\nNote that the trait themselves can still be completed.",
                         "default": [],
                         "type": "array",
                         "items": {
-- 
cgit 1.4.1-3-g733a5


From 764ce49445d3d2f67a2a229b7dc23d514c651c73 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 29 Dec 2024 15:24:52 +0100
Subject: Remove `rust-analyzer.cargo.sysrootQueryMetadata` config again

---
 .../crates/project-model/src/cargo_workspace.rs    |   4 +-
 .../rust-analyzer/crates/project-model/src/lib.rs  |  14 +-
 .../crates/project-model/src/sysroot.rs            | 209 +++++++++------------
 .../crates/project-model/src/tests.rs              |  16 +-
 .../crates/project-model/src/workspace.rs          |  83 ++++----
 .../crates/rust-analyzer/src/cli/analysis_stats.rs |  11 +-
 .../crates/rust-analyzer/src/cli/flags.rs          |   4 -
 .../crates/rust-analyzer/src/cli/rustc_tests.rs    |   9 +-
 .../crates/rust-analyzer/src/config.rs             |  33 +---
 .../crates/rust-analyzer/tests/slow-tests/main.rs  |   4 +-
 .../rust-analyzer/docs/user/generated_config.adoc  |   6 -
 src/tools/rust-analyzer/editors/code/package.json  |  18 --
 12 files changed, 159 insertions(+), 252 deletions(-)

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
index c125c141cd7..4d906c2aeb3 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
@@ -15,7 +15,7 @@ use span::Edition;
 use toolchain::Tool;
 
 use crate::{CfgOverrides, InvocationStrategy};
-use crate::{ManifestPath, Sysroot, SysrootQueryMetadata};
+use crate::{ManifestPath, Sysroot};
 
 /// [`CargoWorkspace`] represents the logical structure of, well, a Cargo
 /// workspace. It pretty closely mirrors `cargo metadata` output.
@@ -89,8 +89,6 @@ pub struct CargoConfig {
     pub target: Option<String>,
     /// Sysroot loading behavior
     pub sysroot: Option<RustLibSource>,
-    /// How to query metadata for the sysroot crate.
-    pub sysroot_query_metadata: SysrootQueryMetadata,
     pub sysroot_src: Option<AbsPathBuf>,
     /// rustc private crate source
     pub rustc_source: Option<RustLibSource>,
diff --git a/src/tools/rust-analyzer/crates/project-model/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/src/lib.rs
index 1913db11fa9..f5405438253 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/lib.rs
@@ -259,13 +259,19 @@ fn parse_cfg(s: &str) -> Result<cfg::CfgAtom, String> {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum SysrootQueryMetadata {
+pub enum SysrootSourceWorkspaceConfig {
     CargoMetadata(CargoMetadataConfig),
-    None,
+    Stitched,
 }
 
-impl Default for SysrootQueryMetadata {
+impl Default for SysrootSourceWorkspaceConfig {
     fn default() -> Self {
-        SysrootQueryMetadata::CargoMetadata(Default::default())
+        SysrootSourceWorkspaceConfig::default_cargo()
+    }
+}
+
+impl SysrootSourceWorkspaceConfig {
+    pub fn default_cargo() -> Self {
+        SysrootSourceWorkspaceConfig::CargoMetadata(Default::default())
     }
 }
diff --git a/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs b/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs
index 9d3dc37c583..8f633d24be9 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs
@@ -4,7 +4,12 @@
 //! but we can't process `.rlib` and need source code instead. The source code
 //! is typically installed with `rustup component add rust-src` command.
 
-use std::{env, fs, ops, path::Path, process::Command};
+use std::{
+    env, fs,
+    ops::{self, Not},
+    path::Path,
+    process::Command,
+};
 
 use anyhow::{format_err, Result};
 use base_db::CrateName;
@@ -12,23 +17,24 @@ use itertools::Itertools;
 use la_arena::{Arena, Idx};
 use paths::{AbsPath, AbsPathBuf, Utf8PathBuf};
 use rustc_hash::FxHashMap;
+use stdx::format_to;
 use toolchain::{probe_for_binary, Tool};
 
 use crate::{
     cargo_workspace::CargoMetadataConfig, utf8_stdout, CargoWorkspace, ManifestPath,
-    SysrootQueryMetadata,
+    SysrootSourceWorkspaceConfig,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Sysroot {
     root: Option<AbsPathBuf>,
     src_root: Option<AbsPathBuf>,
-    mode: SysrootMode,
+    workspace: SysrootWorkspace,
     error: Option<String>,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub(crate) enum SysrootMode {
+pub(crate) enum SysrootWorkspace {
     Workspace(CargoWorkspace),
     Stitched(Stitched),
     Empty,
@@ -82,7 +88,7 @@ pub(crate) struct SysrootCrateData {
 
 impl Sysroot {
     pub const fn empty() -> Sysroot {
-        Sysroot { root: None, src_root: None, mode: SysrootMode::Empty, error: None }
+        Sysroot { root: None, src_root: None, workspace: SysrootWorkspace::Empty, error: None }
     }
 
     /// Returns sysroot "root" directory, where `bin/`, `etc/`, `lib/`, `libexec/`
@@ -99,10 +105,10 @@ impl Sysroot {
     }
 
     pub fn is_empty(&self) -> bool {
-        match &self.mode {
-            SysrootMode::Workspace(ws) => ws.packages().next().is_none(),
-            SysrootMode::Stitched(stitched) => stitched.crates.is_empty(),
-            SysrootMode::Empty => true,
+        match &self.workspace {
+            SysrootWorkspace::Workspace(ws) => ws.packages().next().is_none(),
+            SysrootWorkspace::Stitched(stitched) => stitched.crates.is_empty(),
+            SysrootWorkspace::Empty => true,
         }
     }
 
@@ -111,64 +117,51 @@ impl Sysroot {
     }
 
     pub fn num_packages(&self) -> usize {
-        match &self.mode {
-            SysrootMode::Workspace(ws) => ws.packages().count(),
-            SysrootMode::Stitched(c) => c.crates().count(),
-            SysrootMode::Empty => 0,
+        match &self.workspace {
+            SysrootWorkspace::Workspace(ws) => ws.packages().count(),
+            SysrootWorkspace::Stitched(c) => c.crates().count(),
+            SysrootWorkspace::Empty => 0,
         }
     }
 
-    pub(crate) fn mode(&self) -> &SysrootMode {
-        &self.mode
+    pub(crate) fn workspace(&self) -> &SysrootWorkspace {
+        &self.workspace
     }
 }
 
-// FIXME: Expose a builder api as loading the sysroot got way too modular and complicated.
 impl Sysroot {
     /// Attempts to discover the toolchain's sysroot from the given `dir`.
-    pub fn discover(
-        dir: &AbsPath,
-        extra_env: &FxHashMap<String, String>,
-        sysroot_query_metadata: &SysrootQueryMetadata,
-    ) -> Sysroot {
+    pub fn discover(dir: &AbsPath, extra_env: &FxHashMap<String, String>) -> Sysroot {
         let sysroot_dir = discover_sysroot_dir(dir, extra_env);
         let sysroot_src_dir = sysroot_dir.as_ref().ok().map(|sysroot_dir| {
             discover_sysroot_src_dir_or_add_component(sysroot_dir, dir, extra_env)
         });
-        Sysroot::load_core_check(Some(sysroot_dir), sysroot_src_dir, sysroot_query_metadata)
+        Sysroot::assemble(Some(sysroot_dir), sysroot_src_dir)
     }
 
     pub fn discover_with_src_override(
         current_dir: &AbsPath,
         extra_env: &FxHashMap<String, String>,
         sysroot_src_dir: AbsPathBuf,
-        sysroot_query_metadata: &SysrootQueryMetadata,
     ) -> Sysroot {
         let sysroot_dir = discover_sysroot_dir(current_dir, extra_env);
-        Sysroot::load_core_check(
-            Some(sysroot_dir),
-            Some(Ok(sysroot_src_dir)),
-            sysroot_query_metadata,
-        )
+        Sysroot::assemble(Some(sysroot_dir), Some(Ok(sysroot_src_dir)))
     }
 
-    pub fn discover_sysroot_src_dir(
-        sysroot_dir: AbsPathBuf,
-        sysroot_query_metadata: &SysrootQueryMetadata,
-    ) -> Sysroot {
+    pub fn discover_sysroot_src_dir(sysroot_dir: AbsPathBuf) -> Sysroot {
         let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir)
             .ok_or_else(|| format_err!("can't find standard library sources in {sysroot_dir}"));
-        Sysroot::load_core_check(
-            Some(Ok(sysroot_dir)),
-            Some(sysroot_src_dir),
-            sysroot_query_metadata,
-        )
+        Sysroot::assemble(Some(Ok(sysroot_dir)), Some(sysroot_src_dir))
     }
 
     pub fn discover_rustc_src(&self) -> Option<ManifestPath> {
         get_rustc_src(self.root()?)
     }
 
+    pub fn new(sysroot_dir: Option<AbsPathBuf>, sysroot_src_dir: Option<AbsPathBuf>) -> Sysroot {
+        Self::assemble(sysroot_dir.map(Ok), sysroot_src_dir.map(Ok))
+    }
+
     /// Returns a command to run a tool preferring the cargo proxies if the sysroot exists.
     pub fn tool(&self, tool: Tool, current_dir: impl AsRef<Path>) -> Command {
         match self.root() {
@@ -205,93 +198,51 @@ impl Sysroot {
             })
     }
 
-    pub fn load(
-        sysroot_dir: Option<AbsPathBuf>,
-        sysroot_src_dir: Option<AbsPathBuf>,
-        sysroot_query_metadata: &SysrootQueryMetadata,
-    ) -> Sysroot {
-        Self::load_core_check(sysroot_dir.map(Ok), sysroot_src_dir.map(Ok), sysroot_query_metadata)
-    }
-
-    fn load_core_check(
-        sysroot_dir: Option<Result<AbsPathBuf, anyhow::Error>>,
-        sysroot_src_dir: Option<Result<AbsPathBuf, anyhow::Error>>,
-        sysroot_query_metadata: &SysrootQueryMetadata,
-    ) -> Sysroot {
-        let mut sysroot = Self::load_(sysroot_dir, sysroot_src_dir, sysroot_query_metadata);
-        if sysroot.error.is_none() {
-            if let Some(src_root) = &sysroot.src_root {
-                let has_core = match &sysroot.mode {
-                    SysrootMode::Workspace(ws) => ws.packages().any(|p| ws[p].name == "core"),
-                    SysrootMode::Stitched(stitched) => stitched.by_name("core").is_some(),
-                    SysrootMode::Empty => true,
-                };
-                if !has_core {
-                    let var_note = if env::var_os("RUST_SRC_PATH").is_some() {
-                        " (env var `RUST_SRC_PATH` is set and may be incorrect, try unsetting it)"
-                    } else {
-                        ", try running `rustup component add rust-src` to possibly fix this"
-                    };
-                    sysroot.error = Some(format!(
-                        "sysroot at `{src_root}` is missing a `core` library{var_note}",
-                    ));
-                }
-            }
-        }
-        sysroot
-    }
-
-    fn load_(
+    fn assemble(
         sysroot_dir: Option<Result<AbsPathBuf, anyhow::Error>>,
         sysroot_src_dir: Option<Result<AbsPathBuf, anyhow::Error>>,
-        sysroot_query_metadata: &SysrootQueryMetadata,
     ) -> Sysroot {
-        let sysroot_dir = match sysroot_dir {
+        let mut errors = String::new();
+        let root = match sysroot_dir {
             Some(Ok(sysroot_dir)) => Some(sysroot_dir),
             Some(Err(e)) => {
-                return Sysroot {
-                    root: None,
-                    src_root: None,
-                    mode: SysrootMode::Empty,
-                    error: Some(e.to_string()),
-                }
+                format_to!(errors, "{e}\n");
+                None
             }
             None => None,
         };
-        let sysroot_src_dir = match sysroot_src_dir {
-            Some(Ok(sysroot_src_dir)) => sysroot_src_dir,
+        let src_root = match sysroot_src_dir {
+            Some(Ok(sysroot_src_dir)) => Some(sysroot_src_dir),
             Some(Err(e)) => {
-                return Sysroot {
-                    root: sysroot_dir,
-                    src_root: None,
-                    mode: SysrootMode::Empty,
-                    error: Some(e.to_string()),
-                }
-            }
-            None => {
-                return Sysroot {
-                    root: sysroot_dir,
-                    src_root: None,
-                    mode: SysrootMode::Empty,
-                    error: None,
-                }
+                format_to!(errors, "{e}\n");
+                None
             }
+            None => None,
         };
-        if let SysrootQueryMetadata::CargoMetadata(cargo_config) = sysroot_query_metadata {
-            let library_manifest =
-                ManifestPath::try_from(sysroot_src_dir.join("Cargo.toml")).unwrap();
+        Sysroot {
+            root,
+            src_root,
+            workspace: SysrootWorkspace::Empty,
+            error: errors.is_empty().not().then_some(errors),
+        }
+    }
+
+    pub fn load_workspace(&mut self, sysroot_source_config: &SysrootSourceWorkspaceConfig) {
+        assert!(matches!(self.workspace, SysrootWorkspace::Empty), "workspace already loaded");
+        let Self { root: _, src_root: Some(src_root), workspace, error: _ } = self else { return };
+        if let SysrootSourceWorkspaceConfig::CargoMetadata(cargo_config) = sysroot_source_config {
+            let library_manifest = ManifestPath::try_from(src_root.join("Cargo.toml")).unwrap();
             if fs::metadata(&library_manifest).is_ok() {
-                if let Some(sysroot) = Self::load_library_via_cargo(
-                    library_manifest,
-                    &sysroot_dir,
-                    &sysroot_src_dir,
-                    cargo_config,
-                ) {
-                    return sysroot;
+                if let Some(loaded) =
+                    Self::load_library_via_cargo(library_manifest, src_root, cargo_config)
+                {
+                    *workspace = loaded;
+                    self.load_core_check();
+                    return;
                 }
             }
         }
-        tracing::debug!("Stitching sysroot library: {sysroot_src_dir}");
+        tracing::debug!("Stitching sysroot library: {src_root}");
 
         let mut stitched = Stitched { crates: Arena::default() };
 
@@ -299,7 +250,7 @@ impl Sysroot {
             let name = path.split('/').last().unwrap();
             let root = [format!("{path}/src/lib.rs"), format!("lib{path}/lib.rs")]
                 .into_iter()
-                .map(|it| sysroot_src_dir.join(it))
+                .map(|it| src_root.join(it))
                 .filter_map(|it| ManifestPath::try_from(it).ok())
                 .find(|it| fs::metadata(it).is_ok());
 
@@ -335,20 +286,37 @@ impl Sysroot {
                 }
             }
         }
-        Sysroot {
-            root: sysroot_dir,
-            src_root: Some(sysroot_src_dir),
-            mode: SysrootMode::Stitched(stitched),
-            error: None,
+        *workspace = SysrootWorkspace::Stitched(stitched);
+        self.load_core_check();
+    }
+
+    fn load_core_check(&mut self) {
+        if self.error.is_none() {
+            if let Some(src_root) = &self.src_root {
+                let has_core = match &self.workspace {
+                    SysrootWorkspace::Workspace(ws) => ws.packages().any(|p| ws[p].name == "core"),
+                    SysrootWorkspace::Stitched(stitched) => stitched.by_name("core").is_some(),
+                    SysrootWorkspace::Empty => true,
+                };
+                if !has_core {
+                    let var_note = if env::var_os("RUST_SRC_PATH").is_some() {
+                        " (env var `RUST_SRC_PATH` is set and may be incorrect, try unsetting it)"
+                    } else {
+                        ", try running `rustup component add rust-src` to possibly fix this"
+                    };
+                    self.error = Some(format!(
+                        "sysroot at `{src_root}` is missing a `core` library{var_note}",
+                    ));
+                }
+            }
         }
     }
 
     fn load_library_via_cargo(
         library_manifest: ManifestPath,
-        sysroot_dir: &Option<AbsPathBuf>,
         sysroot_src_dir: &AbsPathBuf,
         cargo_config: &CargoMetadataConfig,
-    ) -> Option<Sysroot> {
+    ) -> Option<SysrootWorkspace> {
         tracing::debug!("Loading library metadata: {library_manifest}");
         let mut cargo_config = cargo_config.clone();
         // the sysroot uses `public-dependency`, so we make cargo think it's a nightly
@@ -423,12 +391,7 @@ impl Sysroot {
         });
 
         let cargo_workspace = CargoWorkspace::new(res, library_manifest, Default::default());
-        Some(Sysroot {
-            root: sysroot_dir.clone(),
-            src_root: Some(sysroot_src_dir.clone()),
-            mode: SysrootMode::Workspace(cargo_workspace),
-            error: None,
-        })
+        Some(SysrootWorkspace::Workspace(cargo_workspace))
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/project-model/src/tests.rs b/src/tools/rust-analyzer/crates/project-model/src/tests.rs
index 8bb130433a1..681bce3a5a6 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/tests.rs
@@ -12,9 +12,9 @@ use span::FileId;
 use triomphe::Arc;
 
 use crate::{
-    sysroot::SysrootMode, workspace::ProjectWorkspaceKind, CargoWorkspace, CfgOverrides,
-    ManifestPath, ProjectJson, ProjectJsonData, ProjectWorkspace, Sysroot, SysrootQueryMetadata,
-    WorkspaceBuildScripts,
+    sysroot::SysrootWorkspace, workspace::ProjectWorkspaceKind, CargoWorkspace, CfgOverrides,
+    ManifestPath, ProjectJson, ProjectJsonData, ProjectWorkspace, Sysroot,
+    SysrootSourceWorkspaceConfig, WorkspaceBuildScripts,
 };
 
 fn load_cargo(file: &str) -> (CrateGraph, ProcMacroPaths) {
@@ -122,7 +122,9 @@ fn get_fake_sysroot() -> Sysroot {
     // fake sysroot, so we give them both the same path:
     let sysroot_dir = AbsPathBuf::assert(sysroot_path);
     let sysroot_src_dir = sysroot_dir.clone();
-    Sysroot::load(Some(sysroot_dir), Some(sysroot_src_dir), &SysrootQueryMetadata::default())
+    let mut sysroot = Sysroot::new(Some(sysroot_dir), Some(sysroot_src_dir));
+    sysroot.load_workspace(&SysrootSourceWorkspaceConfig::default_cargo());
+    sysroot
 }
 
 fn rooted_project_json(data: ProjectJsonData) -> ProjectJson {
@@ -263,12 +265,12 @@ fn smoke_test_real_sysroot_cargo() {
     let manifest_path =
         ManifestPath::try_from(AbsPathBuf::try_from(meta.workspace_root.clone()).unwrap()).unwrap();
     let cargo_workspace = CargoWorkspace::new(meta, manifest_path, Default::default());
-    let sysroot = Sysroot::discover(
+    let mut sysroot = Sysroot::discover(
         AbsPath::assert(Utf8Path::new(env!("CARGO_MANIFEST_DIR"))),
         &Default::default(),
-        &SysrootQueryMetadata::default(),
     );
-    assert!(matches!(sysroot.mode(), SysrootMode::Workspace(_)));
+    sysroot.load_workspace(&SysrootSourceWorkspaceConfig::default_cargo());
+    assert!(matches!(sysroot.workspace(), SysrootWorkspace::Workspace(_)));
     let project_workspace = ProjectWorkspace {
         kind: ProjectWorkspaceKind::Cargo {
             cargo: cargo_workspace,
diff --git a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
index 5a9d8483c85..6dc8e2fa5d8 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
@@ -25,10 +25,11 @@ use crate::{
     cargo_workspace::{CargoMetadataConfig, DepKind, PackageData, RustLibSource},
     env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env},
     project_json::{Crate, CrateArrayIdx},
-    sysroot::{SysrootCrate, SysrootMode},
+    sysroot::{SysrootCrate, SysrootWorkspace},
     toolchain_info::{rustc_cfg, target_data_layout, target_triple, QueryConfig},
     utf8_stdout, CargoConfig, CargoWorkspace, CfgOverrides, InvocationStrategy, ManifestPath,
-    Package, ProjectJson, ProjectManifest, Sysroot, TargetData, TargetKind, WorkspaceBuildScripts,
+    Package, ProjectJson, ProjectManifest, Sysroot, SysrootSourceWorkspaceConfig, TargetData,
+    TargetKind, WorkspaceBuildScripts,
 };
 use tracing::{debug, error, info};
 
@@ -213,34 +214,26 @@ impl ProjectWorkspace {
         config: &CargoConfig,
         progress: &dyn Fn(String),
     ) -> Result<ProjectWorkspace, anyhow::Error> {
-        // FIXME: Split sysroot discovery from sysroot loading, as to load the sysroot we
-        // want to pass the analysis target, but to discover the target we need to know the
-        // sysroot location so we know which cargo to use
-        let sysroot = match (&config.sysroot, &config.sysroot_src) {
-            (Some(RustLibSource::Discover), None) => Sysroot::discover(
-                cargo_toml.parent(),
-                &config.extra_env,
-                &config.sysroot_query_metadata,
-            ),
+        let mut sysroot = match (&config.sysroot, &config.sysroot_src) {
+            (Some(RustLibSource::Discover), None) => {
+                Sysroot::discover(cargo_toml.parent(), &config.extra_env)
+            }
             (Some(RustLibSource::Discover), Some(sysroot_src)) => {
                 Sysroot::discover_with_src_override(
                     cargo_toml.parent(),
                     &config.extra_env,
                     sysroot_src.clone(),
-                    &config.sysroot_query_metadata,
                 )
             }
             (Some(RustLibSource::Path(path)), None) => {
-                Sysroot::discover_sysroot_src_dir(path.clone(), &config.sysroot_query_metadata)
+                Sysroot::discover_sysroot_src_dir(path.clone())
+            }
+            (Some(RustLibSource::Path(sysroot)), Some(sysroot_src)) => {
+                Sysroot::new(Some(sysroot.clone()), Some(sysroot_src.clone()))
             }
-            (Some(RustLibSource::Path(sysroot)), Some(sysroot_src)) => Sysroot::load(
-                Some(sysroot.clone()),
-                Some(sysroot_src.clone()),
-                &config.sysroot_query_metadata,
-            ),
             (None, _) => Sysroot::empty(),
         };
-        tracing::info!(workspace = %cargo_toml, src_root = ?sysroot.src_root(), root = ?sysroot.root(), "Using sysroot");
+
         let rustc_dir = match &config.rustc_source {
             Some(RustLibSource::Path(path)) => ManifestPath::try_from(path.clone())
                 .map_err(|p| Some(format!("rustc source path is not absolute: {p}"))),
@@ -255,6 +248,10 @@ impl ProjectWorkspace {
             &config.extra_env,
         )
         .unwrap_or_default();
+        sysroot.load_workspace(&SysrootSourceWorkspaceConfig::CargoMetadata(
+            sysroot_metadata_config(&config.extra_env, &targets),
+        ));
+        tracing::info!(workspace = %cargo_toml, src_root = ?sysroot.src_root(), root = ?sysroot.root(), "Using sysroot");
         let rustc = rustc_dir.and_then(|rustc_dir| {
             info!(workspace = %cargo_toml, rustc_dir = %rustc_dir, "Using rustc source");
             match CargoWorkspace::fetch_metadata(
@@ -349,11 +346,9 @@ impl ProjectWorkspace {
     }
 
     pub fn load_inline(project_json: ProjectJson, config: &CargoConfig) -> ProjectWorkspace {
-        let sysroot = Sysroot::load(
-            project_json.sysroot.clone(),
-            project_json.sysroot_src.clone(),
-            &config.sysroot_query_metadata,
-        );
+        let mut sysroot =
+            Sysroot::new(project_json.sysroot.clone(), project_json.sysroot_src.clone());
+        sysroot.load_workspace(&SysrootSourceWorkspaceConfig::Stitched);
         let query_config = QueryConfig::Rustc(&sysroot, project_json.path().as_ref());
         let toolchain = match get_toolchain_version(
             project_json.path(),
@@ -387,13 +382,9 @@ impl ProjectWorkspace {
         config: &CargoConfig,
     ) -> anyhow::Result<ProjectWorkspace> {
         let dir = detached_file.parent();
-        let sysroot = match &config.sysroot {
-            Some(RustLibSource::Path(path)) => {
-                Sysroot::discover_sysroot_src_dir(path.clone(), &config.sysroot_query_metadata)
-            }
-            Some(RustLibSource::Discover) => {
-                Sysroot::discover(dir, &config.extra_env, &config.sysroot_query_metadata)
-            }
+        let mut sysroot = match &config.sysroot {
+            Some(RustLibSource::Path(path)) => Sysroot::discover_sysroot_src_dir(path.clone()),
+            Some(RustLibSource::Discover) => Sysroot::discover(dir, &config.extra_env),
             None => Sysroot::empty(),
         };
 
@@ -412,6 +403,10 @@ impl ProjectWorkspace {
             &config.extra_env,
         )
         .unwrap_or_default();
+
+        sysroot.load_workspace(&SysrootSourceWorkspaceConfig::CargoMetadata(
+            sysroot_metadata_config(&config.extra_env, &targets),
+        ));
         let query_config = QueryConfig::Rustc(&sysroot, dir.as_ref());
         let rustc_cfg = rustc_cfg::get(query_config, None, &config.extra_env);
         let data_layout = target_data_layout::get(query_config, None, &config.extra_env);
@@ -570,8 +565,8 @@ impl ProjectWorkspace {
     /// the root is a member of the current workspace
     pub fn to_roots(&self) -> Vec<PackageRoot> {
         let mk_sysroot = || {
-            let mut r = match self.sysroot.mode() {
-                SysrootMode::Workspace(ws) => ws
+            let mut r = match self.sysroot.workspace() {
+                SysrootWorkspace::Workspace(ws) => ws
                     .packages()
                     .filter_map(|pkg| {
                         if ws[pkg].is_local {
@@ -592,7 +587,7 @@ impl ProjectWorkspace {
                         Some(PackageRoot { is_local: false, include, exclude })
                     })
                     .collect(),
-                SysrootMode::Stitched(_) | SysrootMode::Empty => vec![],
+                SysrootWorkspace::Stitched(_) | SysrootWorkspace::Empty => vec![],
             };
 
             r.push(PackageRoot {
@@ -1416,8 +1411,8 @@ fn sysroot_to_crate_graph(
     load: FileLoader<'_>,
 ) -> (SysrootPublicDeps, Option<CrateId>) {
     let _p = tracing::info_span!("sysroot_to_crate_graph").entered();
-    match sysroot.mode() {
-        SysrootMode::Workspace(cargo) => {
+    match sysroot.workspace() {
+        SysrootWorkspace::Workspace(cargo) => {
             let (mut cg, mut pm) = cargo_to_crate_graph(
                 load,
                 None,
@@ -1492,7 +1487,7 @@ fn sysroot_to_crate_graph(
 
             (SysrootPublicDeps { deps: pub_deps }, libproc_macro)
         }
-        SysrootMode::Stitched(stitched) => {
+        SysrootWorkspace::Stitched(stitched) => {
             let cfg_options = Arc::new({
                 let mut cfg_options = CfgOptions::default();
                 cfg_options.extend(rustc_cfg);
@@ -1545,7 +1540,7 @@ fn sysroot_to_crate_graph(
                 stitched.proc_macro().and_then(|it| sysroot_crates.get(&it).copied());
             (public_deps, libproc_macro)
         }
-        SysrootMode::Empty => (SysrootPublicDeps { deps: vec![] }, None),
+        SysrootWorkspace::Empty => (SysrootPublicDeps { deps: vec![] }, None),
     }
 }
 
@@ -1580,3 +1575,15 @@ fn add_dep_inner(graph: &mut CrateGraph, from: CrateId, dep: Dependency) {
         tracing::warn!("{}", err)
     }
 }
+
+fn sysroot_metadata_config(
+    extra_env: &FxHashMap<String, String>,
+    targets: &[String],
+) -> CargoMetadataConfig {
+    CargoMetadataConfig {
+        features: Default::default(),
+        targets: targets.to_vec(),
+        extra_args: Default::default(),
+        extra_env: extra_env.clone(),
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 9b428871c40..afe3455b780 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -33,10 +33,7 @@ use itertools::Itertools;
 use load_cargo::{load_workspace, LoadCargoConfig, ProcMacroServerChoice};
 use oorandom::Rand32;
 use profile::{Bytes, StopWatch};
-use project_model::{
-    CargoConfig, CargoMetadataConfig, CfgOverrides, ProjectManifest, ProjectWorkspace,
-    RustLibSource,
-};
+use project_model::{CargoConfig, CfgOverrides, ProjectManifest, ProjectWorkspace, RustLibSource};
 use rayon::prelude::*;
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{AstNode, SyntaxNode};
@@ -69,12 +66,6 @@ impl flags::AnalysisStats {
                 true => None,
                 false => Some(RustLibSource::Discover),
             },
-            sysroot_query_metadata: match self.no_query_sysroot_metadata {
-                true => project_model::SysrootQueryMetadata::None,
-                false => project_model::SysrootQueryMetadata::CargoMetadata(
-                    CargoMetadataConfig::default(),
-                ),
-            },
             all_targets: true,
             set_test: !self.no_test,
             cfg_overrides: CfgOverrides {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
index 920a2a37efb..ff24602144a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
@@ -71,9 +71,6 @@ xflags::xflags! {
             optional --with-deps
             /// Don't load sysroot crates (`std`, `core` & friends).
             optional --no-sysroot
-            /// Don't run cargo metadata on the sysroot to analyze its third-party dependencies.
-            /// Requires --no-sysroot to not be set.
-            optional --no-query-sysroot-metadata
             /// Don't set #[cfg(test)].
             optional --no-test
 
@@ -238,7 +235,6 @@ pub struct AnalysisStats {
     pub only: Option<String>,
     pub with_deps: bool,
     pub no_sysroot: bool,
-    pub no_query_sysroot_metadata: bool,
     pub no_test: bool,
     pub disable_build_scripts: bool,
     pub disable_proc_macros: bool,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs
index a4be277da6d..6b0ce4db7c9 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs
@@ -13,7 +13,7 @@ use profile::StopWatch;
 use project_model::toolchain_info::{target_data_layout, QueryConfig};
 use project_model::{
     CargoConfig, ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, RustLibSource, Sysroot,
-    SysrootQueryMetadata,
+    SysrootSourceWorkspaceConfig,
 };
 
 use load_cargo::{load_workspace, LoadCargoConfig, ProcMacroServerChoice};
@@ -74,11 +74,8 @@ impl Tester {
             ..Default::default()
         };
 
-        let sysroot = Sysroot::discover(
-            tmp_file.parent().unwrap(),
-            &cargo_config.extra_env,
-            &SysrootQueryMetadata::CargoMetadata(Default::default()),
-        );
+        let mut sysroot = Sysroot::discover(tmp_file.parent().unwrap(), &cargo_config.extra_env);
+        sysroot.load_workspace(&SysrootSourceWorkspaceConfig::default_cargo());
         let data_layout = target_data_layout::get(
             QueryConfig::Rustc(&sysroot, tmp_file.parent().unwrap().as_ref()),
             None,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index 64ce1248353..67e0a208e8c 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -21,8 +21,8 @@ use ide_db::{
 use itertools::Itertools;
 use paths::{Utf8Path, Utf8PathBuf};
 use project_model::{
-    CargoConfig, CargoFeatures, CargoMetadataConfig, ProjectJson, ProjectJsonData,
-    ProjectJsonFromCommand, ProjectManifest, RustLibSource,
+    CargoConfig, CargoFeatures, ProjectJson, ProjectJsonData, ProjectJsonFromCommand,
+    ProjectManifest, RustLibSource,
 };
 use rustc_hash::{FxHashMap, FxHashSet};
 use semver::Version;
@@ -595,9 +595,6 @@ config_data! {
         ///
         /// This option does not take effect until rust-analyzer is restarted.
         cargo_sysroot: Option<String>    = Some("discover".to_owned()),
-        /// How to query metadata for the sysroot crate. Using cargo metadata allows rust-analyzer
-        /// to analyze third-party dependencies of the standard libraries.
-        cargo_sysrootQueryMetadata: SysrootQueryMetadata = SysrootQueryMetadata::CargoMetadata,
         /// Relative path to the sysroot library sources. If left unset, this will default to
         /// `{cargo.sysroot}/lib/rustlib/src/rust/library`.
         ///
@@ -1941,17 +1938,6 @@ impl Config {
             },
             target: self.cargo_target(source_root).clone(),
             sysroot,
-            sysroot_query_metadata: match self.cargo_sysrootQueryMetadata(None) {
-                SysrootQueryMetadata::CargoMetadata => {
-                    project_model::SysrootQueryMetadata::CargoMetadata(CargoMetadataConfig {
-                        features: Default::default(),
-                        targets: self.cargo_target(source_root).clone().into_iter().collect(),
-                        extra_args: Default::default(),
-                        extra_env: Default::default(),
-                    })
-                }
-                SysrootQueryMetadata::None => project_model::SysrootQueryMetadata::None,
-            },
             sysroot_src,
             rustc_source,
             cfg_overrides: project_model::CfgOverrides {
@@ -2674,13 +2660,6 @@ pub enum NumThreads {
     Concrete(usize),
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
-#[serde(rename_all = "snake_case")]
-pub enum SysrootQueryMetadata {
-    CargoMetadata,
-    None,
-}
-
 macro_rules! _default_val {
     (@verbatim: $s:literal, $ty:ty) => {{
         let default_: $ty = serde_json::from_str(&$s).unwrap();
@@ -3532,14 +3511,6 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json
                 }
             ]
         },
-        "SysrootQueryMetadata" => set! {
-            "type": "string",
-            "enum": ["none", "cargo_metadata"],
-            "enumDescriptions": [
-                "Do not query sysroot metadata, always use stitched sysroot.",
-                "Use `cargo metadata` to query sysroot metadata."
-            ],
-        },
         "Option<MaxSubstitutionLength>" => set! {
             "anyOf": [
                 {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
index ccd2ecdb130..2b3c0a47a22 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
@@ -1082,11 +1082,11 @@ fn resolve_proc_macro() {
         return;
     }
 
-    let sysroot = project_model::Sysroot::discover(
+    let mut sysroot = project_model::Sysroot::discover(
         &AbsPathBuf::assert_utf8(std::env::current_dir().unwrap()),
         &Default::default(),
-        &project_model::SysrootQueryMetadata::default(),
     );
+    sysroot.load_workspace(&project_model::SysrootSourceWorkspaceConfig::default_cargo());
 
     let proc_macro_server_path = sysroot.discover_proc_macro_srv().unwrap();
 
diff --git a/src/tools/rust-analyzer/docs/user/generated_config.adoc b/src/tools/rust-analyzer/docs/user/generated_config.adoc
index 205bf0ccb50..2c6ff4fb01e 100644
--- a/src/tools/rust-analyzer/docs/user/generated_config.adoc
+++ b/src/tools/rust-analyzer/docs/user/generated_config.adoc
@@ -135,12 +135,6 @@ Unsetting this disables sysroot loading.
 
 This option does not take effect until rust-analyzer is restarted.
 --
-[[rust-analyzer.cargo.sysrootQueryMetadata]]rust-analyzer.cargo.sysrootQueryMetadata (default: `"cargo_metadata"`)::
-+
---
-How to query metadata for the sysroot crate. Using cargo metadata allows rust-analyzer
-to analyze third-party dependencies of the standard libraries.
---
 [[rust-analyzer.cargo.sysrootSrc]]rust-analyzer.cargo.sysrootSrc (default: `null`)::
 +
 --
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index e1edab4ba24..6ec7032c0b2 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -871,24 +871,6 @@
                     }
                 }
             },
-            {
-                "title": "cargo",
-                "properties": {
-                    "rust-analyzer.cargo.sysrootQueryMetadata": {
-                        "markdownDescription": "How to query metadata for the sysroot crate. Using cargo metadata allows rust-analyzer\nto analyze third-party dependencies of the standard libraries.",
-                        "default": "cargo_metadata",
-                        "type": "string",
-                        "enum": [
-                            "none",
-                            "cargo_metadata"
-                        ],
-                        "enumDescriptions": [
-                            "Do not query sysroot metadata, always use stitched sysroot.",
-                            "Use `cargo metadata` to query sysroot metadata."
-                        ]
-                    }
-                }
-            },
             {
                 "title": "cargo",
                 "properties": {
-- 
cgit 1.4.1-3-g733a5


From 05770f25994b4ac6395c34ad3ee7e6ae13bebee0 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 7 Jan 2025 12:21:27 +0100
Subject: target-triple -> target-tuple

---
 .../rust-analyzer/crates/project-model/src/lib.rs  |  2 +-
 .../src/toolchain_info/target_triple.rs            | 79 ----------------------
 .../src/toolchain_info/target_tuple.rs             | 79 ++++++++++++++++++++++
 .../crates/project-model/src/workspace.rs          |  6 +-
 .../crates/rust-analyzer/src/config.rs             |  6 +-
 .../crates/rust-analyzer/src/flycheck.rs           |  4 +-
 .../rust-analyzer/docs/user/generated_config.adoc  |  2 +-
 src/tools/rust-analyzer/docs/user/manual.adoc      |  2 +-
 src/tools/rust-analyzer/editors/code/package.json  |  2 +-
 9 files changed, 91 insertions(+), 91 deletions(-)
 delete mode 100644 src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_triple.rs
 create mode 100644 src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_tuple.rs

(limited to 'src/tools/rust-analyzer/editors/code/package.json')

diff --git a/src/tools/rust-analyzer/crates/project-model/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/src/lib.rs
index f5405438253..dec4f1456ba 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/lib.rs
@@ -19,7 +19,7 @@ pub mod project_json;
 pub mod toolchain_info {
     pub mod rustc_cfg;
     pub mod target_data_layout;
-    pub mod target_triple;
+    pub mod target_tuple;
 
     use std::path::Path;
 
diff --git a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_triple.rs b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_triple.rs
deleted file mode 100644
index 163884e5e8b..00000000000
--- a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_triple.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-//! Functionality to discover the current build target(s).
-use std::path::Path;
-
-use anyhow::Context;
-use rustc_hash::FxHashMap;
-use toolchain::Tool;
-
-use crate::{toolchain_info::QueryConfig, utf8_stdout, ManifestPath, Sysroot};
-
-/// For cargo, runs `cargo -Zunstable-options config get build.target` to get the configured project target(s).
-/// For rustc, runs `rustc --print -vV` to get the host target.
-pub fn get(
-    config: QueryConfig<'_>,
-    target: Option<&str>,
-    extra_env: &FxHashMap<String, String>,
-) -> anyhow::Result<Vec<String>> {
-    let _p = tracing::info_span!("target_triple::get").entered();
-    if let Some(target) = target {
-        return Ok(vec![target.to_owned()]);
-    }
-
-    let (sysroot, current_dir) = match config {
-        QueryConfig::Cargo(sysroot, cargo_toml) => {
-            match cargo_config_build_target(cargo_toml, extra_env, sysroot) {
-                Some(it) => return Ok(it),
-                None => (sysroot, cargo_toml.parent().as_ref()),
-            }
-        }
-        QueryConfig::Rustc(sysroot, current_dir) => (sysroot, current_dir),
-    };
-    rustc_discover_host_triple(extra_env, sysroot, current_dir).map(|it| vec![it])
-}
-
-fn rustc_discover_host_triple(
-    extra_env: &FxHashMap<String, String>,
-    sysroot: &Sysroot,
-    current_dir: &Path,
-) -> anyhow::Result<String> {
-    let mut cmd = sysroot.tool(Tool::Rustc, current_dir);
-    cmd.envs(extra_env);
-    cmd.arg("-vV");
-    let stdout = utf8_stdout(&mut cmd)
-        .with_context(|| format!("unable to discover host platform via `{cmd:?}`"))?;
-    let field = "host: ";
-    let target = stdout.lines().find_map(|l| l.strip_prefix(field));
-    if let Some(target) = target {
-        Ok(target.to_owned())
-    } else {
-        // If we fail to resolve the host platform, it's not the end of the world.
-        Err(anyhow::format_err!("rustc -vV did not report host platform, got:\n{}", stdout))
-    }
-}
-
-fn cargo_config_build_target(
-    cargo_toml: &ManifestPath,
-    extra_env: &FxHashMap<String, String>,
-    sysroot: &Sysroot,
-) -> Option<Vec<String>> {
-    let mut cmd = sysroot.tool(Tool::Cargo, cargo_toml.parent());
-    cmd.envs(extra_env);
-    cmd.current_dir(cargo_toml.parent()).env("RUSTC_BOOTSTRAP", "1");
-    cmd.args(["-Z", "unstable-options", "config", "get", "build.target"]);
-    // if successful we receive `build.target = "target-triple"`
-    // or `build.target = ["<target 1>", ..]`
-    // this might be `error: config value `build.target` is not set` in which case we
-    // don't wanna log the error
-    utf8_stdout(&mut cmd).and_then(parse_output_cargo_config_build_target).ok()
-}
-
-// Parses `"build.target = [target-triple, target-triple, ...]"` or `"build.target = "target-triple"`
-fn parse_output_cargo_config_build_target(stdout: String) -> anyhow::Result<Vec<String>> {
-    let trimmed = stdout.trim_start_matches("build.target = ").trim_matches('"');
-
-    if !trimmed.starts_with('[') {
-        return Ok([trimmed.to_owned()].to_vec());
-    }
-
-    serde_json::from_str(trimmed).context("Failed to parse `build.target` as an array of target")
-}
diff --git a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_tuple.rs b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_tuple.rs
new file mode 100644
index 00000000000..55e033caecc
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_tuple.rs
@@ -0,0 +1,79 @@
+//! Functionality to discover the current build target(s).
+use std::path::Path;
+
+use anyhow::Context;
+use rustc_hash::FxHashMap;
+use toolchain::Tool;
+
+use crate::{toolchain_info::QueryConfig, utf8_stdout, ManifestPath, Sysroot};
+
+/// For cargo, runs `cargo -Zunstable-options config get build.target` to get the configured project target(s).
+/// For rustc, runs `rustc --print -vV` to get the host target.
+pub fn get(
+    config: QueryConfig<'_>,
+    target: Option<&str>,
+    extra_env: &FxHashMap<String, String>,
+) -> anyhow::Result<Vec<String>> {
+    let _p = tracing::info_span!("target_tuple::get").entered();
+    if let Some(target) = target {
+        return Ok(vec![target.to_owned()]);
+    }
+
+    let (sysroot, current_dir) = match config {
+        QueryConfig::Cargo(sysroot, cargo_toml) => {
+            match cargo_config_build_target(cargo_toml, extra_env, sysroot) {
+                Some(it) => return Ok(it),
+                None => (sysroot, cargo_toml.parent().as_ref()),
+            }
+        }
+        QueryConfig::Rustc(sysroot, current_dir) => (sysroot, current_dir),
+    };
+    rustc_discover_host_tuple(extra_env, sysroot, current_dir).map(|it| vec![it])
+}
+
+fn rustc_discover_host_tuple(
+    extra_env: &FxHashMap<String, String>,
+    sysroot: &Sysroot,
+    current_dir: &Path,
+) -> anyhow::Result<String> {
+    let mut cmd = sysroot.tool(Tool::Rustc, current_dir);
+    cmd.envs(extra_env);
+    cmd.arg("-vV");
+    let stdout = utf8_stdout(&mut cmd)
+        .with_context(|| format!("unable to discover host platform via `{cmd:?}`"))?;
+    let field = "host: ";
+    let target = stdout.lines().find_map(|l| l.strip_prefix(field));
+    if let Some(target) = target {
+        Ok(target.to_owned())
+    } else {
+        // If we fail to resolve the host platform, it's not the end of the world.
+        Err(anyhow::format_err!("rustc -vV did not report host platform, got:\n{}", stdout))
+    }
+}
+
+fn cargo_config_build_target(
+    cargo_toml: &ManifestPath,
+    extra_env: &FxHashMap<String, String>,
+    sysroot: &Sysroot,
+) -> Option<Vec<String>> {
+    let mut cmd = sysroot.tool(Tool::Cargo, cargo_toml.parent());
+    cmd.envs(extra_env);
+    cmd.current_dir(cargo_toml.parent()).env("RUSTC_BOOTSTRAP", "1");
+    cmd.args(["-Z", "unstable-options", "config", "get", "build.target"]);
+    // if successful we receive `build.target = "target-tuple"`
+    // or `build.target = ["<target 1>", ..]`
+    // this might be `error: config value `build.target` is not set` in which case we
+    // don't wanna log the error
+    utf8_stdout(&mut cmd).and_then(parse_output_cargo_config_build_target).ok()
+}
+
+// Parses `"build.target = [target-tuple, target-tuple, ...]"` or `"build.target = "target-tuple"`
+fn parse_output_cargo_config_build_target(stdout: String) -> anyhow::Result<Vec<String>> {
+    let trimmed = stdout.trim_start_matches("build.target = ").trim_matches('"');
+
+    if !trimmed.starts_with('[') {
+        return Ok([trimmed.to_owned()].to_vec());
+    }
+
+    serde_json::from_str(trimmed).context("Failed to parse `build.target` as an array of target")
+}
diff --git a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
index 6dc8e2fa5d8..905e83b27d1 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
@@ -26,7 +26,7 @@ use crate::{
     env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env},
     project_json::{Crate, CrateArrayIdx},
     sysroot::{SysrootCrate, SysrootWorkspace},
-    toolchain_info::{rustc_cfg, target_data_layout, target_triple, QueryConfig},
+    toolchain_info::{rustc_cfg, target_data_layout, target_tuple, QueryConfig},
     utf8_stdout, CargoConfig, CargoWorkspace, CfgOverrides, InvocationStrategy, ManifestPath,
     Package, ProjectJson, ProjectManifest, Sysroot, SysrootSourceWorkspaceConfig, TargetData,
     TargetKind, WorkspaceBuildScripts,
@@ -242,7 +242,7 @@ impl ProjectWorkspace {
                 .ok_or_else(|| Some("Failed to discover rustc source for sysroot.".to_owned())),
             None => Err(None),
         };
-        let targets = target_triple::get(
+        let targets = target_tuple::get(
             QueryConfig::Cargo(&sysroot, cargo_toml),
             config.target.as_deref(),
             &config.extra_env,
@@ -397,7 +397,7 @@ impl ProjectWorkspace {
                 }
             };
 
-        let targets = target_triple::get(
+        let targets = target_tuple::get(
             QueryConfig::Cargo(&sysroot, detached_file),
             config.target.as_deref(),
             &config.extra_env,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index 67e0a208e8c..30f0031905f 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -600,7 +600,7 @@ config_data! {
         ///
         /// This option does not take effect until rust-analyzer is restarted.
         cargo_sysrootSrc: Option<String>    = None,
-        /// Compilation target override (target triple).
+        /// Compilation target override (target tuple).
         // FIXME(@poliorcetics): move to multiple targets here too, but this will need more work
         // than `checkOnSave_target`
         cargo_target: Option<String>     = None,
@@ -2041,7 +2041,7 @@ impl Config {
 
     pub(crate) fn cargo_test_options(&self, source_root: Option<SourceRootId>) -> CargoOptions {
         CargoOptions {
-            target_triples: self.cargo_target(source_root).clone().into_iter().collect(),
+            target_tuples: self.cargo_target(source_root).clone().into_iter().collect(),
             all_targets: false,
             no_default_features: *self.cargo_noDefaultFeatures(source_root),
             all_features: matches!(self.cargo_features(source_root), CargoFeaturesDef::All),
@@ -2076,7 +2076,7 @@ impl Config {
             Some(_) | None => FlycheckConfig::CargoCommand {
                 command: self.check_command(source_root).clone(),
                 options: CargoOptions {
-                    target_triples: self
+                    target_tuples: self
                         .check_targets(source_root)
                         .clone()
                         .and_then(|targets| match &targets.0[..] {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
index a306302cc0e..98042a2bceb 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
@@ -28,7 +28,7 @@ pub(crate) enum InvocationStrategy {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct CargoOptions {
-    pub(crate) target_triples: Vec<String>,
+    pub(crate) target_tuples: Vec<String>,
     pub(crate) all_targets: bool,
     pub(crate) no_default_features: bool,
     pub(crate) all_features: bool,
@@ -49,7 +49,7 @@ pub(crate) enum Target {
 
 impl CargoOptions {
     pub(crate) fn apply_on_command(&self, cmd: &mut Command) {
-        for target in &self.target_triples {
+        for target in &self.target_tuples {
             cmd.args(["--target", target.as_str()]);
         }
         if self.all_targets {
diff --git a/src/tools/rust-analyzer/docs/user/generated_config.adoc b/src/tools/rust-analyzer/docs/user/generated_config.adoc
index 2c6ff4fb01e..5b86766aa8e 100644
--- a/src/tools/rust-analyzer/docs/user/generated_config.adoc
+++ b/src/tools/rust-analyzer/docs/user/generated_config.adoc
@@ -146,7 +146,7 @@ This option does not take effect until rust-analyzer is restarted.
 [[rust-analyzer.cargo.target]]rust-analyzer.cargo.target (default: `null`)::
 +
 --
-Compilation target override (target triple).
+Compilation target override (target tuple).
 --
 [[rust-analyzer.cargo.targetDir]]rust-analyzer.cargo.targetDir (default: `null`)::
 +
diff --git a/src/tools/rust-analyzer/docs/user/manual.adoc b/src/tools/rust-analyzer/docs/user/manual.adoc
index da2aa4eae4e..ffc820e9b7f 100644
--- a/src/tools/rust-analyzer/docs/user/manual.adoc
+++ b/src/tools/rust-analyzer/docs/user/manual.adoc
@@ -769,7 +769,7 @@ interface Crate {
     /// The set of cfgs activated for a given crate, like
     /// `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
     cfg: string[];
-    /// Target triple for this Crate.
+    /// Target tuple for this Crate.
     ///
     /// Used when running `rustc --print cfg`
     /// to get target-specific cfgs.
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 6ec7032c0b2..80246bf3fea 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -888,7 +888,7 @@
                 "title": "cargo",
                 "properties": {
                     "rust-analyzer.cargo.target": {
-                        "markdownDescription": "Compilation target override (target triple).",
+                        "markdownDescription": "Compilation target override (target tuple).",
                         "default": null,
                         "type": [
                             "null",
-- 
cgit 1.4.1-3-g733a5