From 46d6357994eb8ced835a69390dfbf01abed40ee1 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Wed, 3 Aug 2022 18:22:45 +0200
Subject: Add a setting to disable comment continuation in VSCode

---
 editors/code/src/config.ts | 14 +++++++++++---
 editors/code/src/main.ts   |  4 +++-
 2 files changed, 14 insertions(+), 4 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index b04f18890b9..1c58040d58c 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -16,9 +16,13 @@ export class Config {
     readonly extensionId = "rust-lang.rust-analyzer";
 
     readonly rootSection = "rust-analyzer";
-    private readonly requiresWorkspaceReloadOpts = ["serverPath", "server"].map(
-        (opt) => `${this.rootSection}.${opt}`
-    );
+    private readonly requiresWorkspaceReloadOpts = [
+        "serverPath",
+        "server",
+        // FIXME: This shouldn't be here, changing this setting should reload
+        // `continueCommentsOnNewline` behavior without restart
+        "typing",
+    ].map((opt) => `${this.rootSection}.${opt}`);
     private readonly requiresReloadOpts = [
         "cargo",
         "procMacro",
@@ -140,6 +144,10 @@ export class Config {
         return this.get<boolean>("restartServerOnConfigChange");
     }
 
+    get typingContinueCommentsOnNewline() {
+        return this.get<boolean>("typing.continueCommentsOnNewline");
+    }
+
     get debug() {
         let sourceFileMap = this.get<Record<string, string> | "auto">("debug.sourceFileMap");
         if (sourceFileMap !== "auto") {
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 9ae20ddc4ac..d78b711a47a 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -84,7 +84,9 @@ async function tryActivate(context: vscode.ExtensionContext): Promise<RustAnalyz
 
     warnAboutExtensionConflicts();
 
-    ctx.pushCleanup(configureLanguage());
+    if (config.typingContinueCommentsOnNewline) {
+        ctx.pushCleanup(configureLanguage());
+    }
 
     vscode.workspace.onDidChangeConfiguration(
         (_) =>
-- 
cgit 1.4.1-3-g733a5


From 4b648d8f6cfb9f58490a70e4539aa36c89b9d35e Mon Sep 17 00:00:00 2001
From: Jake Heinz <jh@discordapp.com>
Date: Mon, 8 Aug 2022 00:20:17 +0000
Subject: [code] make toggleInlayHints understand {off,on}UntilPressed

---
 editors/code/src/commands.ts | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index bf55329ca1f..1b793bb0b15 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -326,8 +326,22 @@ export function toggleInlayHints(_ctx: Ctx): Cmd {
         const config = vscode.workspace.getConfiguration("editor.inlayHints", {
             languageId: "rust",
         });
-        const value = !config.get("enabled");
-        await config.update("enabled", value, vscode.ConfigurationTarget.Global);
+
+        const value = config.get("enabled");
+        let stringValue;
+        if (typeof value === "string") {
+            stringValue = value;
+        } else {
+            stringValue = value ? "on" : "off";
+        }
+        const nextValues: Record<string, string> = {
+            on: "off",
+            off: "on",
+            onUnlessPressed: "offUnlessPressed",
+            offUnlessPressed: "onUnlessPressed",
+        };
+        const nextValue = nextValues[stringValue] ?? "on";
+        await config.update("enabled", nextValue, vscode.ConfigurationTarget.Global);
     };
 }
 
-- 
cgit 1.4.1-3-g733a5


From ec8256dd8027bbe5493698e4b9125f1f0cf8c646 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sat, 13 Aug 2022 20:18:21 +0200
Subject: Move VSCode diagnostics workaroudn into client code

---
 crates/rust-analyzer/src/handlers.rs  |  3 +--
 crates/rust-analyzer/src/main_loop.rs | 22 ++++------------------
 editors/code/src/client.ts            |  9 +++++++++
 3 files changed, 14 insertions(+), 20 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 47daa732d5d..943d043bc19 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -1320,8 +1320,7 @@ pub(crate) fn publish_diagnostics(
                 .unwrap(),
             }),
             source: Some("rust-analyzer".to_string()),
-            // https://github.com/rust-lang/rust-analyzer/issues/11404
-            message: if !d.message.is_empty() { d.message } else { " ".to_string() },
+            message: d.message,
             related_information: None,
             tags: if d.unused { Some(vec![DiagnosticTag::UNNECESSARY]) } else { None },
             data: None,
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 92b6be22e76..77419998249 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -327,29 +327,15 @@ impl GlobalState {
                     continue;
                 }
 
-                let url = file_id_to_url(&self.vfs.read().0, file_id);
-                let mut diagnostics =
+                let uri = file_id_to_url(&self.vfs.read().0, file_id);
+                let diagnostics =
                     self.diagnostics.diagnostics_for(file_id).cloned().collect::<Vec<_>>();
-                for d in &mut diagnostics {
-                    // https://github.com/rust-lang/rust-analyzer/issues/11404
-                    // FIXME: We should move this workaround into the client code
-                    if d.message.is_empty() {
-                        d.message = " ".to_string();
-                    }
-                    if let Some(rds) = d.related_information.as_mut() {
-                        for rd in rds {
-                            if rd.message.is_empty() {
-                                rd.message = " ".to_string();
-                            }
-                        }
-                    }
-                }
-                let version = from_proto::vfs_path(&url)
+                let version = from_proto::vfs_path(&uri)
                     .map(|path| self.mem_docs.get(&path).map(|it| it.version))
                     .unwrap_or_default();
 
                 self.send_notification::<lsp_types::notification::PublishDiagnostics>(
-                    lsp_types::PublishDiagnosticsParams { uri: url, diagnostics, version },
+                    lsp_types::PublishDiagnosticsParams { uri, diagnostics, version },
                 );
             }
         }
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 8a2dea6b35b..40ba17844be 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -105,6 +105,15 @@ export async function createClient(
         traceOutputChannel: traceOutputChannel(),
         outputChannel: outputChannel(),
         middleware: {
+            async handleDiagnostics(uri, diagnostics, next) {
+                // Workaround for https://github.com/microsoft/vscode/issues/155531
+                for (const diagnostic of diagnostics) {
+                    if (!diagnostic.message) {
+                        diagnostic.message = " ";
+                    }
+                }
+                next(uri, diagnostics);
+            },
             async provideHover(
                 document: vscode.TextDocument,
                 position: vscode.Position,
-- 
cgit 1.4.1-3-g733a5


From 614969baa770360b711881a3d9776d60937c98db Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sat, 13 Aug 2022 20:49:00 +0200
Subject: Pad empty diagnostic messages in relatedInformation as well

---
 editors/code/src/client.ts | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 40ba17844be..27ab31db8db 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -111,6 +111,13 @@ export async function createClient(
                     if (!diagnostic.message) {
                         diagnostic.message = " ";
                     }
+                    if (diagnostic.relatedInformation) {
+                        for (const relatedInformation of diagnostic.relatedInformation) {
+                            if (!relatedInformation.message) {
+                                relatedInformation.message = " ";
+                            }
+                        }
+                    }
                 }
                 next(uri, diagnostics);
             },
-- 
cgit 1.4.1-3-g733a5


From dcbe892d7ceec113a148a89bc6d1c339c55586d1 Mon Sep 17 00:00:00 2001
From: Jonas Schievink <jonas.schievink@ferrous-systems.com>
Date: Mon, 15 Aug 2022 13:51:45 +0200
Subject: Add an HIR pretty-printer

---
 crates/hir-def/src/body.rs             |   5 +
 crates/hir-def/src/body/pretty.rs      | 621 +++++++++++++++++++++++++++++++++
 crates/hir-def/src/builtin_type.rs     |  35 ++
 crates/hir-def/src/expr.rs             |   6 +-
 crates/hir-def/src/item_tree/pretty.rs | 179 +---------
 crates/hir-def/src/item_tree/tests.rs  |  12 +-
 crates/hir-def/src/lib.rs              |   1 +
 crates/hir-def/src/pretty.rs           | 209 +++++++++++
 crates/hir-def/src/type_ref.rs         |   4 +
 crates/hir/src/lib.rs                  |  29 +-
 crates/ide/src/view_hir.rs             |  14 +-
 editors/code/src/commands.ts           |   2 +-
 12 files changed, 914 insertions(+), 203 deletions(-)
 create mode 100644 crates/hir-def/src/body/pretty.rs
 create mode 100644 crates/hir-def/src/pretty.rs

(limited to 'editors/code/src')

diff --git a/crates/hir-def/src/body.rs b/crates/hir-def/src/body.rs
index 080a307b1f8..1d818d96267 100644
--- a/crates/hir-def/src/body.rs
+++ b/crates/hir-def/src/body.rs
@@ -4,6 +4,7 @@ mod lower;
 #[cfg(test)]
 mod tests;
 pub mod scope;
+mod pretty;
 
 use std::{ops::Index, sync::Arc};
 
@@ -352,6 +353,10 @@ impl Body {
         }
     }
 
+    pub fn pretty_print(&self, db: &dyn DefDatabase, owner: DefWithBodyId) -> String {
+        pretty::print_body_hir(db, self, owner)
+    }
+
     fn new(
         db: &dyn DefDatabase,
         expander: Expander,
diff --git a/crates/hir-def/src/body/pretty.rs b/crates/hir-def/src/body/pretty.rs
new file mode 100644
index 00000000000..ddd476efe5c
--- /dev/null
+++ b/crates/hir-def/src/body/pretty.rs
@@ -0,0 +1,621 @@
+//! A pretty-printer for HIR.
+
+use std::fmt::{self, Write};
+
+use crate::{
+    expr::{Array, BindingAnnotation, Literal, Statement},
+    pretty::{print_generic_args, print_path, print_type_ref},
+    type_ref::TypeRef,
+};
+
+use super::*;
+
+pub(super) fn print_body_hir(db: &dyn DefDatabase, body: &Body, owner: DefWithBodyId) -> String {
+    let needs_semi;
+    let header = match owner {
+        DefWithBodyId::FunctionId(it) => {
+            needs_semi = false;
+            let item_tree_id = it.lookup(db).id;
+            format!("fn {}(…) ", item_tree_id.item_tree(db)[item_tree_id.value].name)
+        }
+        DefWithBodyId::StaticId(it) => {
+            needs_semi = true;
+            let item_tree_id = it.lookup(db).id;
+            format!("static {} = ", item_tree_id.item_tree(db)[item_tree_id.value].name)
+        }
+        DefWithBodyId::ConstId(it) => {
+            needs_semi = true;
+            let item_tree_id = it.lookup(db).id;
+            let name = match &item_tree_id.item_tree(db)[item_tree_id.value].name {
+                Some(name) => name.to_string(),
+                None => "_".to_string(),
+            };
+            format!("const {} = ", name)
+        }
+    };
+
+    let mut p = Printer { body, buf: header, indent_level: 0, needs_indent: false };
+    p.print_expr(body.body_expr);
+    if needs_semi {
+        p.buf.push(';');
+    }
+    p.buf
+}
+
+macro_rules! w {
+    ($dst:expr, $($arg:tt)*) => {
+        { let _ = write!($dst, $($arg)*); }
+    };
+}
+
+macro_rules! wln {
+    ($dst:expr) => {
+        { let _ = writeln!($dst); }
+    };
+    ($dst:expr, $($arg:tt)*) => {
+        { let _ = writeln!($dst, $($arg)*); }
+    };
+}
+
+struct Printer<'a> {
+    body: &'a Body,
+    buf: String,
+    indent_level: usize,
+    needs_indent: bool,
+}
+
+impl<'a> Write for Printer<'a> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for line in s.split_inclusive('\n') {
+            if self.needs_indent {
+                match self.buf.chars().rev().skip_while(|ch| *ch == ' ').next() {
+                    Some('\n') | None => {}
+                    _ => self.buf.push('\n'),
+                }
+                self.buf.push_str(&"    ".repeat(self.indent_level));
+                self.needs_indent = false;
+            }
+
+            self.buf.push_str(line);
+            self.needs_indent = line.ends_with('\n');
+        }
+
+        Ok(())
+    }
+}
+
+impl<'a> Printer<'a> {
+    fn indented(&mut self, f: impl FnOnce(&mut Self)) {
+        self.indent_level += 1;
+        wln!(self);
+        f(self);
+        self.indent_level -= 1;
+        self.buf = self.buf.trim_end_matches('\n').to_string();
+    }
+
+    fn whitespace(&mut self) {
+        match self.buf.chars().next_back() {
+            None | Some('\n' | ' ') => {}
+            _ => self.buf.push(' '),
+        }
+    }
+
+    fn newline(&mut self) {
+        match self.buf.chars().rev().skip_while(|ch| *ch == ' ').next() {
+            Some('\n') | None => {}
+            _ => writeln!(self).unwrap(),
+        }
+    }
+
+    fn print_expr(&mut self, expr: ExprId) {
+        let expr = &self.body[expr];
+
+        match expr {
+            Expr::Missing => w!(self, "�"),
+            Expr::Underscore => w!(self, "_"),
+            Expr::Path(path) => self.print_path(path),
+            Expr::If { condition, then_branch, else_branch } => {
+                w!(self, "if ");
+                self.print_expr(*condition);
+                w!(self, " ");
+                self.print_expr(*then_branch);
+                if let Some(els) = *else_branch {
+                    w!(self, " else ");
+                    self.print_expr(els);
+                }
+            }
+            Expr::Let { pat, expr } => {
+                w!(self, "let ");
+                self.print_pat(*pat);
+                w!(self, " = ");
+                self.print_expr(*expr);
+            }
+            Expr::Loop { body, label } => {
+                if let Some(lbl) = label {
+                    w!(self, "{}: ", self.body[*lbl].name);
+                }
+                w!(self, "loop ");
+                self.print_expr(*body);
+            }
+            Expr::While { condition, body, label } => {
+                if let Some(lbl) = label {
+                    w!(self, "{}: ", self.body[*lbl].name);
+                }
+                w!(self, "while ");
+                self.print_expr(*condition);
+                self.print_expr(*body);
+            }
+            Expr::For { iterable, pat, body, label } => {
+                if let Some(lbl) = label {
+                    w!(self, "{}: ", self.body[*lbl].name);
+                }
+                w!(self, "for ");
+                self.print_pat(*pat);
+                w!(self, " in ");
+                self.print_expr(*iterable);
+                self.print_expr(*body);
+            }
+            Expr::Call { callee, args, is_assignee_expr: _ } => {
+                self.print_expr(*callee);
+                w!(self, "(");
+                if !args.is_empty() {
+                    self.indented(|p| {
+                        for arg in &**args {
+                            p.print_expr(*arg);
+                            wln!(p, ",");
+                        }
+                    });
+                }
+                w!(self, ")");
+            }
+            Expr::MethodCall { receiver, method_name, args, generic_args } => {
+                self.print_expr(*receiver);
+                w!(self, ".{}", method_name);
+                if let Some(args) = generic_args {
+                    w!(self, "::<");
+                    print_generic_args(args, self).unwrap();
+                    w!(self, ">");
+                }
+                w!(self, "(");
+                if !args.is_empty() {
+                    self.indented(|p| {
+                        for arg in &**args {
+                            p.print_expr(*arg);
+                            wln!(p, ",");
+                        }
+                    });
+                }
+                w!(self, ")");
+            }
+            Expr::Match { expr, arms } => {
+                w!(self, "match ");
+                self.print_expr(*expr);
+                w!(self, " {{");
+                self.indented(|p| {
+                    for arm in &**arms {
+                        p.print_pat(arm.pat);
+                        if let Some(guard) = arm.guard {
+                            w!(p, " if ");
+                            p.print_expr(guard);
+                        }
+                        w!(p, " => ");
+                        p.print_expr(arm.expr);
+                        wln!(p, ",");
+                    }
+                });
+                wln!(self, "}}");
+            }
+            Expr::Continue { label } => {
+                w!(self, "continue");
+                if let Some(label) = label {
+                    w!(self, " {}", label);
+                }
+            }
+            Expr::Break { expr, label } => {
+                w!(self, "break");
+                if let Some(label) = label {
+                    w!(self, " {}", label);
+                }
+                if let Some(expr) = expr {
+                    self.whitespace();
+                    self.print_expr(*expr);
+                }
+            }
+            Expr::Return { expr } => {
+                w!(self, "return");
+                if let Some(expr) = expr {
+                    self.whitespace();
+                    self.print_expr(*expr);
+                }
+            }
+            Expr::Yield { expr } => {
+                w!(self, "yield");
+                if let Some(expr) = expr {
+                    self.whitespace();
+                    self.print_expr(*expr);
+                }
+            }
+            Expr::RecordLit { path, fields, spread, ellipsis, is_assignee_expr: _ } => {
+                match path {
+                    Some(path) => self.print_path(path),
+                    None => w!(self, "�"),
+                }
+
+                w!(self, "{{");
+                self.indented(|p| {
+                    for field in &**fields {
+                        w!(p, "{}: ", field.name);
+                        p.print_expr(field.expr);
+                        wln!(p, ",");
+                    }
+                    if let Some(spread) = spread {
+                        w!(p, "..");
+                        p.print_expr(*spread);
+                        wln!(p);
+                    }
+                    if *ellipsis {
+                        wln!(p, "..");
+                    }
+                });
+                w!(self, "}}");
+            }
+            Expr::Field { expr, name } => {
+                self.print_expr(*expr);
+                w!(self, ".{}", name);
+            }
+            Expr::Await { expr } => {
+                self.print_expr(*expr);
+                w!(self, ".await");
+            }
+            Expr::Try { expr } => {
+                self.print_expr(*expr);
+                w!(self, "?");
+            }
+            Expr::TryBlock { body } => {
+                w!(self, "try ");
+                self.print_expr(*body);
+            }
+            Expr::Async { body } => {
+                w!(self, "async ");
+                self.print_expr(*body);
+            }
+            Expr::Const { body } => {
+                w!(self, "const ");
+                self.print_expr(*body);
+            }
+            Expr::Cast { expr, type_ref } => {
+                self.print_expr(*expr);
+                w!(self, " as ");
+                self.print_type_ref(type_ref);
+            }
+            Expr::Ref { expr, rawness, mutability } => {
+                w!(self, "&");
+                if rawness.is_raw() {
+                    w!(self, "raw ");
+                }
+                if mutability.is_mut() {
+                    w!(self, "mut ");
+                }
+                self.print_expr(*expr);
+            }
+            Expr::Box { expr } => {
+                w!(self, "box ");
+                self.print_expr(*expr);
+            }
+            Expr::UnaryOp { expr, op } => {
+                let op = match op {
+                    ast::UnaryOp::Deref => "*",
+                    ast::UnaryOp::Not => "!",
+                    ast::UnaryOp::Neg => "-",
+                };
+                w!(self, "{}", op);
+                self.print_expr(*expr);
+            }
+            Expr::BinaryOp { lhs, rhs, op } => {
+                let (bra, ket) = match op {
+                    None | Some(ast::BinaryOp::Assignment { .. }) => ("", ""),
+                    _ => ("(", ")"),
+                };
+                w!(self, "{}", bra);
+                self.print_expr(*lhs);
+                w!(self, "{} ", ket);
+                match op {
+                    Some(op) => w!(self, "{}", op),
+                    None => w!(self, "�"), // :)
+                }
+                w!(self, " {}", bra);
+                self.print_expr(*rhs);
+                w!(self, "{}", ket);
+            }
+            Expr::Range { lhs, rhs, range_type } => {
+                if let Some(lhs) = lhs {
+                    w!(self, "(");
+                    self.print_expr(*lhs);
+                    w!(self, ") ");
+                }
+                let range = match range_type {
+                    ast::RangeOp::Exclusive => "..",
+                    ast::RangeOp::Inclusive => "..=",
+                };
+                w!(self, "{}", range);
+                if let Some(rhs) = rhs {
+                    w!(self, "(");
+                    self.print_expr(*rhs);
+                    w!(self, ") ");
+                }
+            }
+            Expr::Index { base, index } => {
+                self.print_expr(*base);
+                w!(self, "[");
+                self.print_expr(*index);
+                w!(self, "]");
+            }
+            Expr::Closure { args, arg_types, ret_type, body } => {
+                w!(self, "|");
+                for (i, (pat, ty)) in args.iter().zip(arg_types.iter()).enumerate() {
+                    if i != 0 {
+                        w!(self, ", ");
+                    }
+                    self.print_pat(*pat);
+                    if let Some(ty) = ty {
+                        w!(self, ": ");
+                        self.print_type_ref(ty);
+                    }
+                }
+                w!(self, "|");
+                if let Some(ret_ty) = ret_type {
+                    w!(self, " -> ");
+                    self.print_type_ref(ret_ty);
+                }
+                self.whitespace();
+                self.print_expr(*body);
+            }
+            Expr::Tuple { exprs, is_assignee_expr: _ } => {
+                w!(self, "(");
+                for expr in exprs.iter() {
+                    self.print_expr(*expr);
+                    w!(self, ", ");
+                }
+                w!(self, ")");
+            }
+            Expr::Unsafe { body } => {
+                w!(self, "unsafe ");
+                self.print_expr(*body);
+            }
+            Expr::Array(arr) => {
+                w!(self, "[");
+                if !matches!(arr, Array::ElementList { elements, .. } if elements.is_empty()) {
+                    self.indented(|p| match arr {
+                        Array::ElementList { elements, is_assignee_expr: _ } => {
+                            for elem in elements.iter() {
+                                p.print_expr(*elem);
+                                w!(p, ", ");
+                            }
+                        }
+                        Array::Repeat { initializer, repeat } => {
+                            p.print_expr(*initializer);
+                            w!(p, "; ");
+                            p.print_expr(*repeat);
+                        }
+                    });
+                    self.newline();
+                }
+                w!(self, "]");
+            }
+            Expr::Literal(lit) => self.print_literal(lit),
+            Expr::Block { id: _, statements, tail, label } => {
+                self.whitespace();
+                if let Some(lbl) = label {
+                    w!(self, "{}: ", self.body[*lbl].name);
+                }
+                w!(self, "{{");
+                if !statements.is_empty() || tail.is_some() {
+                    self.indented(|p| {
+                        for stmt in &**statements {
+                            p.print_stmt(stmt);
+                        }
+                        if let Some(tail) = tail {
+                            p.print_expr(*tail);
+                        }
+                        p.newline();
+                    });
+                }
+                w!(self, "}}");
+            }
+            Expr::MacroStmts { statements, tail } => {
+                w!(self, "{{ // macro statements");
+                self.indented(|p| {
+                    for stmt in statements.iter() {
+                        p.print_stmt(stmt);
+                    }
+                    if let Some(tail) = tail {
+                        p.print_expr(*tail);
+                    }
+                });
+                self.newline();
+                w!(self, "}}");
+            }
+        }
+    }
+
+    fn print_pat(&mut self, pat: PatId) {
+        let pat = &self.body[pat];
+
+        match pat {
+            Pat::Missing => w!(self, "�"),
+            Pat::Wild => w!(self, "_"),
+            Pat::Tuple { args, ellipsis } => {
+                w!(self, "(");
+                for (i, pat) in args.iter().enumerate() {
+                    if i != 0 {
+                        w!(self, ", ");
+                    }
+                    if *ellipsis == Some(i) {
+                        w!(self, ".., ");
+                    }
+                    self.print_pat(*pat);
+                }
+                w!(self, ")");
+            }
+            Pat::Or(pats) => {
+                for (i, pat) in pats.iter().enumerate() {
+                    if i != 0 {
+                        w!(self, " | ");
+                    }
+                    self.print_pat(*pat);
+                }
+            }
+            Pat::Record { path, args, ellipsis } => {
+                match path {
+                    Some(path) => self.print_path(path),
+                    None => w!(self, "�"),
+                }
+
+                w!(self, " {{");
+                self.indented(|p| {
+                    for arg in args.iter() {
+                        w!(p, "{}: ", arg.name);
+                        p.print_pat(arg.pat);
+                        wln!(p, ",");
+                    }
+                    if *ellipsis {
+                        wln!(p, "..");
+                    }
+                });
+                w!(self, "}}");
+            }
+            Pat::Range { start, end } => {
+                self.print_expr(*start);
+                w!(self, "...");
+                self.print_expr(*end);
+            }
+            Pat::Slice { prefix, slice, suffix } => {
+                w!(self, "[");
+                for pat in prefix.iter() {
+                    self.print_pat(*pat);
+                    w!(self, ", ");
+                }
+                if let Some(pat) = slice {
+                    self.print_pat(*pat);
+                    w!(self, ", ");
+                }
+                for pat in suffix.iter() {
+                    self.print_pat(*pat);
+                    w!(self, ", ");
+                }
+                w!(self, "]");
+            }
+            Pat::Path(path) => self.print_path(path),
+            Pat::Lit(expr) => self.print_expr(*expr),
+            Pat::Bind { mode, name, subpat } => {
+                let mode = match mode {
+                    BindingAnnotation::Unannotated => "",
+                    BindingAnnotation::Mutable => "mut ",
+                    BindingAnnotation::Ref => "ref ",
+                    BindingAnnotation::RefMut => "ref mut ",
+                };
+                w!(self, "{}{}", mode, name);
+                if let Some(pat) = subpat {
+                    self.whitespace();
+                    self.print_pat(*pat);
+                }
+            }
+            Pat::TupleStruct { path, args, ellipsis } => {
+                match path {
+                    Some(path) => self.print_path(path),
+                    None => w!(self, "�"),
+                }
+                w!(self, "(");
+                for (i, arg) in args.iter().enumerate() {
+                    if i != 0 {
+                        w!(self, ", ");
+                    }
+                    if *ellipsis == Some(i) {
+                        w!(self, ", ..");
+                    }
+                    self.print_pat(*arg);
+                }
+                w!(self, ")");
+            }
+            Pat::Ref { pat, mutability } => {
+                w!(self, "&");
+                if mutability.is_mut() {
+                    w!(self, "mut ");
+                }
+                self.print_pat(*pat);
+            }
+            Pat::Box { inner } => {
+                w!(self, "box ");
+                self.print_pat(*inner);
+            }
+            Pat::ConstBlock(c) => {
+                w!(self, "const ");
+                self.print_expr(*c);
+            }
+        }
+    }
+
+    fn print_stmt(&mut self, stmt: &Statement) {
+        match stmt {
+            Statement::Let { pat, type_ref, initializer, else_branch } => {
+                w!(self, "let ");
+                self.print_pat(*pat);
+                if let Some(ty) = type_ref {
+                    w!(self, ": ");
+                    self.print_type_ref(ty);
+                }
+                if let Some(init) = initializer {
+                    w!(self, " = ");
+                    self.print_expr(*init);
+                }
+                if let Some(els) = else_branch {
+                    w!(self, " else ");
+                    self.print_expr(*els);
+                }
+                wln!(self, ";");
+            }
+            Statement::Expr { expr, has_semi } => {
+                self.print_expr(*expr);
+                if *has_semi {
+                    w!(self, ";");
+                }
+                wln!(self);
+            }
+        }
+    }
+
+    fn print_literal(&mut self, literal: &Literal) {
+        match literal {
+            Literal::String(it) => w!(self, "{:?}", it),
+            Literal::ByteString(it) => w!(self, "\"{}\"", it.escape_ascii()),
+            Literal::Char(it) => w!(self, "'{}'", it.escape_debug()),
+            Literal::Bool(it) => w!(self, "{}", it),
+            Literal::Int(i, suffix) => {
+                w!(self, "{}", i);
+                if let Some(suffix) = suffix {
+                    w!(self, "{}", suffix);
+                }
+            }
+            Literal::Uint(i, suffix) => {
+                w!(self, "{}", i);
+                if let Some(suffix) = suffix {
+                    w!(self, "{}", suffix);
+                }
+            }
+            Literal::Float(f, suffix) => {
+                w!(self, "{}", f);
+                if let Some(suffix) = suffix {
+                    w!(self, "{}", suffix);
+                }
+            }
+        }
+    }
+
+    fn print_type_ref(&mut self, ty: &TypeRef) {
+        print_type_ref(ty, self).unwrap();
+    }
+
+    fn print_path(&mut self, path: &Path) {
+        print_path(path, self).unwrap();
+    }
+}
diff --git a/crates/hir-def/src/builtin_type.rs b/crates/hir-def/src/builtin_type.rs
index 25a408036ff..dd69c3ab473 100644
--- a/crates/hir-def/src/builtin_type.rs
+++ b/crates/hir-def/src/builtin_type.rs
@@ -156,3 +156,38 @@ impl BuiltinFloat {
         Some(res)
     }
 }
+
+impl fmt::Display for BuiltinInt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            BuiltinInt::Isize => "isize",
+            BuiltinInt::I8 => "i8",
+            BuiltinInt::I16 => "i16",
+            BuiltinInt::I32 => "i32",
+            BuiltinInt::I64 => "i64",
+            BuiltinInt::I128 => "i128",
+        })
+    }
+}
+
+impl fmt::Display for BuiltinUint {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            BuiltinUint::Usize => "usize",
+            BuiltinUint::U8 => "u8",
+            BuiltinUint::U16 => "u16",
+            BuiltinUint::U32 => "u32",
+            BuiltinUint::U64 => "u64",
+            BuiltinUint::U128 => "u128",
+        })
+    }
+}
+
+impl fmt::Display for BuiltinFloat {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            BuiltinFloat::F32 => "f32",
+            BuiltinFloat::F64 => "f64",
+        })
+    }
+}
diff --git a/crates/hir-def/src/expr.rs b/crates/hir-def/src/expr.rs
index c1b3788acb7..4381b43c258 100644
--- a/crates/hir-def/src/expr.rs
+++ b/crates/hir-def/src/expr.rs
@@ -12,6 +12,8 @@
 //!
 //! See also a neighboring `body` module.
 
+use std::fmt;
+
 use hir_expand::name::Name;
 use la_arena::{Idx, RawIdx};
 
@@ -52,8 +54,8 @@ impl FloatTypeWrapper {
     }
 }
 
-impl std::fmt::Display for FloatTypeWrapper {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl fmt::Display for FloatTypeWrapper {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{:?}", f64::from_bits(self.0))
     }
 }
diff --git a/crates/hir-def/src/item_tree/pretty.rs b/crates/hir-def/src/item_tree/pretty.rs
index f12d9a1273c..34dd817fd13 100644
--- a/crates/hir-def/src/item_tree/pretty.rs
+++ b/crates/hir-def/src/item_tree/pretty.rs
@@ -2,13 +2,10 @@
 
 use std::fmt::{self, Write};
 
-use itertools::Itertools;
-
 use crate::{
     attr::RawAttrs,
     generics::{TypeOrConstParamData, WherePredicate, WherePredicateTypeTarget},
-    path::GenericArg,
-    type_ref::TraitBoundModifier,
+    pretty::{print_path, print_type_bounds, print_type_ref},
     visibility::RawVisibility,
 };
 
@@ -464,183 +461,15 @@ impl<'a> Printer<'a> {
     }
 
     fn print_type_ref(&mut self, type_ref: &TypeRef) {
-        // FIXME: deduplicate with `HirDisplay` impl
-        match type_ref {
-            TypeRef::Never => w!(self, "!"),
-            TypeRef::Placeholder => w!(self, "_"),
-            TypeRef::Tuple(fields) => {
-                w!(self, "(");
-                for (i, field) in fields.iter().enumerate() {
-                    if i != 0 {
-                        w!(self, ", ");
-                    }
-                    self.print_type_ref(field);
-                }
-                w!(self, ")");
-            }
-            TypeRef::Path(path) => self.print_path(path),
-            TypeRef::RawPtr(pointee, mtbl) => {
-                let mtbl = match mtbl {
-                    Mutability::Shared => "*const",
-                    Mutability::Mut => "*mut",
-                };
-                w!(self, "{} ", mtbl);
-                self.print_type_ref(pointee);
-            }
-            TypeRef::Reference(pointee, lt, mtbl) => {
-                let mtbl = match mtbl {
-                    Mutability::Shared => "",
-                    Mutability::Mut => "mut ",
-                };
-                w!(self, "&");
-                if let Some(lt) = lt {
-                    w!(self, "{} ", lt.name);
-                }
-                w!(self, "{}", mtbl);
-                self.print_type_ref(pointee);
-            }
-            TypeRef::Array(elem, len) => {
-                w!(self, "[");
-                self.print_type_ref(elem);
-                w!(self, "; {}]", len);
-            }
-            TypeRef::Slice(elem) => {
-                w!(self, "[");
-                self.print_type_ref(elem);
-                w!(self, "]");
-            }
-            TypeRef::Fn(args_and_ret, varargs) => {
-                let ((_, return_type), args) =
-                    args_and_ret.split_last().expect("TypeRef::Fn is missing return type");
-                w!(self, "fn(");
-                for (i, (_, typeref)) in args.iter().enumerate() {
-                    if i != 0 {
-                        w!(self, ", ");
-                    }
-                    self.print_type_ref(typeref);
-                }
-                if *varargs {
-                    if !args.is_empty() {
-                        w!(self, ", ");
-                    }
-                    w!(self, "...");
-                }
-                w!(self, ") -> ");
-                self.print_type_ref(return_type);
-            }
-            TypeRef::Macro(_ast_id) => {
-                w!(self, "<macro>");
-            }
-            TypeRef::Error => w!(self, "{{unknown}}"),
-            TypeRef::ImplTrait(bounds) => {
-                w!(self, "impl ");
-                self.print_type_bounds(bounds);
-            }
-            TypeRef::DynTrait(bounds) => {
-                w!(self, "dyn ");
-                self.print_type_bounds(bounds);
-            }
-        }
+        print_type_ref(type_ref, self).unwrap();
     }
 
     fn print_type_bounds(&mut self, bounds: &[Interned<TypeBound>]) {
-        for (i, bound) in bounds.iter().enumerate() {
-            if i != 0 {
-                w!(self, " + ");
-            }
-
-            match bound.as_ref() {
-                TypeBound::Path(path, modifier) => {
-                    match modifier {
-                        TraitBoundModifier::None => (),
-                        TraitBoundModifier::Maybe => w!(self, "?"),
-                    }
-                    self.print_path(path)
-                }
-                TypeBound::ForLifetime(lifetimes, path) => {
-                    w!(self, "for<{}> ", lifetimes.iter().format(", "));
-                    self.print_path(path);
-                }
-                TypeBound::Lifetime(lt) => w!(self, "{}", lt.name),
-                TypeBound::Error => w!(self, "{{unknown}}"),
-            }
-        }
+        print_type_bounds(bounds, self).unwrap();
     }
 
     fn print_path(&mut self, path: &Path) {
-        match path.type_anchor() {
-            Some(anchor) => {
-                w!(self, "<");
-                self.print_type_ref(anchor);
-                w!(self, ">::");
-            }
-            None => match path.kind() {
-                PathKind::Plain => {}
-                PathKind::Super(0) => w!(self, "self::"),
-                PathKind::Super(n) => {
-                    for _ in 0..*n {
-                        w!(self, "super::");
-                    }
-                }
-                PathKind::Crate => w!(self, "crate::"),
-                PathKind::Abs => w!(self, "::"),
-                PathKind::DollarCrate(_) => w!(self, "$crate::"),
-            },
-        }
-
-        for (i, segment) in path.segments().iter().enumerate() {
-            if i != 0 {
-                w!(self, "::");
-            }
-
-            w!(self, "{}", segment.name);
-            if let Some(generics) = segment.args_and_bindings {
-                // NB: these are all in type position, so `::<` turbofish syntax is not necessary
-                w!(self, "<");
-                let mut first = true;
-                let args = if generics.has_self_type {
-                    let (self_ty, args) = generics.args.split_first().unwrap();
-                    w!(self, "Self=");
-                    self.print_generic_arg(self_ty);
-                    first = false;
-                    args
-                } else {
-                    &generics.args
-                };
-                for arg in args {
-                    if !first {
-                        w!(self, ", ");
-                    }
-                    first = false;
-                    self.print_generic_arg(arg);
-                }
-                for binding in &generics.bindings {
-                    if !first {
-                        w!(self, ", ");
-                    }
-                    first = false;
-                    w!(self, "{}", binding.name);
-                    if !binding.bounds.is_empty() {
-                        w!(self, ": ");
-                        self.print_type_bounds(&binding.bounds);
-                    }
-                    if let Some(ty) = &binding.type_ref {
-                        w!(self, " = ");
-                        self.print_type_ref(ty);
-                    }
-                }
-
-                w!(self, ">");
-            }
-        }
-    }
-
-    fn print_generic_arg(&mut self, arg: &GenericArg) {
-        match arg {
-            GenericArg::Type(ty) => self.print_type_ref(ty),
-            GenericArg::Const(c) => w!(self, "{}", c),
-            GenericArg::Lifetime(lt) => w!(self, "{}", lt.name),
-        }
+        print_path(path, self).unwrap();
     }
 
     fn print_generic_params(&mut self, params: &GenericParams) {
diff --git a/crates/hir-def/src/item_tree/tests.rs b/crates/hir-def/src/item_tree/tests.rs
index 5cdf36cc61b..e30d9652bb5 100644
--- a/crates/hir-def/src/item_tree/tests.rs
+++ b/crates/hir-def/src/item_tree/tests.rs
@@ -283,10 +283,10 @@ struct S {
         "#,
         expect![[r#"
             pub(self) struct S {
-                pub(self) a: Mixed<'a, T, Item = (), OtherItem = u8>,
-                pub(self) b: Qualified<Self=Fully>::Syntax,
-                pub(self) c: <TypeAnchored>::Path<'a>,
-                pub(self) d: dyn for<'a> Trait<'a>,
+                pub(self) a: Mixed::<'a, T, Item = (), OtherItem = u8>,
+                pub(self) b: Qualified::<Self=Fully>::Syntax,
+                pub(self) c: <TypeAnchored>::Path::<'a>,
+                pub(self) d: dyn for<'a> Trait::<'a>,
             }
         "#]],
     )
@@ -329,7 +329,7 @@ trait Tr<'a, T: 'a>: Super where Self: for<'a> Tr<'a, T> {}
                 T: Copy,
                 U: ?Sized;
 
-            impl<'a, 'b, T, const K: u8> S<'a, 'b, T, K>
+            impl<'a, 'b, T, const K: u8> S::<'a, 'b, T, K>
             where
                 T: Copy,
                 T: 'a,
@@ -352,7 +352,7 @@ trait Tr<'a, T: 'a>: Super where Self: for<'a> Tr<'a, T> {}
             where
                 Self: Super,
                 T: 'a,
-                Self: for<'a> Tr<'a, T>
+                Self: for<'a> Tr::<'a, T>
             {
             }
         "#]],
diff --git a/crates/hir-def/src/lib.rs b/crates/hir-def/src/lib.rs
index 56603f4b154..32ebfda4fd9 100644
--- a/crates/hir-def/src/lib.rs
+++ b/crates/hir-def/src/lib.rs
@@ -53,6 +53,7 @@ pub mod import_map;
 mod test_db;
 #[cfg(test)]
 mod macro_expansion_tests;
+mod pretty;
 
 use std::{
     hash::{Hash, Hasher},
diff --git a/crates/hir-def/src/pretty.rs b/crates/hir-def/src/pretty.rs
new file mode 100644
index 00000000000..6636c8a23ca
--- /dev/null
+++ b/crates/hir-def/src/pretty.rs
@@ -0,0 +1,209 @@
+//! Display and pretty printing routines.
+
+use std::fmt::{self, Write};
+
+use hir_expand::mod_path::PathKind;
+use itertools::Itertools;
+
+use crate::{
+    intern::Interned,
+    path::{GenericArg, GenericArgs, Path},
+    type_ref::{Mutability, TraitBoundModifier, TypeBound, TypeRef},
+};
+
+pub(crate) fn print_path(path: &Path, buf: &mut dyn Write) -> fmt::Result {
+    match path.type_anchor() {
+        Some(anchor) => {
+            write!(buf, "<")?;
+            print_type_ref(anchor, buf)?;
+            write!(buf, ">::")?;
+        }
+        None => match path.kind() {
+            PathKind::Plain => {}
+            PathKind::Super(0) => write!(buf, "self")?,
+            PathKind::Super(n) => {
+                for i in 0..*n {
+                    if i == 0 {
+                        buf.write_str("super")?;
+                    } else {
+                        buf.write_str("::super")?;
+                    }
+                }
+            }
+            PathKind::Crate => write!(buf, "crate")?,
+            PathKind::Abs => {}
+            PathKind::DollarCrate(_) => write!(buf, "$crate")?,
+        },
+    }
+
+    for (i, segment) in path.segments().iter().enumerate() {
+        if i != 0 || !matches!(path.kind(), PathKind::Plain) {
+            write!(buf, "::")?;
+        }
+
+        write!(buf, "{}", segment.name)?;
+        if let Some(generics) = segment.args_and_bindings {
+            write!(buf, "::<")?;
+            print_generic_args(generics, buf)?;
+
+            write!(buf, ">")?;
+        }
+    }
+
+    Ok(())
+}
+
+pub(crate) fn print_generic_args(generics: &GenericArgs, buf: &mut dyn Write) -> fmt::Result {
+    let mut first = true;
+    let args = if generics.has_self_type {
+        let (self_ty, args) = generics.args.split_first().unwrap();
+        write!(buf, "Self=")?;
+        print_generic_arg(self_ty, buf)?;
+        first = false;
+        args
+    } else {
+        &generics.args
+    };
+    for arg in args {
+        if !first {
+            write!(buf, ", ")?;
+        }
+        first = false;
+        print_generic_arg(arg, buf)?;
+    }
+    for binding in &generics.bindings {
+        if !first {
+            write!(buf, ", ")?;
+        }
+        first = false;
+        write!(buf, "{}", binding.name)?;
+        if !binding.bounds.is_empty() {
+            write!(buf, ": ")?;
+            print_type_bounds(&binding.bounds, buf)?;
+        }
+        if let Some(ty) = &binding.type_ref {
+            write!(buf, " = ")?;
+            print_type_ref(ty, buf)?;
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn print_generic_arg(arg: &GenericArg, buf: &mut dyn Write) -> fmt::Result {
+    match arg {
+        GenericArg::Type(ty) => print_type_ref(ty, buf),
+        GenericArg::Const(c) => write!(buf, "{}", c),
+        GenericArg::Lifetime(lt) => write!(buf, "{}", lt.name),
+    }
+}
+
+pub(crate) fn print_type_ref(type_ref: &TypeRef, buf: &mut dyn Write) -> fmt::Result {
+    // FIXME: deduplicate with `HirDisplay` impl
+    match type_ref {
+        TypeRef::Never => write!(buf, "!")?,
+        TypeRef::Placeholder => write!(buf, "_")?,
+        TypeRef::Tuple(fields) => {
+            write!(buf, "(")?;
+            for (i, field) in fields.iter().enumerate() {
+                if i != 0 {
+                    write!(buf, ", ")?;
+                }
+                print_type_ref(field, buf)?;
+            }
+            write!(buf, ")")?;
+        }
+        TypeRef::Path(path) => print_path(path, buf)?,
+        TypeRef::RawPtr(pointee, mtbl) => {
+            let mtbl = match mtbl {
+                Mutability::Shared => "*const",
+                Mutability::Mut => "*mut",
+            };
+            write!(buf, "{} ", mtbl)?;
+            print_type_ref(pointee, buf)?;
+        }
+        TypeRef::Reference(pointee, lt, mtbl) => {
+            let mtbl = match mtbl {
+                Mutability::Shared => "",
+                Mutability::Mut => "mut ",
+            };
+            write!(buf, "&")?;
+            if let Some(lt) = lt {
+                write!(buf, "{} ", lt.name)?;
+            }
+            write!(buf, "{}", mtbl)?;
+            print_type_ref(pointee, buf)?;
+        }
+        TypeRef::Array(elem, len) => {
+            write!(buf, "[")?;
+            print_type_ref(elem, buf)?;
+            write!(buf, "; {}]", len)?;
+        }
+        TypeRef::Slice(elem) => {
+            write!(buf, "[")?;
+            print_type_ref(elem, buf)?;
+            write!(buf, "]")?;
+        }
+        TypeRef::Fn(args_and_ret, varargs) => {
+            let ((_, return_type), args) =
+                args_and_ret.split_last().expect("TypeRef::Fn is missing return type");
+            write!(buf, "fn(")?;
+            for (i, (_, typeref)) in args.iter().enumerate() {
+                if i != 0 {
+                    write!(buf, ", ")?;
+                }
+                print_type_ref(typeref, buf)?;
+            }
+            if *varargs {
+                if !args.is_empty() {
+                    write!(buf, ", ")?;
+                }
+                write!(buf, "...")?;
+            }
+            write!(buf, ") -> ")?;
+            print_type_ref(return_type, buf)?;
+        }
+        TypeRef::Macro(_ast_id) => {
+            write!(buf, "<macro>")?;
+        }
+        TypeRef::Error => write!(buf, "{{unknown}}")?,
+        TypeRef::ImplTrait(bounds) => {
+            write!(buf, "impl ")?;
+            print_type_bounds(bounds, buf)?;
+        }
+        TypeRef::DynTrait(bounds) => {
+            write!(buf, "dyn ")?;
+            print_type_bounds(bounds, buf)?;
+        }
+    }
+
+    Ok(())
+}
+
+pub(crate) fn print_type_bounds(
+    bounds: &[Interned<TypeBound>],
+    buf: &mut dyn Write,
+) -> fmt::Result {
+    for (i, bound) in bounds.iter().enumerate() {
+        if i != 0 {
+            write!(buf, " + ")?;
+        }
+
+        match bound.as_ref() {
+            TypeBound::Path(path, modifier) => {
+                match modifier {
+                    TraitBoundModifier::None => (),
+                    TraitBoundModifier::Maybe => write!(buf, "?")?,
+                }
+                print_path(path, buf)?;
+            }
+            TypeBound::ForLifetime(lifetimes, path) => {
+                write!(buf, "for<{}> ", lifetimes.iter().format(", "))?;
+                print_path(path, buf)?;
+            }
+            TypeBound::Lifetime(lt) => write!(buf, "{}", lt.name)?,
+            TypeBound::Error => write!(buf, "{{unknown}}")?,
+        }
+    }
+
+    Ok(())
+}
diff --git a/crates/hir-def/src/type_ref.rs b/crates/hir-def/src/type_ref.rs
index 9248059627d..5b4c71be7fb 100644
--- a/crates/hir-def/src/type_ref.rs
+++ b/crates/hir-def/src/type_ref.rs
@@ -77,6 +77,10 @@ impl Rawness {
             Rawness::Ref
         }
     }
+
+    pub fn is_raw(&self) -> bool {
+        matches!(self, Self::RawPtr)
+    }
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 8f984210e11..3561bdeba7f 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -72,7 +72,7 @@ use itertools::Itertools;
 use nameres::diagnostics::DefDiagnosticKind;
 use once_cell::unsync::Lazy;
 use rustc_hash::FxHashSet;
-use stdx::{format_to, impl_from, never};
+use stdx::{impl_from, never};
 use syntax::{
     ast::{self, HasAttrs as _, HasDocComments, HasName},
     AstNode, AstPtr, SmolStr, SyntaxNodePtr, TextRange, T,
@@ -1136,6 +1136,20 @@ impl DefWithBody {
         }
     }
 
+    fn id(&self) -> DefWithBodyId {
+        match self {
+            DefWithBody::Function(it) => it.id.into(),
+            DefWithBody::Static(it) => it.id.into(),
+            DefWithBody::Const(it) => it.id.into(),
+        }
+    }
+
+    /// A textual representation of the HIR of this def's body for debugging purposes.
+    pub fn debug_hir(self, db: &dyn HirDatabase) -> String {
+        let body = db.body(self.id());
+        body.pretty_print(db.upcast(), self.id())
+    }
+
     pub fn diagnostics(self, db: &dyn HirDatabase, acc: &mut Vec<AnyDiagnostic>) {
         let krate = self.module(db).id.krate();
 
@@ -1470,19 +1484,6 @@ impl Function {
         let def_map = db.crate_def_map(loc.krate(db).into());
         def_map.fn_as_proc_macro(self.id).map(|id| Macro { id: id.into() })
     }
-
-    /// A textual representation of the HIR of this function for debugging purposes.
-    pub fn debug_hir(self, db: &dyn HirDatabase) -> String {
-        let body = db.body(self.id.into());
-
-        let mut result = String::new();
-        format_to!(result, "HIR expressions in the body of `{}`:\n", self.name(db));
-        for (id, expr) in body.exprs.iter() {
-            format_to!(result, "{:?}: {:?}\n", id, expr);
-        }
-
-        result
-    }
 }
 
 // Note: logically, this belongs to `hir_ty`, but we are not using it there yet.
diff --git a/crates/ide/src/view_hir.rs b/crates/ide/src/view_hir.rs
index bf0835ed7e0..d2bbbf6d26a 100644
--- a/crates/ide/src/view_hir.rs
+++ b/crates/ide/src/view_hir.rs
@@ -1,4 +1,4 @@
-use hir::{Function, Semantics};
+use hir::{DefWithBody, Semantics};
 use ide_db::base_db::FilePosition;
 use ide_db::RootDatabase;
 use syntax::{algo::find_node_at_offset, ast, AstNode};
@@ -19,8 +19,12 @@ fn body_hir(db: &RootDatabase, position: FilePosition) -> Option<String> {
     let sema = Semantics::new(db);
     let source_file = sema.parse(position.file_id);
 
-    let function = find_node_at_offset::<ast::Fn>(source_file.syntax(), position.offset)?;
-
-    let function: Function = sema.to_def(&function)?;
-    Some(function.debug_hir(db))
+    let item = find_node_at_offset::<ast::Item>(source_file.syntax(), position.offset)?;
+    let def: DefWithBody = match item {
+        ast::Item::Fn(it) => sema.to_def(&it)?.into(),
+        ast::Item::Const(it) => sema.to_def(&it)?.into(),
+        ast::Item::Static(it) => sema.to_def(&it)?.into(),
+        _ => return None,
+    };
+    Some(def.debug_hir(db))
 }
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 1b793bb0b15..f58de9da1bf 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -433,7 +433,7 @@ export function syntaxTree(ctx: Ctx): Cmd {
 // The contents of the file come from the `TextDocumentContentProvider`
 export function viewHir(ctx: Ctx): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
-        readonly uri = vscode.Uri.parse("rust-analyzer-hir://viewHir/hir.txt");
+        readonly uri = vscode.Uri.parse("rust-analyzer-hir://viewHir/hir.rs");
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
         constructor() {
             vscode.workspace.onDidChangeTextDocument(
-- 
cgit 1.4.1-3-g733a5


From a0b257c9d91d00c054376facc6681f563f1a5e1b Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Tue, 16 Aug 2022 13:38:50 -0400
Subject: chore: remove unused `currentExtensionIsNightly()` in config.ts

---
 editors/code/src/config.ts | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 1c58040d58c..b83582a344a 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -5,8 +5,6 @@ import { log } from "./util";
 
 export type UpdatesChannel = "stable" | "nightly";
 
-const NIGHTLY_TAG = "nightly";
-
 export type RunnableEnvCfg =
     | undefined
     | Record<string, string>
@@ -175,10 +173,6 @@ export class Config {
             gotoTypeDef: this.get<boolean>("hover.actions.gotoTypeDef.enable"),
         };
     }
-
-    get currentExtensionIsNightly() {
-        return this.package.releaseTag === NIGHTLY_TAG;
-    }
 }
 
 export async function updateConfig(config: vscode.WorkspaceConfiguration) {
-- 
cgit 1.4.1-3-g733a5


From 23747419ca52414d3ecf6f69f1e530e47ab1e937 Mon Sep 17 00:00:00 2001
From: Dezhi Wu <wu543065657@163.com>
Date: Wed, 17 Aug 2022 21:44:58 +0800
Subject: fix: a bunch of typos

This PR will fix some typos detected by [typos].

There are also some other typos in the function names, variable names, and file
names, which I leave as they are. I'm more certain that typos in comments
should be fixed.

[typos]: https://github.com/crate-ci/typos
---
 crates/flycheck/src/lib.rs                                          | 2 +-
 crates/hir-def/src/nameres/proc_macro.rs                            | 2 +-
 crates/hir-expand/src/lib.rs                                        | 2 +-
 crates/ide-assists/src/handlers/extract_module.rs                   | 6 +++---
 .../src/handlers/replace_turbofish_with_explicit_type.rs            | 2 +-
 crates/ide-assists/src/utils/suggest_name.rs                        | 4 ++--
 crates/ide-completion/src/completions/postfix/format_like.rs        | 4 ++--
 crates/ide-completion/src/tests/flyimport.rs                        | 2 +-
 crates/ide-db/src/rename.rs                                         | 2 +-
 crates/ide-diagnostics/src/handlers/missing_match_arms.rs           | 2 +-
 crates/mbe/src/expander/matcher.rs                                  | 2 +-
 crates/project-model/src/lib.rs                                     | 2 +-
 crates/project-model/src/workspace.rs                               | 2 +-
 crates/rust-analyzer/src/bin/logger.rs                              | 2 +-
 crates/syntax/src/hacks.rs                                          | 2 +-
 crates/vfs/src/lib.rs                                               | 2 +-
 docs/dev/architecture.md                                            | 2 +-
 editors/code/src/commands.ts                                        | 2 +-
 editors/code/src/toolchain.ts                                       | 2 +-
 19 files changed, 23 insertions(+), 23 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 3347940ec6d..2bebea2fbfe 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -345,7 +345,7 @@ impl CargoActor {
         //
         // Because cargo only outputs one JSON object per line, we can
         // simply skip a line if it doesn't parse, which just ignores any
-        // erroneus output.
+        // erroneous output.
 
         let mut error = String::new();
         let mut read_at_least_one_message = false;
diff --git a/crates/hir-def/src/nameres/proc_macro.rs b/crates/hir-def/src/nameres/proc_macro.rs
index 5089ef2d817..52b79cd0fdd 100644
--- a/crates/hir-def/src/nameres/proc_macro.rs
+++ b/crates/hir-def/src/nameres/proc_macro.rs
@@ -45,7 +45,7 @@ impl Attrs {
                     kind: ProcMacroKind::CustomDerive { helpers: Box::new([]) },
                 }),
 
-                // `#[proc_macro_derive(Trait, attibutes(helper1, helper2, ...))]`
+                // `#[proc_macro_derive(Trait, attributes(helper1, helper2, ...))]`
                 [
                     TokenTree::Leaf(Leaf::Ident(trait_name)),
                     TokenTree::Leaf(Leaf::Punct(comma)),
diff --git a/crates/hir-expand/src/lib.rs b/crates/hir-expand/src/lib.rs
index f6b97fd5405..d753d88470c 100644
--- a/crates/hir-expand/src/lib.rs
+++ b/crates/hir-expand/src/lib.rs
@@ -616,7 +616,7 @@ impl ExpansionInfo {
 
         let token_id = match token_id_in_attr_input {
             Some(token_id) => token_id,
-            // the token is not inside an attribute's input so do the lookup in the macro_arg as ususal
+            // the token is not inside an attribute's input so do the lookup in the macro_arg as usual
             None => {
                 let relative_range =
                     token.value.text_range().checked_sub(self.arg.value.text_range().start())?;
diff --git a/crates/ide-assists/src/handlers/extract_module.rs b/crates/ide-assists/src/handlers/extract_module.rs
index b3c4d306ac1..897980c6650 100644
--- a/crates/ide-assists/src/handlers/extract_module.rs
+++ b/crates/ide-assists/src/handlers/extract_module.rs
@@ -29,7 +29,7 @@ use super::remove_unused_param::range_to_remove;
 
 // Assist: extract_module
 //
-// Extracts a selected region as seperate module. All the references, visibility and imports are
+// Extracts a selected region as separate module. All the references, visibility and imports are
 // resolved.
 //
 // ```
@@ -105,7 +105,7 @@ pub(crate) fn extract_module(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
             //
             //- Thirdly, resolving all the imports this includes removing paths from imports
             //  outside the module, shifting/cloning them inside new module, or shifting the imports, or making
-            //  new import statemnts
+            //  new import statements
 
             //We are getting item usages and record_fields together, record_fields
             //for change_visibility and usages for first point mentioned above in the process
@@ -661,7 +661,7 @@ fn check_intersection_and_push(
     import_path: TextRange,
 ) {
     if import_paths_to_be_removed.len() > 0 {
-        // Text ranges recieved here for imports are extended to the
+        // Text ranges received here for imports are extended to the
         // next/previous comma which can cause intersections among them
         // and later deletion of these can cause panics similar
         // to reported in #11766. So to mitigate it, we
diff --git a/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs b/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs
index 6112e09455a..5242f3b5100 100644
--- a/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs
+++ b/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs
@@ -88,7 +88,7 @@ pub(crate) fn replace_turbofish_with_explicit_type(
             },
         );
     } else if let Some(InferType(t)) = let_stmt.ty() {
-        // If there's a type inferrence underscore, we can offer to replace it with the type in
+        // If there's a type inference underscore, we can offer to replace it with the type in
         // the turbofish.
         // let x: _ = fn::<...>();
         let underscore_range = t.syntax().text_range();
diff --git a/crates/ide-assists/src/utils/suggest_name.rs b/crates/ide-assists/src/utils/suggest_name.rs
index 779cdbc93c5..662ddd063f3 100644
--- a/crates/ide-assists/src/utils/suggest_name.rs
+++ b/crates/ide-assists/src/utils/suggest_name.rs
@@ -75,7 +75,7 @@ pub(crate) fn for_generic_parameter(ty: &ast::ImplTraitType) -> SmolStr {
 /// In current implementation, the function tries to get the name from
 /// the following sources:
 ///
-/// * if expr is an argument to function/method, use paramter name
+/// * if expr is an argument to function/method, use parameter name
 /// * if expr is a function/method call, use function name
 /// * expression type name if it exists (E.g. `()`, `fn() -> ()` or `!` do not have names)
 /// * fallback: `var_name`
@@ -85,7 +85,7 @@ pub(crate) fn for_generic_parameter(ty: &ast::ImplTraitType) -> SmolStr {
 /// Currently it sticks to the first name found.
 // FIXME: Microoptimize and return a `SmolStr` here.
 pub(crate) fn for_variable(expr: &ast::Expr, sema: &Semantics<'_, RootDatabase>) -> String {
-    // `from_param` does not benifit from stripping
+    // `from_param` does not benefit from stripping
     // it need the largest context possible
     // so we check firstmost
     if let Some(name) = from_param(expr, sema) {
diff --git a/crates/ide-completion/src/completions/postfix/format_like.rs b/crates/ide-completion/src/completions/postfix/format_like.rs
index 6b94347e0ad..b273a4cb53b 100644
--- a/crates/ide-completion/src/completions/postfix/format_like.rs
+++ b/crates/ide-completion/src/completions/postfix/format_like.rs
@@ -173,7 +173,7 @@ impl FormatStrParser {
                     }
                 }
                 (State::Expr, ':') if chars.peek().copied() == Some(':') => {
-                    // path seperator
+                    // path separator
                     current_expr.push_str("::");
                     chars.next();
                 }
@@ -185,7 +185,7 @@ impl FormatStrParser {
                         current_expr = String::new();
                         self.state = State::FormatOpts;
                     } else {
-                        // We're inside of braced expression, assume that it's a struct field name/value delimeter.
+                        // We're inside of braced expression, assume that it's a struct field name/value delimiter.
                         current_expr.push(chr);
                     }
                 }
diff --git a/crates/ide-completion/src/tests/flyimport.rs b/crates/ide-completion/src/tests/flyimport.rs
index 0bba7f2459c..a63ef006875 100644
--- a/crates/ide-completion/src/tests/flyimport.rs
+++ b/crates/ide-completion/src/tests/flyimport.rs
@@ -159,7 +159,7 @@ pub mod some_module {
     pub struct ThiiiiiirdStruct;
     // contains all letters from the query, but not in the beginning, displayed second
     pub struct AfterThirdStruct;
-    // contains all letters from the query in the begginning, displayed first
+    // contains all letters from the query in the beginning, displayed first
     pub struct ThirdStruct;
 }
 
diff --git a/crates/ide-db/src/rename.rs b/crates/ide-db/src/rename.rs
index 517fe3f246d..49b81265ea5 100644
--- a/crates/ide-db/src/rename.rs
+++ b/crates/ide-db/src/rename.rs
@@ -82,7 +82,7 @@ impl Definition {
     }
 
     /// Textual range of the identifier which will change when renaming this
-    /// `Definition`. Note that some definitions, like buitin types, can't be
+    /// `Definition`. Note that some definitions, like builtin types, can't be
     /// renamed.
     pub fn range_for_rename(self, sema: &Semantics<'_, RootDatabase>) -> Option<FileRange> {
         let res = match self {
diff --git a/crates/ide-diagnostics/src/handlers/missing_match_arms.rs b/crates/ide-diagnostics/src/handlers/missing_match_arms.rs
index 9e66fbfb752..5fcaf405b14 100644
--- a/crates/ide-diagnostics/src/handlers/missing_match_arms.rs
+++ b/crates/ide-diagnostics/src/handlers/missing_match_arms.rs
@@ -750,7 +750,7 @@ fn main() {
 enum Foo { A }
 fn main() {
     // FIXME: this should not bail out but current behavior is such as the old algorithm.
-    // ExprValidator::validate_match(..) checks types of top level patterns incorrecly.
+    // ExprValidator::validate_match(..) checks types of top level patterns incorrectly.
     match Foo::A {
         ref _x => {}
         Foo::A => {}
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index 5020e9abaf3..c1aa14d6b7e 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -321,7 +321,7 @@ struct MatchState<'t> {
     /// The KleeneOp of this sequence if we are in a repetition.
     sep_kind: Option<RepeatKind>,
 
-    /// Number of tokens of seperator parsed
+    /// Number of tokens of separator parsed
     sep_parsed: Option<usize>,
 
     /// Matched meta variables bindings
diff --git a/crates/project-model/src/lib.rs b/crates/project-model/src/lib.rs
index e3f83084ac8..b81b7432f65 100644
--- a/crates/project-model/src/lib.rs
+++ b/crates/project-model/src/lib.rs
@@ -3,7 +3,7 @@
 //!
 //! Pure model is represented by the [`base_db::CrateGraph`] from another crate.
 //!
-//! In this crate, we are conserned with "real world" project models.
+//! In this crate, we are concerned with "real world" project models.
 //!
 //! Specifically, here we have a representation for a Cargo project
 //! ([`CargoWorkspace`]) and for manually specified layout ([`ProjectJson`]).
diff --git a/crates/project-model/src/workspace.rs b/crates/project-model/src/workspace.rs
index daabb299f76..8d6f50f5587 100644
--- a/crates/project-model/src/workspace.rs
+++ b/crates/project-model/src/workspace.rs
@@ -770,7 +770,7 @@ fn handle_rustc_crates(
         queue.push_back(root_pkg);
         while let Some(pkg) = queue.pop_front() {
             // Don't duplicate packages if they are dependended on a diamond pattern
-            // N.B. if this line is ommitted, we try to analyse over 4_800_000 crates
+            // N.B. if this line is omitted, we try to analyse over 4_800_000 crates
             // which is not ideal
             if rustc_pkg_crates.contains_key(&pkg) {
                 continue;
diff --git a/crates/rust-analyzer/src/bin/logger.rs b/crates/rust-analyzer/src/bin/logger.rs
index 0b69f75bc0d..298814af5a4 100644
--- a/crates/rust-analyzer/src/bin/logger.rs
+++ b/crates/rust-analyzer/src/bin/logger.rs
@@ -52,7 +52,7 @@ impl Logger {
         // merge chalk filter to our main filter (from RA_LOG env).
         //
         // The acceptable syntax of CHALK_DEBUG is `target[span{field=value}]=level`.
-        // As the value should only affect chalk crates, we'd better mannually
+        // As the value should only affect chalk crates, we'd better manually
         // specify the target. And for simplicity, CHALK_DEBUG only accept the value
         // that specify level.
         let chalk_level_dir = std::env::var("CHALK_DEBUG")
diff --git a/crates/syntax/src/hacks.rs b/crates/syntax/src/hacks.rs
index a047f61fa03..ec3d3d444c3 100644
--- a/crates/syntax/src/hacks.rs
+++ b/crates/syntax/src/hacks.rs
@@ -1,4 +1,4 @@
-//! Things which exist to solve practial issues, but which shouldn't exist.
+//! Things which exist to solve practical issues, but which shouldn't exist.
 //!
 //! Please avoid adding new usages of the functions in this module
 
diff --git a/crates/vfs/src/lib.rs b/crates/vfs/src/lib.rs
index 10fae41d081..7badb1c363b 100644
--- a/crates/vfs/src/lib.rs
+++ b/crates/vfs/src/lib.rs
@@ -64,7 +64,7 @@ pub struct FileId(pub u32);
 
 /// Storage for all files read by rust-analyzer.
 ///
-/// For more informations see the [crate-level](crate) documentation.
+/// For more information see the [crate-level](crate) documentation.
 #[derive(Default)]
 pub struct Vfs {
     interner: PathInterner,
diff --git a/docs/dev/architecture.md b/docs/dev/architecture.md
index 51e26c58a91..c173a239fea 100644
--- a/docs/dev/architecture.md
+++ b/docs/dev/architecture.md
@@ -485,7 +485,7 @@ Mind the code--architecture gap: at the moment, we are using fewer feature flags
 ### Serialization
 
 In Rust, it is easy (often too easy) to add serialization to any type by adding `#[derive(Serialize)]`.
-This easiness is misleading -- serializable types impose significant backwards compatability constraints.
+This easiness is misleading -- serializable types impose significant backwards compatibility constraints.
 If a type is serializable, then it is a part of some IPC boundary.
 You often don't control the other side of this boundary, so changing serializable types is hard.
 
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index f58de9da1bf..12f666401fd 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -655,7 +655,7 @@ function crateGraph(ctx: Ctx, full: boolean): Cmd {
                     html, body { margin:0; padding:0; overflow:hidden }
                     svg { position:fixed; top:0; left:0; height:100%; width:100% }
 
-                    /* Disable the graphviz backgroud and fill the polygons */
+                    /* Disable the graphviz background and fill the polygons */
                     .graph > polygon { display:none; }
                     :is(.node,.edge) polygon { fill: white; }
 
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index bac163da9f3..e1ca4954280 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -158,7 +158,7 @@ export const getPathForExecutable = memoizeAsync(
 
         try {
             // hmm, `os.homedir()` seems to be infallible
-            // it is not mentioned in docs and cannot be infered by the type signature...
+            // it is not mentioned in docs and cannot be inferred by the type signature...
             const standardPath = vscode.Uri.joinPath(
                 vscode.Uri.file(os.homedir()),
                 ".cargo",
-- 
cgit 1.4.1-3-g733a5


From 45b7b6a60a7404d093f4afe81a0da10824cef7b8 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Fri, 19 Aug 2022 08:52:31 +0200
Subject: Implement lsp extension for cancelling running flychecks

---
 crates/flycheck/src/lib.rs            | 26 +++++++++++++++++++++-----
 crates/rust-analyzer/src/handlers.rs  |  6 ++++++
 crates/rust-analyzer/src/lsp_ext.rs   |  8 ++++++++
 crates/rust-analyzer/src/main_loop.rs |  7 ++++---
 docs/dev/lsp-extensions.md            |  2 +-
 editors/code/package.json             |  5 +++++
 editors/code/src/commands.ts          |  6 ++++++
 editors/code/src/lsp_ext.ts           | 30 +++++++++++++++++-------------
 editors/code/src/main.ts              |  1 +
 9 files changed, 69 insertions(+), 22 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 2bebea2fbfe..c22945c81fc 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -77,8 +77,13 @@ impl FlycheckHandle {
     }
 
     /// Schedule a re-start of the cargo check worker.
-    pub fn update(&self) {
-        self.sender.send(Restart).unwrap();
+    pub fn restart(&self) {
+        self.sender.send(Restart::Yes).unwrap();
+    }
+
+    /// Stop this cargo check worker.
+    pub fn cancel(&self) {
+        self.sender.send(Restart::No).unwrap();
     }
 
     pub fn id(&self) -> usize {
@@ -122,7 +127,10 @@ pub enum Progress {
     DidCancel,
 }
 
-struct Restart;
+enum Restart {
+    Yes,
+    No,
+}
 
 struct FlycheckActor {
     id: usize,
@@ -149,6 +157,7 @@ impl FlycheckActor {
         config: FlycheckConfig,
         workspace_root: AbsPathBuf,
     ) -> FlycheckActor {
+        tracing::info!(%id, ?workspace_root, "Spawning flycheck");
         FlycheckActor { id, sender, config, workspace_root, cargo_handle: None }
     }
     fn progress(&self, progress: Progress) {
@@ -164,10 +173,13 @@ impl FlycheckActor {
     fn run(mut self, inbox: Receiver<Restart>) {
         while let Some(event) = self.next_event(&inbox) {
             match event {
-                Event::Restart(Restart) => {
+                Event::Restart(Restart::No) => {
+                    self.cancel_check_process();
+                }
+                Event::Restart(Restart::Yes) => {
                     // Cancel the previously spawned process
                     self.cancel_check_process();
-                    while let Ok(Restart) = inbox.recv_timeout(Duration::from_millis(50)) {}
+                    while let Ok(_) = inbox.recv_timeout(Duration::from_millis(50)) {}
 
                     let command = self.check_command();
                     tracing::debug!(?command, "will restart flycheck");
@@ -223,6 +235,10 @@ impl FlycheckActor {
 
     fn cancel_check_process(&mut self) {
         if let Some(cargo_handle) = self.cargo_handle.take() {
+            tracing::debug!(
+                command = ?self.check_command(),
+                "did  cancel flycheck"
+            );
             cargo_handle.cancel();
             self.progress(Progress::DidCancel);
         }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 6337d49c240..fdb3205b0a9 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -51,6 +51,12 @@ pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> Result<
     Ok(())
 }
 
+pub(crate) fn handle_cancel_flycheck(state: &mut GlobalState, _: ()) -> Result<()> {
+    let _p = profile::span("handle_stop_flycheck");
+    state.flycheck.iter().for_each(|flycheck| flycheck.cancel());
+    Ok(())
+}
+
 pub(crate) fn handle_analyzer_status(
     snap: GlobalStateSnapshot,
     params: lsp_ext::AnalyzerStatusParams,
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 5f0e108624b..e61c8b643d2 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -129,6 +129,14 @@ pub struct ExpandedMacro {
     pub expansion: String,
 }
 
+pub enum CancelFlycheck {}
+
+impl Request for CancelFlycheck {
+    type Params = ();
+    type Result = ();
+    const METHOD: &'static str = "rust-analyzer/cancelFlycheck";
+}
+
 pub enum MatchingBrace {}
 
 impl Request for MatchingBrace {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 77419998249..f187547019a 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -288,7 +288,7 @@ impl GlobalState {
 
             if became_quiescent {
                 // Project has loaded properly, kick off initial flycheck
-                self.flycheck.iter().for_each(FlycheckHandle::update);
+                self.flycheck.iter().for_each(FlycheckHandle::restart);
                 if self.config.prefill_caches() {
                     self.prime_caches_queue.request_op("became quiescent".to_string());
                 }
@@ -590,6 +590,7 @@ impl GlobalState {
             .on_sync_mut::<lsp_ext::ReloadWorkspace>(handlers::handle_workspace_reload)
             .on_sync_mut::<lsp_ext::MemoryUsage>(handlers::handle_memory_usage)
             .on_sync_mut::<lsp_ext::ShuffleCrateGraph>(handlers::handle_shuffle_crate_graph)
+            .on_sync_mut::<lsp_ext::CancelFlycheck>(handlers::handle_cancel_flycheck)
             .on_sync::<lsp_ext::JoinLines>(handlers::handle_join_lines)
             .on_sync::<lsp_ext::OnEnter>(handlers::handle_on_enter)
             .on_sync::<lsp_types::request::SelectionRangeRequest>(handlers::handle_selection_range)
@@ -779,7 +780,7 @@ impl GlobalState {
                             for (id, _) in workspace_ids.clone() {
                                 if id == flycheck.id() {
                                     updated = true;
-                                    flycheck.update();
+                                    flycheck.restart();
                                     continue;
                                 }
                             }
@@ -798,7 +799,7 @@ impl GlobalState {
                 // No specific flycheck was triggered, so let's trigger all of them.
                 if !updated {
                     for flycheck in &this.flycheck {
-                        flycheck.update();
+                        flycheck.restart();
                     }
                 }
                 Ok(())
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 5040643d34a..6d2c7d7b063 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: 2a188defec26cc7c
+lsp_ext.rs hash: 7b710095d773b978
 
 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/editors/code/package.json b/editors/code/package.json
index 0714b356fe0..2e38c057302 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -235,6 +235,11 @@
                 "command": "rust-analyzer.moveItemDown",
                 "title": "Move item down",
                 "category": "rust-analyzer"
+            },
+            {
+                "command": "rust-analyzer.cancelFlycheck",
+                "title": "Cancel running flychecks",
+                "category": "rust-analyzer"
             }
         ],
         "keybindings": [
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 12f666401fd..a21b304bbda 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -817,6 +817,12 @@ export function openDocs(ctx: Ctx): Cmd {
     };
 }
 
+export function cancelFlycheck(ctx: Ctx): Cmd {
+    return async () => {
+        await ctx.client.sendRequest(ra.cancelFlycheck);
+    };
+}
+
 export function resolveCodeAction(ctx: Ctx): Cmd {
     const client = ctx.client;
     return async (params: lc.CodeAction) => {
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index f80af78a74a..875261c48a6 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -75,6 +75,23 @@ export const expandMacro = new lc.RequestType<ExpandMacroParams, ExpandedMacro |
     "rust-analyzer/expandMacro"
 );
 
+export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, TestInfo[], void>(
+    "rust-analyzer/relatedTests"
+);
+
+export const cancelFlycheck = new lc.RequestType0<void, void>("rust-analyzer/cancelFlycheck");
+
+// Experimental extensions
+
+export interface SsrParams {
+    query: string;
+    parseOnly: boolean;
+    textDocument: lc.TextDocumentIdentifier;
+    position: lc.Position;
+    selections: readonly lc.Range[];
+}
+export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>("experimental/ssr");
+
 export interface MatchingBraceParams {
     textDocument: lc.TextDocumentIdentifier;
     positions: lc.Position[];
@@ -127,19 +144,6 @@ export interface TestInfo {
     runnable: Runnable;
 }
 
-export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, TestInfo[], void>(
-    "rust-analyzer/relatedTests"
-);
-
-export interface SsrParams {
-    query: string;
-    parseOnly: boolean;
-    textDocument: lc.TextDocumentIdentifier;
-    position: lc.Position;
-    selections: readonly lc.Range[];
-}
-export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>("experimental/ssr");
-
 export interface CommandLink extends lc.Command {
     /**
      * A tooltip for the command, when represented in the UI.
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index d78b711a47a..a9847dd2a65 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -163,6 +163,7 @@ async function initCommonContext(context: vscode.ExtensionContext, ctx: Ctx) {
     ctx.registerCommand("peekTests", commands.peekTests);
     ctx.registerCommand("moveItemUp", commands.moveItemUp);
     ctx.registerCommand("moveItemDown", commands.moveItemDown);
+    ctx.registerCommand("cancelFlycheck", commands.cancelFlycheck);
 
     defaultOnEnter.dispose();
     ctx.registerCommand("onEnter", commands.onEnter);
-- 
cgit 1.4.1-3-g733a5


From b19f78b022dfbbc5699ba4de9fd967fe8da628a0 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 22 Aug 2022 17:13:49 +0200
Subject: Remove auto-config patching from the VSCode client

---
 editors/code/src/client.ts |  6 ---
 editors/code/src/config.ts | 94 ----------------------------------------------
 2 files changed, 100 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 27ab31db8db..719d2734643 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -5,7 +5,6 @@ import * as Is from "vscode-languageclient/lib/common/utils/is";
 import { assert } from "./util";
 import { WorkspaceEdit } from "vscode";
 import { Workspace } from "./ctx";
-import { updateConfig } from "./config";
 import { substituteVariablesInEnv } from "./config";
 import { outputChannel, traceOutputChannel } from "./main";
 import { randomUUID } from "crypto";
@@ -86,11 +85,6 @@ export async function createClient(
 
     let initializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
 
-    // Update outdated user configs
-    await updateConfig(initializationOptions).catch((err) => {
-        void vscode.window.showErrorMessage(`Failed updating old config keys: ${err.message}`);
-    });
-
     if (workspace.kind === "Detached Files") {
         initializationOptions = {
             detachedFiles: workspace.files.map((file) => file.uri.fsPath),
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index b83582a344a..7e6d4ac2970 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -175,100 +175,6 @@ export class Config {
     }
 }
 
-export async function updateConfig(config: vscode.WorkspaceConfiguration) {
-    const renames = [
-        ["assist.allowMergingIntoGlobImports", "imports.merge.glob"],
-        ["assist.exprFillDefault", "assist.expressionFillDefault"],
-        ["assist.importEnforceGranularity", "imports.granularity.enforce"],
-        ["assist.importGranularity", "imports.granularity.group"],
-        ["assist.importMergeBehavior", "imports.granularity.group"],
-        ["assist.importMergeBehaviour", "imports.granularity.group"],
-        ["assist.importGroup", "imports.group.enable"],
-        ["assist.importPrefix", "imports.prefix"],
-        ["primeCaches.enable", "cachePriming.enable"],
-        ["cache.warmup", "cachePriming.enable"],
-        ["cargo.loadOutDirsFromCheck", "cargo.buildScripts.enable"],
-        ["cargo.runBuildScripts", "cargo.buildScripts.enable"],
-        ["cargo.runBuildScriptsCommand", "cargo.buildScripts.overrideCommand"],
-        ["cargo.useRustcWrapperForBuildScripts", "cargo.buildScripts.useRustcWrapper"],
-        ["completion.snippets", "completion.snippets.custom"],
-        ["diagnostics.enableExperimental", "diagnostics.experimental.enable"],
-        ["experimental.procAttrMacros", "procMacro.attributes.enable"],
-        ["highlighting.strings", "semanticHighlighting.strings.enable"],
-        ["highlightRelated.breakPoints", "highlightRelated.breakPoints.enable"],
-        ["highlightRelated.exitPoints", "highlightRelated.exitPoints.enable"],
-        ["highlightRelated.yieldPoints", "highlightRelated.yieldPoints.enable"],
-        ["highlightRelated.references", "highlightRelated.references.enable"],
-        ["hover.documentation", "hover.documentation.enable"],
-        ["hover.linksInHover", "hover.links.enable"],
-        ["hoverActions.linksInHover", "hover.links.enable"],
-        ["hoverActions.debug", "hover.actions.debug.enable"],
-        ["hoverActions.enable", "hover.actions.enable.enable"],
-        ["hoverActions.gotoTypeDef", "hover.actions.gotoTypeDef.enable"],
-        ["hoverActions.implementations", "hover.actions.implementations.enable"],
-        ["hoverActions.references", "hover.actions.references.enable"],
-        ["hoverActions.run", "hover.actions.run.enable"],
-        ["inlayHints.chainingHints", "inlayHints.chainingHints.enable"],
-        ["inlayHints.closureReturnTypeHints", "inlayHints.closureReturnTypeHints.enable"],
-        ["inlayHints.hideNamedConstructorHints", "inlayHints.typeHints.hideNamedConstructor"],
-        ["inlayHints.parameterHints", "inlayHints.parameterHints.enable"],
-        ["inlayHints.reborrowHints", "inlayHints.reborrowHints.enable"],
-        ["inlayHints.typeHints", "inlayHints.typeHints.enable"],
-        ["lruCapacity", "lru.capacity"],
-        ["runnables.cargoExtraArgs", "runnables.extraArgs"],
-        ["runnables.overrideCargo", "runnables.command"],
-        ["rustcSource", "rustc.source"],
-        ["rustfmt.enableRangeFormatting", "rustfmt.rangeFormatting.enable"],
-    ];
-
-    for (const [oldKey, newKey] of renames) {
-        const inspect = config.inspect(oldKey);
-        if (inspect !== undefined) {
-            const valMatrix = [
-                {
-                    val: inspect.globalValue,
-                    langVal: inspect.globalLanguageValue,
-                    target: vscode.ConfigurationTarget.Global,
-                },
-                {
-                    val: inspect.workspaceFolderValue,
-                    langVal: inspect.workspaceFolderLanguageValue,
-                    target: vscode.ConfigurationTarget.WorkspaceFolder,
-                },
-                {
-                    val: inspect.workspaceValue,
-                    langVal: inspect.workspaceLanguageValue,
-                    target: vscode.ConfigurationTarget.Workspace,
-                },
-            ];
-            for (const { val, langVal, target } of valMatrix) {
-                const patch = (val: unknown) => {
-                    // some of the updates we do only append "enable" or "custom"
-                    // that means on the next run we would find these again, but as objects with
-                    // these properties causing us to destroy the config
-                    // so filter those already updated ones out
-                    return (
-                        val !== undefined &&
-                        !(
-                            typeof val === "object" &&
-                            val !== null &&
-                            (oldKey === "completion.snippets" || !val.hasOwnProperty("custom"))
-                        )
-                    );
-                };
-                if (patch(val)) {
-                    await config.update(newKey, val, target, false);
-                    await config.update(oldKey, undefined, target, false);
-                }
-                if (patch(langVal)) {
-                    await config.update(newKey, langVal, target, true);
-                    await config.update(oldKey, undefined, target, true);
-                }
-            }
-        }
-    }
-}
-
 export function substituteVariablesInEnv(env: Env): Env {
     const missingDeps = new Set<string>();
     // vscode uses `env:ENV_NAME` for env vars resolution, and it's easier
-- 
cgit 1.4.1-3-g733a5


From 16a0eb1829b569e2d1e1046a60fd7e25aa35bfcf Mon Sep 17 00:00:00 2001
From: Jonas Schievink <jonas.schievink@ferrous-systems.com>
Date: Tue, 23 Aug 2022 15:45:02 +0200
Subject: Avoid error popup when using in Live Share

---
 editors/code/src/main.ts | 36 +++++++++++++++++++++++-------------
 1 file changed, 23 insertions(+), 13 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index a9847dd2a65..ae145234792 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -33,7 +33,7 @@ export function outputChannel() {
 }
 
 export interface RustAnalyzerExtensionApi {
-    client: lc.LanguageClient;
+    client?: lc.LanguageClient;
 }
 
 export async function activate(
@@ -48,6 +48,23 @@ export async function activate(
 }
 
 async function tryActivate(context: vscode.ExtensionContext): Promise<RustAnalyzerExtensionApi> {
+    // We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
+    // only those are in use.
+    // (r-a still somewhat works with Live Share, because commands are tunneled to the host)
+    const folders = (vscode.workspace.workspaceFolders || []).filter((folder) =>
+        folder.uri.scheme == "file"
+    );
+    const rustDocuments = vscode.workspace.textDocuments.filter((document) =>
+        isRustDocument(document)
+    );
+
+    if (folders.length == 0 && rustDocuments.length == 0) {
+        // FIXME: Ideally we would choose not to activate at all (and avoid registering
+        // non-functional editor commands), but VS Code doesn't seem to have a good way of doing
+        // that
+        return {};
+    }
+
     const config = new Config(context);
     const state = new PersistentState(context.globalState);
     const serverPath = await bootstrap(context, config, state).catch((err) => {
@@ -60,18 +77,11 @@ async function tryActivate(context: vscode.ExtensionContext): Promise<RustAnalyz
         throw new Error(message);
     });
 
-    if ((vscode.workspace.workspaceFolders || []).length === 0) {
-        const rustDocuments = vscode.workspace.textDocuments.filter((document) =>
-            isRustDocument(document)
-        );
-        if (rustDocuments.length > 0) {
-            ctx = await Ctx.create(config, context, serverPath, {
-                kind: "Detached Files",
-                files: rustDocuments,
-            });
-        } else {
-            throw new Error("no rust files are opened");
-        }
+    if (folders.length === 0) {
+        ctx = await Ctx.create(config, context, serverPath, {
+            kind: "Detached Files",
+            files: rustDocuments,
+        });
     } else {
         // Note: we try to start the server before we activate type hints so that it
         // registers its `onDidChangeDocument` handler before us.
-- 
cgit 1.4.1-3-g733a5


From dcbbb7f211771fc08281312310067469e58efa0b Mon Sep 17 00:00:00 2001
From: Jonas Schievink <jonas.schievink@ferrous-systems.com>
Date: Tue, 23 Aug 2022 15:56:02 +0200
Subject: ForGoT tO RuN prEttIeR¿
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 editors/code/src/main.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index ae145234792..e9b62e0cc25 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -51,14 +51,14 @@ async function tryActivate(context: vscode.ExtensionContext): Promise<RustAnalyz
     // We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
     // only those are in use.
     // (r-a still somewhat works with Live Share, because commands are tunneled to the host)
-    const folders = (vscode.workspace.workspaceFolders || []).filter((folder) =>
-        folder.uri.scheme == "file"
+    const folders = (vscode.workspace.workspaceFolders || []).filter(
+        (folder) => folder.uri.scheme === "file"
     );
     const rustDocuments = vscode.workspace.textDocuments.filter((document) =>
         isRustDocument(document)
     );
 
-    if (folders.length == 0 && rustDocuments.length == 0) {
+    if (folders.length === 0 && rustDocuments.length === 0) {
         // FIXME: Ideally we would choose not to activate at all (and avoid registering
         // non-functional editor commands), but VS Code doesn't seem to have a good way of doing
         // that
-- 
cgit 1.4.1-3-g733a5


From 10617938b1c9a0ee873762c6806483e0ead209f5 Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Thu, 25 Aug 2022 21:33:42 +0300
Subject: Remove unused UpdatesChannel type

---
 editors/code/src/config.ts | 2 --
 1 file changed, 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index b83582a344a..07e899eb0aa 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -3,8 +3,6 @@ import * as vscode from "vscode";
 import { Env } from "./client";
 import { log } from "./util";
 
-export type UpdatesChannel = "stable" | "nightly";
-
 export type RunnableEnvCfg =
     | undefined
     | Record<string, string>
-- 
cgit 1.4.1-3-g733a5


From 9ad0a8c4673059c22d2f55e14b8ee05f47237f80 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 28 Aug 2022 11:54:46 +0200
Subject: Move empty diagnostics workaround back into the server

---
 crates/rust-analyzer/src/main_loop.rs | 27 ++++++++++++++++++++++++++-
 editors/code/src/client.ts            | 16 ----------------
 2 files changed, 26 insertions(+), 17 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 122aba2f7d9..3cfbc2e4e45 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -328,8 +328,33 @@ impl GlobalState {
                 }
 
                 let uri = file_id_to_url(&self.vfs.read().0, file_id);
-                let diagnostics =
+                let mut diagnostics =
                     self.diagnostics.diagnostics_for(file_id).cloned().collect::<Vec<_>>();
+
+                // VSCode assumes diagnostic messages to be non-empty strings, so we need to patch
+                // empty diagnostics. Neither the docs of VSCode nor the LSP spec say whether
+                // diagnostic messages are actually allowed to be empty or not and patching this
+                // in the VSCode client does not work as the assertion happens in the protocol
+                // conversion. So this hack is here to stay, and will be considered a hack
+                // until the LSP decides to state that empty messages are allowed.
+
+                // See https://github.com/rust-lang/rust-analyzer/issues/11404
+                // See https://github.com/rust-lang/rust-analyzer/issues/13130
+                let patch_empty = |message: &mut String| {
+                    if message.is_empty() {
+                        *message = " ".to_string();
+                    }
+                };
+
+                for d in &mut diagnostics {
+                    patch_empty(&mut d.message);
+                    if let Some(dri) = &mut d.related_information {
+                        for dri in dri {
+                            patch_empty(&mut dri.message);
+                        }
+                    }
+                }
+
                 let version = from_proto::vfs_path(&uri)
                     .map(|path| self.mem_docs.get(&path).map(|it| it.version))
                     .unwrap_or_default();
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 719d2734643..05d4d08f70b 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -99,22 +99,6 @@ export async function createClient(
         traceOutputChannel: traceOutputChannel(),
         outputChannel: outputChannel(),
         middleware: {
-            async handleDiagnostics(uri, diagnostics, next) {
-                // Workaround for https://github.com/microsoft/vscode/issues/155531
-                for (const diagnostic of diagnostics) {
-                    if (!diagnostic.message) {
-                        diagnostic.message = " ";
-                    }
-                    if (diagnostic.relatedInformation) {
-                        for (const relatedInformation of diagnostic.relatedInformation) {
-                            if (!relatedInformation.message) {
-                                relatedInformation.message = " ";
-                            }
-                        }
-                    }
-                }
-                next(uri, diagnostics);
-            },
             async provideHover(
                 document: vscode.TextDocument,
                 position: vscode.Position,
-- 
cgit 1.4.1-3-g733a5


From 9c97997af939184d825b54cd25a0d0817a4fc8ac Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sat, 10 Sep 2022 11:50:55 +0200
Subject: Remove the toggleInlayHints command from VSCode

Inlay hints are no longer something specifc to r-a as it has been
upstreamed into the LSP, we don't have a reason to give the config
for this feature special treatment in regards to toggling. There are
plenty of other options out there in the VSCode marketplace to create
toggle commands/hotkeys for configurations in general which I believe
we should nudge people towards instead.
---
 editors/code/package.json    |  9 ---------
 editors/code/src/commands.ts | 24 ------------------------
 editors/code/src/main.ts     |  1 -
 3 files changed, 34 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index 767c5875bf7..023b4502091 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -206,11 +206,6 @@
                 "title": "Show RA Version",
                 "category": "rust-analyzer"
             },
-            {
-                "command": "rust-analyzer.toggleInlayHints",
-                "title": "Toggle inlay hints",
-                "category": "rust-analyzer"
-            },
             {
                 "command": "rust-analyzer.openDocs",
                 "title": "Open docs under cursor",
@@ -1633,10 +1628,6 @@
                     "command": "rust-analyzer.serverVersion",
                     "when": "inRustProject"
                 },
-                {
-                    "command": "rust-analyzer.toggleInlayHints",
-                    "when": "inRustProject"
-                },
                 {
                     "command": "rust-analyzer.openDocs",
                     "when": "inRustProject"
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index a21b304bbda..b9ad525e361 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -321,30 +321,6 @@ export function serverVersion(ctx: Ctx): Cmd {
     };
 }
 
-export function toggleInlayHints(_ctx: Ctx): Cmd {
-    return async () => {
-        const config = vscode.workspace.getConfiguration("editor.inlayHints", {
-            languageId: "rust",
-        });
-
-        const value = config.get("enabled");
-        let stringValue;
-        if (typeof value === "string") {
-            stringValue = value;
-        } else {
-            stringValue = value ? "on" : "off";
-        }
-        const nextValues: Record<string, string> = {
-            on: "off",
-            off: "on",
-            onUnlessPressed: "offUnlessPressed",
-            offUnlessPressed: "onUnlessPressed",
-        };
-        const nextValue = nextValues[stringValue] ?? "on";
-        await config.update("enabled", nextValue, vscode.ConfigurationTarget.Global);
-    };
-}
-
 // Opens the virtual file that will show the syntax tree
 //
 // The contents of the file come from the `TextDocumentContentProvider`
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index e9b62e0cc25..41bde4195e0 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -180,7 +180,6 @@ async function initCommonContext(context: vscode.ExtensionContext, ctx: Ctx) {
 
     ctx.registerCommand("ssr", commands.ssr);
     ctx.registerCommand("serverVersion", commands.serverVersion);
-    ctx.registerCommand("toggleInlayHints", commands.toggleInlayHints);
 
     // Internal commands which are invoked by the server.
     ctx.registerCommand("runSingle", commands.runSingle);
-- 
cgit 1.4.1-3-g733a5


From 5bbfea03ccada14bbaca6df6c0ef3760ac44a9a5 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Sat, 8 Oct 2022 23:18:11 +0100
Subject: fix: in VSCode, correctly resolve relative paths to errors

VS Code problem matcher are restricted to be static "regexes". You can't
create a problem matcher dynamically, and you can't use custom code in
lieu of problem matcher.

This creates a problem for rust/cargo compiler errors. They use paths
relative to the root of the Cargo workspace, but VS Code doesn't
necessary know where that root is.

Luckily, there's a way out: our current problem matcher is defined like
this:

    "fileLocation": [ "autoDetect", "${workspaceRoot}" ],

That means that relative pahts would be resoleved relative to workspace
root. VS Code allows to specify a command inside `${}`. So we can plug
custom logic there to fetch Cargo's workspace root!

And that's exactly what this PR is doing!
---
 editors/code/package.json    | 9 +++++++++
 editors/code/src/commands.ts | 4 ++++
 editors/code/src/ctx.ts      | 4 ++++
 editors/code/src/main.ts     | 1 +
 editors/code/src/run.ts      | 2 ++
 editors/code/src/tasks.ts    | 2 +-
 6 files changed, 21 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index f1dd3aa79ff..ccf62d002bb 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -1301,6 +1301,15 @@
                     "endsPattern": "^\\[Finished running\\b"
                 },
                 "pattern": "$rustc"
+            },
+            {
+                "name": "rustc-run",
+                "base": "$rustc",
+                "fileLocation": [
+                    "autoDetect",
+                    "${command:rust-analyzer.cargoWorkspaceRootForCurrentRun}"
+                ],
+                "pattern": "$rustc-run"
             }
         ],
         "colors": [
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index b9ad525e361..6b10073aa86 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -842,6 +842,7 @@ export function run(ctx: Ctx): Cmd {
         item.detail = "rerun";
         prevRunnable = item;
         const task = await createTask(item.runnable, ctx.config);
+        ctx.cargoWorkspaceRootForCurrentRun = item.cargoWorkspaceRoot;
         return await vscode.tasks.executeTask(task);
     };
 }
@@ -946,3 +947,6 @@ export function linkToCommand(ctx: Ctx): Cmd {
         }
     };
 }
+export function getCargoWorkspaceDir(ctx: Ctx): Cmd {
+    return async () => ctx.cargoWorkspaceRootForCurrentRun;
+}
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 26510011d43..b6c0eedfb16 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -17,6 +17,10 @@ export type Workspace =
       };
 
 export class Ctx {
+    // Helps VS Code to correctly link problems from runnables. This is used by
+    // `rust-analyzer.cargoWorkspaceRootForCurrentRun` command of $rustc-run problem matcher.
+    cargoWorkspaceRootForCurrentRun?: string = undefined;
+
     private constructor(
         readonly config: Config,
         private readonly extCtx: vscode.ExtensionContext,
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 41bde4195e0..6e6c2513dd9 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -189,6 +189,7 @@ async function initCommonContext(context: vscode.ExtensionContext, ctx: Ctx) {
     ctx.registerCommand("resolveCodeAction", commands.resolveCodeAction);
     ctx.registerCommand("applyActionGroup", commands.applyActionGroup);
     ctx.registerCommand("gotoLocation", commands.gotoLocation);
+    ctx.registerCommand("cargoWorkspaceRootForCurrentRun", commands.getCargoWorkspaceDir);
 
     ctx.registerCommand("linkToCommand", commands.linkToCommand);
 }
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index 22e5eda6827..100c0fe2d8c 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -89,12 +89,14 @@ export async function selectRunnable(
 
 export class RunnableQuickPick implements vscode.QuickPickItem {
     public label: string;
+    public cargoWorkspaceRoot?: string;
     public description?: string | undefined;
     public detail?: string | undefined;
     public picked?: boolean | undefined;
 
     constructor(public runnable: ra.Runnable) {
         this.label = runnable.label;
+        this.cargoWorkspaceRoot = runnable.args.workspaceRoot;
     }
 }
 
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index e6239deeb21..44697f95bab 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -128,7 +128,7 @@ export async function buildCargoTask(
         name,
         TASK_SOURCE,
         exec,
-        ["$rustc"]
+        ["$rustc-run"]
     );
 }
 
-- 
cgit 1.4.1-3-g733a5


From 983ae1b1c9b54bb82c5c7e90e98725d283d0889b Mon Sep 17 00:00:00 2001
From: HKalbasi <45197576+HKalbasi@users.noreply.github.com>
Date: Wed, 12 Oct 2022 20:40:49 +0330
Subject: Cast runnableEnv items to string

---
 editors/code/src/config.ts | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index a9c0f079b3d..d66aa52fadc 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -133,7 +133,21 @@ export class Config {
     }
 
     get runnableEnv() {
-        return this.get<RunnableEnvCfg>("runnableEnv");
+        const item = this.get<any>("runnableEnv");
+        if (!item) return item;
+        const fixRecord = (r: Record<string, any>) => {
+            for (const key in r) {
+                if (typeof r[key] !== 'string') {
+                    r[key] = String(r[key]);
+                }
+            }
+        };
+        if (item instanceof Array) {
+            item.forEach((x) => fixRecord(x.env));
+        } else {
+            fixRecord(item);
+        }
+        return item;
     }
 
     get restartServerOnConfigChange() {
-- 
cgit 1.4.1-3-g733a5


From 58e5452a9bd6adef56e7099b21862985c4c0151c Mon Sep 17 00:00:00 2001
From: HKalbasi <45197576+HKalbasi@users.noreply.github.com>
Date: Wed, 12 Oct 2022 14:14:59 -0700
Subject: fix formatting

---
 editors/code/src/config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index d66aa52fadc..15846a5e864 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -137,7 +137,7 @@ export class Config {
         if (!item) return item;
         const fixRecord = (r: Record<string, any>) => {
             for (const key in r) {
-                if (typeof r[key] !== 'string') {
+                if (typeof r[key] !== "string") {
                     r[key] = String(r[key]);
                 }
             }
-- 
cgit 1.4.1-3-g733a5


From 55fdcbe339a002099c17ba545fb593163fef2011 Mon Sep 17 00:00:00 2001
From: Jonas Schievink <jonasschievink@gmail.com>
Date: Fri, 14 Oct 2022 09:28:44 +0200
Subject: Revert "fix: in VSCode, correctly resolve relative paths to errors"

---
 editors/code/package.json    | 9 ---------
 editors/code/src/commands.ts | 4 ----
 editors/code/src/ctx.ts      | 4 ----
 editors/code/src/main.ts     | 1 -
 editors/code/src/run.ts      | 2 --
 editors/code/src/tasks.ts    | 2 +-
 6 files changed, 1 insertion(+), 21 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index ccf62d002bb..f1dd3aa79ff 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -1301,15 +1301,6 @@
                     "endsPattern": "^\\[Finished running\\b"
                 },
                 "pattern": "$rustc"
-            },
-            {
-                "name": "rustc-run",
-                "base": "$rustc",
-                "fileLocation": [
-                    "autoDetect",
-                    "${command:rust-analyzer.cargoWorkspaceRootForCurrentRun}"
-                ],
-                "pattern": "$rustc-run"
             }
         ],
         "colors": [
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 6b10073aa86..b9ad525e361 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -842,7 +842,6 @@ export function run(ctx: Ctx): Cmd {
         item.detail = "rerun";
         prevRunnable = item;
         const task = await createTask(item.runnable, ctx.config);
-        ctx.cargoWorkspaceRootForCurrentRun = item.cargoWorkspaceRoot;
         return await vscode.tasks.executeTask(task);
     };
 }
@@ -947,6 +946,3 @@ export function linkToCommand(ctx: Ctx): Cmd {
         }
     };
 }
-export function getCargoWorkspaceDir(ctx: Ctx): Cmd {
-    return async () => ctx.cargoWorkspaceRootForCurrentRun;
-}
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index b6c0eedfb16..26510011d43 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -17,10 +17,6 @@ export type Workspace =
       };
 
 export class Ctx {
-    // Helps VS Code to correctly link problems from runnables. This is used by
-    // `rust-analyzer.cargoWorkspaceRootForCurrentRun` command of $rustc-run problem matcher.
-    cargoWorkspaceRootForCurrentRun?: string = undefined;
-
     private constructor(
         readonly config: Config,
         private readonly extCtx: vscode.ExtensionContext,
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 6e6c2513dd9..41bde4195e0 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -189,7 +189,6 @@ async function initCommonContext(context: vscode.ExtensionContext, ctx: Ctx) {
     ctx.registerCommand("resolveCodeAction", commands.resolveCodeAction);
     ctx.registerCommand("applyActionGroup", commands.applyActionGroup);
     ctx.registerCommand("gotoLocation", commands.gotoLocation);
-    ctx.registerCommand("cargoWorkspaceRootForCurrentRun", commands.getCargoWorkspaceDir);
 
     ctx.registerCommand("linkToCommand", commands.linkToCommand);
 }
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index 100c0fe2d8c..22e5eda6827 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -89,14 +89,12 @@ export async function selectRunnable(
 
 export class RunnableQuickPick implements vscode.QuickPickItem {
     public label: string;
-    public cargoWorkspaceRoot?: string;
     public description?: string | undefined;
     public detail?: string | undefined;
     public picked?: boolean | undefined;
 
     constructor(public runnable: ra.Runnable) {
         this.label = runnable.label;
-        this.cargoWorkspaceRoot = runnable.args.workspaceRoot;
     }
 }
 
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index 44697f95bab..e6239deeb21 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -128,7 +128,7 @@ export async function buildCargoTask(
         name,
         TASK_SOURCE,
         exec,
-        ["$rustc-run"]
+        ["$rustc"]
     );
 }
 
-- 
cgit 1.4.1-3-g733a5


From d5f467aa4a6b28ffa6acb7673bfea472fdcd64c8 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 16 Oct 2022 17:11:24 +0200
Subject: Substitute some VSCode variables in the VSCode client

---
 editors/code/src/client.ts | 26 +++++++++++---
 editors/code/src/config.ts | 85 +++++++++++++++++++++++++++++++---------------
 2 files changed, 79 insertions(+), 32 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 05d4d08f70b..45a7970b217 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -5,7 +5,7 @@ import * as Is from "vscode-languageclient/lib/common/utils/is";
 import { assert } from "./util";
 import { WorkspaceEdit } from "vscode";
 import { Workspace } from "./ctx";
-import { substituteVariablesInEnv } from "./config";
+import { substituteVariablesInEnv, substituteVSCodeVariables } from "./config";
 import { outputChannel, traceOutputChannel } from "./main";
 import { randomUUID } from "crypto";
 
@@ -83,15 +83,17 @@ export async function createClient(
         debug: run,
     };
 
-    let initializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
+    let rawInitializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
 
     if (workspace.kind === "Detached Files") {
-        initializationOptions = {
+        rawInitializationOptions = {
             detachedFiles: workspace.files.map((file) => file.uri.fsPath),
-            ...initializationOptions,
+            ...rawInitializationOptions,
         };
     }
 
+    const initializationOptions = substituteVSCodeVariables(rawInitializationOptions);
+
     const clientOptions: lc.LanguageClientOptions = {
         documentSelector: [{ scheme: "file", language: "rust" }],
         initializationOptions,
@@ -99,6 +101,22 @@ export async function createClient(
         traceOutputChannel: traceOutputChannel(),
         outputChannel: outputChannel(),
         middleware: {
+            workspace: {
+                async configuration(
+                    params: lc.ConfigurationParams,
+                    token: vscode.CancellationToken,
+                    next: lc.ConfigurationRequest.HandlerSignature
+                ) {
+                    const resp = await next(params, token);
+                    if (resp && Array.isArray(resp)) {
+                        return resp.map((val) => {
+                            return substituteVSCodeVariables(val);
+                        });
+                    } else {
+                        return resp;
+                    }
+                },
+            },
             async provideHover(
                 document: vscode.TextDocument,
                 position: vscode.Position,
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 15846a5e864..199db6e30fc 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -1,4 +1,5 @@
-import path = require("path");
+import * as path from "path";
+import * as os from "os";
 import * as vscode from "vscode";
 import { Env } from "./client";
 import { log } from "./util";
@@ -187,6 +188,37 @@ export class Config {
     }
 }
 
+const VarRegex = new RegExp(/\$\{(.+?)\}/g);
+
+export function substituteVSCodeVariableInString(val: string): string {
+    return val.replaceAll(VarRegex, (substring: string, varName) => {
+        if (typeof varName === "string") {
+            return computeVscodeVar(varName) || substring;
+        } else {
+            return substring;
+        }
+    });
+}
+
+export function substituteVSCodeVariables(resp: any): any {
+    if (typeof resp === "string") {
+        return substituteVSCodeVariableInString(resp);
+    } else if (resp && Array.isArray(resp)) {
+        return resp.map((val) => {
+            return substituteVSCodeVariables(val);
+        });
+    } else if (resp && typeof resp === "object") {
+        const res: { [key: string]: any } = {};
+        for (const key in resp) {
+            const val = resp[key];
+            res[key] = substituteVSCodeVariables(val);
+        }
+        return res;
+    } else if (typeof resp === "function") {
+        return null;
+    }
+    return resp;
+}
 export function substituteVariablesInEnv(env: Env): Env {
     const missingDeps = new Set<string>();
     // vscode uses `env:ENV_NAME` for env vars resolution, and it's easier
@@ -233,7 +265,7 @@ export function substituteVariablesInEnv(env: Env): Env {
             }
         } else {
             envWithDeps[dep] = {
-                value: computeVscodeVar(dep),
+                value: computeVscodeVar(dep) || "${" + dep + "}",
                 deps: [],
             };
         }
@@ -264,37 +296,34 @@ export function substituteVariablesInEnv(env: Env): Env {
     return resolvedEnv;
 }
 
-function computeVscodeVar(varName: string): string {
+function computeVscodeVar(varName: string): string | null {
+    const workspaceFolder = () => {
+        const folders = vscode.workspace.workspaceFolders ?? [];
+        if (folders.length === 1) {
+            // TODO: support for remote workspaces?
+            return folders[0].uri.fsPath;
+        } else if (folders.length > 1) {
+            // could use currently opened document to detect the correct
+            // workspace. However, that would be determined by the document
+            // user has opened on Editor startup. Could lead to
+            // unpredictable workspace selection in practice.
+            // It's better to pick the first one
+            return folders[0].uri.fsPath;
+        } else {
+            // no workspace opened
+            return "";
+        }
+    };
     // https://code.visualstudio.com/docs/editor/variables-reference
     const supportedVariables: { [k: string]: () => string } = {
-        workspaceFolder: () => {
-            const folders = vscode.workspace.workspaceFolders ?? [];
-            if (folders.length === 1) {
-                // TODO: support for remote workspaces?
-                return folders[0].uri.fsPath;
-            } else if (folders.length > 1) {
-                // could use currently opened document to detect the correct
-                // workspace. However, that would be determined by the document
-                // user has opened on Editor startup. Could lead to
-                // unpredictable workspace selection in practice.
-                // It's better to pick the first one
-                return folders[0].uri.fsPath;
-            } else {
-                // no workspace opened
-                return "";
-            }
-        },
+        workspaceFolder,
 
         workspaceFolderBasename: () => {
-            const workspaceFolder = computeVscodeVar("workspaceFolder");
-            if (workspaceFolder) {
-                return path.basename(workspaceFolder);
-            } else {
-                return "";
-            }
+            return path.basename(workspaceFolder());
         },
 
         cwd: () => process.cwd(),
+        userHome: () => os.homedir(),
 
         // see
         // https://github.com/microsoft/vscode/blob/08ac1bb67ca2459496b272d8f4a908757f24f56f/src/vs/workbench/api/common/extHostVariableResolverService.ts#L81
@@ -308,7 +337,7 @@ function computeVscodeVar(varName: string): string {
     if (varName in supportedVariables) {
         return supportedVariables[varName]();
     } else {
-        // can't resolve, keep the expression as is
-        return "${" + varName + "}";
+        // return "${" + varName + "}";
+        return null;
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 6f435977df34e722b45d787d7eadac23cf5b040e Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 17 Oct 2022 14:20:14 +0200
Subject: Refactor language client handling

---
 editors/code/package-lock.json    |  78 +++++-----
 editors/code/package.json         |   4 +-
 editors/code/src/ast_inspector.ts |   8 +-
 editors/code/src/bootstrap.ts     | 148 +++++++++++++++++++
 editors/code/src/client.ts        |  43 ++----
 editors/code/src/commands.ts      | 183 ++++++++++++------------
 editors/code/src/ctx.ts           | 143 ++++++++++++++----
 editors/code/src/main.ts          | 294 +++++++-------------------------------
 8 files changed, 460 insertions(+), 441 deletions(-)
 create mode 100644 editors/code/src/bootstrap.ts

(limited to 'editors/code/src')

diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index 3ff4b6897a1..192d8fabc31 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -11,11 +11,11 @@
             "dependencies": {
                 "d3": "^7.6.1",
                 "d3-graphviz": "^4.1.1",
-                "vscode-languageclient": "^8.0.0-next.14"
+                "vscode-languageclient": "^8.0.2"
             },
             "devDependencies": {
                 "@types/node": "~16.11.7",
-                "@types/vscode": "~1.66.0",
+                "@types/vscode": "~1.72.0",
                 "@typescript-eslint/eslint-plugin": "^5.30.5",
                 "@typescript-eslint/parser": "^5.30.5",
                 "@vscode/test-electron": "^2.1.5",
@@ -141,9 +141,9 @@
             "dev": true
         },
         "node_modules/@types/vscode": {
-            "version": "1.66.0",
-            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.66.0.tgz",
-            "integrity": "sha512-ZfJck4M7nrGasfs4A4YbUoxis3Vu24cETw3DERsNYtDZmYSYtk6ljKexKFKhImO/ZmY6ZMsmegu2FPkXoUFImA==",
+            "version": "1.72.0",
+            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.72.0.tgz",
+            "integrity": "sha512-WvHluhUo+lQvE3I4wUagRpnkHuysB4qSyOQUyIAS9n9PYMJjepzTUD8Jyks0YeXoPD0UGctjqp2u84/b3v6Ydw==",
             "dev": true
         },
         "node_modules/@typescript-eslint/eslint-plugin": {
@@ -3791,39 +3791,39 @@
             }
         },
         "node_modules/vscode-jsonrpc": {
-            "version": "8.0.0-next.7",
-            "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.0.0-next.7.tgz",
-            "integrity": "sha512-JX/F31LEsims0dAlOTKFE4E+AJMiJvdRSRViifFJSqSN7EzeYyWlfuDchF7g91oRNPZOIWfibTkDf3/UMsQGzQ==",
+            "version": "8.0.2",
+            "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.0.2.tgz",
+            "integrity": "sha512-RY7HwI/ydoC1Wwg4gJ3y6LpU9FJRZAUnTYMXthqhFXXu77ErDd/xkREpGuk4MyYkk4a+XDWAMqe0S3KkelYQEQ==",
             "engines": {
                 "node": ">=14.0.0"
             }
         },
         "node_modules/vscode-languageclient": {
-            "version": "8.0.0-next.14",
-            "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-8.0.0-next.14.tgz",
-            "integrity": "sha512-NqjkOuDTMu8uo+PhoMsV72VO9Gd3wBi/ZpOrkRUOrWKQo7yUdiIw183g8wjH8BImgbK9ZP51HM7TI0ZhCnI1Mw==",
+            "version": "8.0.2",
+            "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-8.0.2.tgz",
+            "integrity": "sha512-lHlthJtphG9gibGb/y72CKqQUxwPsMXijJVpHEC2bvbFqxmkj9LwQ3aGU9dwjBLqsX1S4KjShYppLvg1UJDF/Q==",
             "dependencies": {
                 "minimatch": "^3.0.4",
                 "semver": "^7.3.5",
-                "vscode-languageserver-protocol": "3.17.0-next.16"
+                "vscode-languageserver-protocol": "3.17.2"
             },
             "engines": {
-                "vscode": "^1.66.0"
+                "vscode": "^1.67.0"
             }
         },
         "node_modules/vscode-languageserver-protocol": {
-            "version": "3.17.0-next.16",
-            "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.0-next.16.tgz",
-            "integrity": "sha512-tx4DnXw9u3N7vw+bx6n2NKp6FoxoNwiP/biH83AS30I2AnTGyLd7afSeH6Oewn2E8jvB7K15bs12sMppkKOVeQ==",
+            "version": "3.17.2",
+            "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.2.tgz",
+            "integrity": "sha512-8kYisQ3z/SQ2kyjlNeQxbkkTNmVFoQCqkmGrzLH6A9ecPlgTbp3wDTnUNqaUxYr4vlAcloxx8zwy7G5WdguYNg==",
             "dependencies": {
-                "vscode-jsonrpc": "8.0.0-next.7",
-                "vscode-languageserver-types": "3.17.0-next.9"
+                "vscode-jsonrpc": "8.0.2",
+                "vscode-languageserver-types": "3.17.2"
             }
         },
         "node_modules/vscode-languageserver-types": {
-            "version": "3.17.0-next.9",
-            "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.0-next.9.tgz",
-            "integrity": "sha512-9/PeDNPYduaoXRUzYpqmu4ZV9L01HGo0wH9FUt+sSHR7IXwA7xoXBfNUlv8gB9H0D2WwEmMomSy1NmhjKQyn3A=="
+            "version": "3.17.2",
+            "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.2.tgz",
+            "integrity": "sha512-zHhCWatviizPIq9B7Vh9uvrH6x3sK8itC84HkamnBWoDFJtzBf7SWlpLCZUit72b3os45h6RWQNC9xHRDF8dRA=="
         },
         "node_modules/which": {
             "version": "2.0.2",
@@ -4039,9 +4039,9 @@
             "dev": true
         },
         "@types/vscode": {
-            "version": "1.66.0",
-            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.66.0.tgz",
-            "integrity": "sha512-ZfJck4M7nrGasfs4A4YbUoxis3Vu24cETw3DERsNYtDZmYSYtk6ljKexKFKhImO/ZmY6ZMsmegu2FPkXoUFImA==",
+            "version": "1.72.0",
+            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.72.0.tgz",
+            "integrity": "sha512-WvHluhUo+lQvE3I4wUagRpnkHuysB4qSyOQUyIAS9n9PYMJjepzTUD8Jyks0YeXoPD0UGctjqp2u84/b3v6Ydw==",
             "dev": true
         },
         "@typescript-eslint/eslint-plugin": {
@@ -6634,33 +6634,33 @@
             }
         },
         "vscode-jsonrpc": {
-            "version": "8.0.0-next.7",
-            "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.0.0-next.7.tgz",
-            "integrity": "sha512-JX/F31LEsims0dAlOTKFE4E+AJMiJvdRSRViifFJSqSN7EzeYyWlfuDchF7g91oRNPZOIWfibTkDf3/UMsQGzQ=="
+            "version": "8.0.2",
+            "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.0.2.tgz",
+            "integrity": "sha512-RY7HwI/ydoC1Wwg4gJ3y6LpU9FJRZAUnTYMXthqhFXXu77ErDd/xkREpGuk4MyYkk4a+XDWAMqe0S3KkelYQEQ=="
         },
         "vscode-languageclient": {
-            "version": "8.0.0-next.14",
-            "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-8.0.0-next.14.tgz",
-            "integrity": "sha512-NqjkOuDTMu8uo+PhoMsV72VO9Gd3wBi/ZpOrkRUOrWKQo7yUdiIw183g8wjH8BImgbK9ZP51HM7TI0ZhCnI1Mw==",
+            "version": "8.0.2",
+            "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-8.0.2.tgz",
+            "integrity": "sha512-lHlthJtphG9gibGb/y72CKqQUxwPsMXijJVpHEC2bvbFqxmkj9LwQ3aGU9dwjBLqsX1S4KjShYppLvg1UJDF/Q==",
             "requires": {
                 "minimatch": "^3.0.4",
                 "semver": "^7.3.5",
-                "vscode-languageserver-protocol": "3.17.0-next.16"
+                "vscode-languageserver-protocol": "3.17.2"
             }
         },
         "vscode-languageserver-protocol": {
-            "version": "3.17.0-next.16",
-            "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.0-next.16.tgz",
-            "integrity": "sha512-tx4DnXw9u3N7vw+bx6n2NKp6FoxoNwiP/biH83AS30I2AnTGyLd7afSeH6Oewn2E8jvB7K15bs12sMppkKOVeQ==",
+            "version": "3.17.2",
+            "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.2.tgz",
+            "integrity": "sha512-8kYisQ3z/SQ2kyjlNeQxbkkTNmVFoQCqkmGrzLH6A9ecPlgTbp3wDTnUNqaUxYr4vlAcloxx8zwy7G5WdguYNg==",
             "requires": {
-                "vscode-jsonrpc": "8.0.0-next.7",
-                "vscode-languageserver-types": "3.17.0-next.9"
+                "vscode-jsonrpc": "8.0.2",
+                "vscode-languageserver-types": "3.17.2"
             }
         },
         "vscode-languageserver-types": {
-            "version": "3.17.0-next.9",
-            "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.0-next.9.tgz",
-            "integrity": "sha512-9/PeDNPYduaoXRUzYpqmu4ZV9L01HGo0wH9FUt+sSHR7IXwA7xoXBfNUlv8gB9H0D2WwEmMomSy1NmhjKQyn3A=="
+            "version": "3.17.2",
+            "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.2.tgz",
+            "integrity": "sha512-zHhCWatviizPIq9B7Vh9uvrH6x3sK8itC84HkamnBWoDFJtzBf7SWlpLCZUit72b3os45h6RWQNC9xHRDF8dRA=="
         },
         "which": {
             "version": "2.0.2",
diff --git a/editors/code/package.json b/editors/code/package.json
index f1dd3aa79ff..da4bac5ad84 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -37,11 +37,11 @@
     "dependencies": {
         "d3": "^7.6.1",
         "d3-graphviz": "^4.1.1",
-        "vscode-languageclient": "^8.0.0-next.14"
+        "vscode-languageclient": "^8.0.2"
     },
     "devDependencies": {
         "@types/node": "~16.11.7",
-        "@types/vscode": "~1.66.0",
+        "@types/vscode": "~1.72.0",
         "@typescript-eslint/eslint-plugin": "^5.30.5",
         "@typescript-eslint/parser": "^5.30.5",
         "@vscode/test-electron": "^2.1.5",
diff --git a/editors/code/src/ast_inspector.ts b/editors/code/src/ast_inspector.ts
index e57fb20e2cf..2a2c9326b6a 100644
--- a/editors/code/src/ast_inspector.ts
+++ b/editors/code/src/ast_inspector.ts
@@ -35,8 +35,10 @@ export class AstInspector implements vscode.HoverProvider, vscode.DefinitionProv
     });
 
     constructor(ctx: Ctx) {
-        ctx.pushCleanup(vscode.languages.registerHoverProvider({ scheme: "rust-analyzer" }, this));
-        ctx.pushCleanup(vscode.languages.registerDefinitionProvider({ language: "rust" }, this));
+        ctx.pushExtCleanup(
+            vscode.languages.registerHoverProvider({ scheme: "rust-analyzer" }, this)
+        );
+        ctx.pushExtCleanup(vscode.languages.registerDefinitionProvider({ language: "rust" }, this));
         vscode.workspace.onDidCloseTextDocument(
             this.onDidCloseTextDocument,
             this,
@@ -53,7 +55,7 @@ export class AstInspector implements vscode.HoverProvider, vscode.DefinitionProv
             ctx.subscriptions
         );
 
-        ctx.pushCleanup(this);
+        ctx.pushExtCleanup(this);
     }
     dispose() {
         this.setRustEditor(undefined);
diff --git a/editors/code/src/bootstrap.ts b/editors/code/src/bootstrap.ts
new file mode 100644
index 00000000000..374c3b8144c
--- /dev/null
+++ b/editors/code/src/bootstrap.ts
@@ -0,0 +1,148 @@
+import * as vscode from "vscode";
+import * as os from "os";
+import { Config } from "./config";
+import { log, isValidExecutable } from "./util";
+import { PersistentState } from "./persistent_state";
+import { exec } from "child_process";
+
+export async function bootstrap(
+    context: vscode.ExtensionContext,
+    config: Config,
+    state: PersistentState
+): Promise<string> {
+    const path = await getServer(context, config, state);
+    if (!path) {
+        throw new Error(
+            "Rust Analyzer Language Server is not available. " +
+                "Please, ensure its [proper installation](https://rust-analyzer.github.io/manual.html#installation)."
+        );
+    }
+
+    log.info("Using server binary at", path);
+
+    if (!isValidExecutable(path)) {
+        if (config.serverPath) {
+            throw new Error(`Failed to execute ${path} --version. \`config.server.path\` or \`config.serverPath\` has been set explicitly.\
+            Consider removing this config or making a valid server binary available at that path.`);
+        } else {
+            throw new Error(`Failed to execute ${path} --version`);
+        }
+    }
+
+    return path;
+}
+
+async function patchelf(dest: vscode.Uri): Promise<void> {
+    await vscode.window.withProgress(
+        {
+            location: vscode.ProgressLocation.Notification,
+            title: "Patching rust-analyzer for NixOS",
+        },
+        async (progress, _) => {
+            const expression = `
+            {srcStr, pkgs ? import <nixpkgs> {}}:
+                pkgs.stdenv.mkDerivation {
+                    name = "rust-analyzer";
+                    src = /. + srcStr;
+                    phases = [ "installPhase" "fixupPhase" ];
+                    installPhase = "cp $src $out";
+                    fixupPhase = ''
+                    chmod 755 $out
+                    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out
+                    '';
+                }
+            `;
+            const origFile = vscode.Uri.file(dest.fsPath + "-orig");
+            await vscode.workspace.fs.rename(dest, origFile, { overwrite: true });
+            try {
+                progress.report({ message: "Patching executable", increment: 20 });
+                await new Promise((resolve, reject) => {
+                    const handle = exec(
+                        `nix-build -E - --argstr srcStr '${origFile.fsPath}' -o '${dest.fsPath}'`,
+                        (err, stdout, stderr) => {
+                            if (err != null) {
+                                reject(Error(stderr));
+                            } else {
+                                resolve(stdout);
+                            }
+                        }
+                    );
+                    handle.stdin?.write(expression);
+                    handle.stdin?.end();
+                });
+            } finally {
+                await vscode.workspace.fs.delete(origFile);
+            }
+        }
+    );
+}
+
+async function getServer(
+    context: vscode.ExtensionContext,
+    config: Config,
+    state: PersistentState
+): Promise<string | undefined> {
+    const explicitPath = serverPath(config);
+    if (explicitPath) {
+        if (explicitPath.startsWith("~/")) {
+            return os.homedir() + explicitPath.slice("~".length);
+        }
+        return explicitPath;
+    }
+    if (config.package.releaseTag === null) return "rust-analyzer";
+
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const bundled = vscode.Uri.joinPath(context.extensionUri, "server", `rust-analyzer${ext}`);
+    const bundledExists = await vscode.workspace.fs.stat(bundled).then(
+        () => true,
+        () => false
+    );
+    if (bundledExists) {
+        let server = bundled;
+        if (await isNixOs()) {
+            await vscode.workspace.fs.createDirectory(config.globalStorageUri).then();
+            const dest = vscode.Uri.joinPath(config.globalStorageUri, `rust-analyzer${ext}`);
+            let exists = await vscode.workspace.fs.stat(dest).then(
+                () => true,
+                () => false
+            );
+            if (exists && config.package.version !== state.serverVersion) {
+                await vscode.workspace.fs.delete(dest);
+                exists = false;
+            }
+            if (!exists) {
+                await vscode.workspace.fs.copy(bundled, dest);
+                await patchelf(dest);
+            }
+            server = dest;
+        }
+        await state.updateServerVersion(config.package.version);
+        return server.fsPath;
+    }
+
+    await state.updateServerVersion(undefined);
+    await vscode.window.showErrorMessage(
+        "Unfortunately we don't ship binaries for your platform yet. " +
+            "You need to manually clone the rust-analyzer repository and " +
+            "run `cargo xtask install --server` to build the language server from sources. " +
+            "If you feel that your platform should be supported, please create an issue " +
+            "about that [here](https://github.com/rust-lang/rust-analyzer/issues) and we " +
+            "will consider it."
+    );
+    return undefined;
+}
+function serverPath(config: Config): string | null {
+    return process.env.__RA_LSP_SERVER_DEBUG ?? config.serverPath;
+}
+
+async function isNixOs(): Promise<boolean> {
+    try {
+        const contents = (
+            await vscode.workspace.fs.readFile(vscode.Uri.file("/etc/os-release"))
+        ).toString();
+        const idString = contents.split("\n").find((a) => a.startsWith("ID=")) || "ID=linux";
+        return idString.indexOf("nixos") !== -1;
+    } catch {
+        return false;
+    }
+}
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 45a7970b217..3408a2ee84e 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -4,9 +4,7 @@ import * as ra from "../src/lsp_ext";
 import * as Is from "vscode-languageclient/lib/common/utils/is";
 import { assert } from "./util";
 import { WorkspaceEdit } from "vscode";
-import { Workspace } from "./ctx";
-import { substituteVariablesInEnv, substituteVSCodeVariables } from "./config";
-import { outputChannel, traceOutputChannel } from "./main";
+import { substituteVSCodeVariables } from "./config";
 import { randomUUID } from "crypto";
 
 export interface Env {
@@ -65,41 +63,17 @@ function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownStri
 }
 
 export async function createClient(
-    serverPath: string,
-    workspace: Workspace,
-    extraEnv: Env
+    traceOutputChannel: vscode.OutputChannel,
+    outputChannel: vscode.OutputChannel,
+    initializationOptions: vscode.WorkspaceConfiguration,
+    serverOptions: lc.ServerOptions
 ): Promise<lc.LanguageClient> {
-    // '.' Is the fallback if no folder is open
-    // TODO?: Workspace folders support Uri's (eg: file://test.txt).
-    // It might be a good idea to test if the uri points to a file.
-
-    const newEnv = substituteVariablesInEnv(Object.assign({}, process.env, extraEnv));
-    const run: lc.Executable = {
-        command: serverPath,
-        options: { env: newEnv },
-    };
-    const serverOptions: lc.ServerOptions = {
-        run,
-        debug: run,
-    };
-
-    let rawInitializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
-
-    if (workspace.kind === "Detached Files") {
-        rawInitializationOptions = {
-            detachedFiles: workspace.files.map((file) => file.uri.fsPath),
-            ...rawInitializationOptions,
-        };
-    }
-
-    const initializationOptions = substituteVSCodeVariables(rawInitializationOptions);
-
     const clientOptions: lc.LanguageClientOptions = {
         documentSelector: [{ scheme: "file", language: "rust" }],
         initializationOptions,
         diagnosticCollectionName: "rustc",
-        traceOutputChannel: traceOutputChannel(),
-        outputChannel: outputChannel(),
+        traceOutputChannel,
+        outputChannel,
         middleware: {
             workspace: {
                 async configuration(
@@ -273,6 +247,9 @@ export async function createClient(
 }
 
 class ExperimentalFeatures implements lc.StaticFeature {
+    getState(): lc.FeatureState {
+        return { kind: "static" };
+    }
     fillClientCapabilities(capabilities: lc.ClientCapabilities): void {
         const caps: any = capabilities.experimental ?? {};
         caps.snippetTextEdit = true;
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index b9ad525e361..cbdeb28c99f 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -21,16 +21,16 @@ export function analyzerStatus(ctx: Ctx): Cmd {
         readonly uri = vscode.Uri.parse("rust-analyzer-status://status");
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
 
-        provideTextDocumentContent(_uri: vscode.Uri): vscode.ProviderResult<string> {
+        async provideTextDocumentContent(_uri: vscode.Uri): Promise<string> {
             if (!vscode.window.activeTextEditor) return "";
+            const client = await ctx.getClient();
 
             const params: ra.AnalyzerStatusParams = {};
             const doc = ctx.activeRustEditor?.document;
             if (doc != null) {
-                params.textDocument =
-                    ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(doc);
+                params.textDocument = client.code2ProtocolConverter.asTextDocumentIdentifier(doc);
             }
-            return ctx.client.sendRequest(ra.analyzerStatus, params);
+            return await client.sendRequest(ra.analyzerStatus, params);
         }
 
         get onDidChange(): vscode.Event<vscode.Uri> {
@@ -38,7 +38,7 @@ export function analyzerStatus(ctx: Ctx): Cmd {
         }
     })();
 
-    ctx.pushCleanup(
+    ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-status", tdcp)
     );
 
@@ -60,9 +60,14 @@ export function memoryUsage(ctx: Ctx): Cmd {
         provideTextDocumentContent(_uri: vscode.Uri): vscode.ProviderResult<string> {
             if (!vscode.window.activeTextEditor) return "";
 
-            return ctx.client.sendRequest(ra.memoryUsage).then((mem: any) => {
-                return "Per-query memory usage:\n" + mem + "\n(note: database has been cleared)";
-            });
+            return ctx
+                .getClient()
+                .then((it) => it.sendRequest(ra.memoryUsage))
+                .then((mem: any) => {
+                    return (
+                        "Per-query memory usage:\n" + mem + "\n(note: database has been cleared)"
+                    );
+                });
         }
 
         get onDidChange(): vscode.Event<vscode.Uri> {
@@ -70,7 +75,7 @@ export function memoryUsage(ctx: Ctx): Cmd {
         }
     })();
 
-    ctx.pushCleanup(
+    ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-memory", tdcp)
     );
 
@@ -83,23 +88,19 @@ export function memoryUsage(ctx: Ctx): Cmd {
 
 export function shuffleCrateGraph(ctx: Ctx): Cmd {
     return async () => {
-        const client = ctx.client;
-        if (!client) return;
-
-        await client.sendRequest(ra.shuffleCrateGraph);
+        return ctx.getClient().then((it) => it.sendRequest(ra.shuffleCrateGraph));
     };
 }
 
 export function matchingBrace(ctx: Ctx): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
-        const client = ctx.client;
-        if (!editor || !client) return;
+        if (!editor) return;
+
+        const client = await ctx.getClient();
 
         const response = await client.sendRequest(ra.matchingBrace, {
-            textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(
-                editor.document
-            ),
+            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
             positions: editor.selections.map((s) =>
                 client.code2ProtocolConverter.asPosition(s.active)
             ),
@@ -116,14 +117,13 @@ export function matchingBrace(ctx: Ctx): Cmd {
 export function joinLines(ctx: Ctx): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
-        const client = ctx.client;
-        if (!editor || !client) return;
+        if (!editor) return;
+
+        const client = await ctx.getClient();
 
         const items: lc.TextEdit[] = await client.sendRequest(ra.joinLines, {
             ranges: editor.selections.map((it) => client.code2ProtocolConverter.asRange(it)),
-            textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(
-                editor.document
-            ),
+            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
         });
         const textEdits = await client.protocol2CodeConverter.asTextEdits(items);
         await editor.edit((builder) => {
@@ -145,14 +145,12 @@ export function moveItemDown(ctx: Ctx): Cmd {
 export function moveItem(ctx: Ctx, direction: ra.Direction): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
-        const client = ctx.client;
-        if (!editor || !client) return;
+        if (!editor) return;
+        const client = await ctx.getClient();
 
         const lcEdits = await client.sendRequest(ra.moveItem, {
             range: client.code2ProtocolConverter.asRange(editor.selection),
-            textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(
-                editor.document
-            ),
+            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
             direction,
         });
 
@@ -166,13 +164,13 @@ export function moveItem(ctx: Ctx, direction: ra.Direction): Cmd {
 export function onEnter(ctx: Ctx): Cmd {
     async function handleKeypress() {
         const editor = ctx.activeRustEditor;
-        const client = ctx.client;
 
-        if (!editor || !client) return false;
+        if (!editor) return false;
 
+        const client = await ctx.getClient();
         const lcEdits = await client
             .sendRequest(ra.onEnter, {
-                textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(
+                textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
                     editor.document
                 ),
                 position: client.code2ProtocolConverter.asPosition(editor.selection.active),
@@ -198,14 +196,13 @@ export function onEnter(ctx: Ctx): Cmd {
 export function parentModule(ctx: Ctx): Cmd {
     return async () => {
         const editor = vscode.window.activeTextEditor;
-        const client = ctx.client;
-        if (!editor || !client) return;
+        if (!editor) return;
         if (!(isRustDocument(editor.document) || isCargoTomlDocument(editor.document))) return;
 
+        const client = await ctx.getClient();
+
         const locations = await client.sendRequest(ra.parentModule, {
-            textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(
-                editor.document
-            ),
+            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
             position: client.code2ProtocolConverter.asPosition(editor.selection.active),
         });
         if (!locations) return;
@@ -236,13 +233,11 @@ export function parentModule(ctx: Ctx): Cmd {
 export function openCargoToml(ctx: Ctx): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
-        const client = ctx.client;
-        if (!editor || !client) return;
+        if (!editor) return;
 
+        const client = await ctx.getClient();
         const response = await client.sendRequest(ra.openCargoToml, {
-            textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(
-                editor.document
-            ),
+            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
         });
         if (!response) return;
 
@@ -259,12 +254,13 @@ export function openCargoToml(ctx: Ctx): Cmd {
 export function ssr(ctx: Ctx): Cmd {
     return async () => {
         const editor = vscode.window.activeTextEditor;
-        const client = ctx.client;
-        if (!editor || !client) return;
+        if (!editor) return;
+
+        const client = await ctx.getClient();
 
         const position = editor.selection.active;
         const selections = editor.selections;
-        const textDocument = ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(
+        const textDocument = client.code2ProtocolConverter.asTextDocumentIdentifier(
             editor.document
         );
 
@@ -354,21 +350,22 @@ export function syntaxTree(ctx: Ctx): Cmd {
             }
         }
 
-        provideTextDocumentContent(
+        async provideTextDocumentContent(
             uri: vscode.Uri,
             ct: vscode.CancellationToken
-        ): vscode.ProviderResult<string> {
+        ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
             if (!rustEditor) return "";
+            const client = await ctx.getClient();
 
             // When the range based query is enabled we take the range of the selection
             const range =
                 uri.query === "range=true" && !rustEditor.selection.isEmpty
-                    ? ctx.client.code2ProtocolConverter.asRange(rustEditor.selection)
+                    ? client.code2ProtocolConverter.asRange(rustEditor.selection)
                     : null;
 
             const params = { textDocument: { uri: rustEditor.document.uri.toString() }, range };
-            return ctx.client.sendRequest(ra.syntaxTree, params, ct);
+            return client.sendRequest(ra.syntaxTree, params, ct);
         }
 
         get onDidChange(): vscode.Event<vscode.Uri> {
@@ -378,10 +375,10 @@ export function syntaxTree(ctx: Ctx): Cmd {
 
     void new AstInspector(ctx);
 
-    ctx.pushCleanup(
+    ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-syntax-tree", tdcp)
     );
-    ctx.pushCleanup(
+    ctx.pushExtCleanup(
         vscode.languages.setLanguageConfiguration("ra_syntax_tree", {
             brackets: [["[", ")"]],
         })
@@ -437,14 +434,14 @@ export function viewHir(ctx: Ctx): Cmd {
             }
         }
 
-        provideTextDocumentContent(
+        async provideTextDocumentContent(
             _uri: vscode.Uri,
             ct: vscode.CancellationToken
-        ): vscode.ProviderResult<string> {
+        ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
-            const client = ctx.client;
-            if (!rustEditor || !client) return "";
+            if (!rustEditor) return "";
 
+            const client = await ctx.getClient();
             const params = {
                 textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
                     rustEditor.document
@@ -459,7 +456,7 @@ export function viewHir(ctx: Ctx): Cmd {
         }
     })();
 
-    ctx.pushCleanup(
+    ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-hir", tdcp)
     );
 
@@ -503,13 +500,13 @@ export function viewFileText(ctx: Ctx): Cmd {
             }
         }
 
-        provideTextDocumentContent(
+        async provideTextDocumentContent(
             _uri: vscode.Uri,
             ct: vscode.CancellationToken
-        ): vscode.ProviderResult<string> {
+        ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
-            const client = ctx.client;
-            if (!rustEditor || !client) return "";
+            if (!rustEditor) return "";
+            const client = await ctx.getClient();
 
             const params = client.code2ProtocolConverter.asTextDocumentIdentifier(
                 rustEditor.document
@@ -522,7 +519,7 @@ export function viewFileText(ctx: Ctx): Cmd {
         }
     })();
 
-    ctx.pushCleanup(
+    ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-file-text", tdcp)
     );
 
@@ -566,13 +563,13 @@ export function viewItemTree(ctx: Ctx): Cmd {
             }
         }
 
-        provideTextDocumentContent(
+        async provideTextDocumentContent(
             _uri: vscode.Uri,
             ct: vscode.CancellationToken
-        ): vscode.ProviderResult<string> {
+        ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
-            const client = ctx.client;
-            if (!rustEditor || !client) return "";
+            if (!rustEditor) return "";
+            const client = await ctx.getClient();
 
             const params = {
                 textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
@@ -587,7 +584,7 @@ export function viewItemTree(ctx: Ctx): Cmd {
         }
     })();
 
-    ctx.pushCleanup(
+    ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-item-tree", tdcp)
     );
 
@@ -618,8 +615,8 @@ function crateGraph(ctx: Ctx, full: boolean): Cmd {
         const params = {
             full: full,
         };
-
-        const dot = await ctx.client.sendRequest(ra.viewCrateGraph, params);
+        const client = await ctx.getClient();
+        const dot = await client.sendRequest(ra.viewCrateGraph, params);
         const uri = panel.webview.asWebviewUri(nodeModulesPath);
 
         const html = `
@@ -690,13 +687,13 @@ export function expandMacro(ctx: Ctx): Cmd {
         eventEmitter = new vscode.EventEmitter<vscode.Uri>();
         async provideTextDocumentContent(_uri: vscode.Uri): Promise<string> {
             const editor = vscode.window.activeTextEditor;
-            const client = ctx.client;
-            if (!editor || !client) return "";
+            if (!editor) return "";
+            const client = await ctx.getClient();
 
             const position = editor.selection.active;
 
             const expanded = await client.sendRequest(ra.expandMacro, {
-                textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(
+                textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
                     editor.document
                 ),
                 position,
@@ -712,7 +709,7 @@ export function expandMacro(ctx: Ctx): Cmd {
         }
     })();
 
-    ctx.pushCleanup(
+    ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-expand-macro", tdcp)
     );
 
@@ -724,11 +721,11 @@ export function expandMacro(ctx: Ctx): Cmd {
 }
 
 export function reloadWorkspace(ctx: Ctx): Cmd {
-    return async () => ctx.client.sendRequest(ra.reloadWorkspace);
+    return async () => (await ctx.getClient()).sendRequest(ra.reloadWorkspace);
 }
 
 async function showReferencesImpl(
-    client: LanguageClient,
+    client: LanguageClient | undefined,
     uri: string,
     position: lc.Position,
     locations: lc.Location[]
@@ -745,7 +742,7 @@ async function showReferencesImpl(
 
 export function showReferences(ctx: Ctx): Cmd {
     return async (uri: string, position: lc.Position, locations: lc.Location[]) => {
-        await showReferencesImpl(ctx.client, uri, position, locations);
+        await showReferencesImpl(await ctx.getClient(), uri, position, locations);
     };
 }
 
@@ -762,25 +759,23 @@ export function applyActionGroup(_ctx: Ctx): Cmd {
 
 export function gotoLocation(ctx: Ctx): Cmd {
     return async (locationLink: lc.LocationLink) => {
-        const client = ctx.client;
-        if (client) {
-            const uri = client.protocol2CodeConverter.asUri(locationLink.targetUri);
-            let range = client.protocol2CodeConverter.asRange(locationLink.targetSelectionRange);
-            // collapse the range to a cursor position
-            range = range.with({ end: range.start });
+        const client = await ctx.getClient();
+        const uri = client.protocol2CodeConverter.asUri(locationLink.targetUri);
+        let range = client.protocol2CodeConverter.asRange(locationLink.targetSelectionRange);
+        // collapse the range to a cursor position
+        range = range.with({ end: range.start });
 
-            await vscode.window.showTextDocument(uri, { selection: range });
-        }
+        await vscode.window.showTextDocument(uri, { selection: range });
     };
 }
 
 export function openDocs(ctx: Ctx): Cmd {
     return async () => {
-        const client = ctx.client;
         const editor = vscode.window.activeTextEditor;
-        if (!editor || !client) {
+        if (!editor) {
             return;
         }
+        const client = await ctx.getClient();
 
         const position = editor.selection.active;
         const textDocument = { uri: editor.document.uri.toString() };
@@ -795,20 +790,21 @@ export function openDocs(ctx: Ctx): Cmd {
 
 export function cancelFlycheck(ctx: Ctx): Cmd {
     return async () => {
-        await ctx.client.sendRequest(ra.cancelFlycheck);
+        const client = await ctx.getClient();
+        await client.sendRequest(ra.cancelFlycheck);
     };
 }
 
 export function resolveCodeAction(ctx: Ctx): Cmd {
-    const client = ctx.client;
     return async (params: lc.CodeAction) => {
+        const client = await ctx.getClient();
         params.command = undefined;
-        const item = await client.sendRequest(lc.CodeActionResolveRequest.type, params);
-        if (!item.edit) {
+        const item = await client?.sendRequest(lc.CodeActionResolveRequest.type, params);
+        if (!item?.edit) {
             return;
         }
         const itemEdit = item.edit;
-        const edit = await client.protocol2CodeConverter.asWorkspaceEdit(itemEdit);
+        const edit = await client?.protocol2CodeConverter.asWorkspaceEdit(itemEdit);
         // filter out all text edits and recreate the WorkspaceEdit without them so we can apply
         // snippet edits on our own
         const lcFileSystemEdit = {
@@ -847,11 +843,10 @@ export function run(ctx: Ctx): Cmd {
 }
 
 export function peekTests(ctx: Ctx): Cmd {
-    const client = ctx.client;
-
     return async () => {
         const editor = ctx.activeRustEditor;
-        if (!editor || !client) return;
+        if (!editor) return;
+        const client = await ctx.getClient();
 
         await vscode.window.withProgress(
             {
@@ -937,10 +932,10 @@ export function newDebugConfig(ctx: Ctx): Cmd {
     };
 }
 
-export function linkToCommand(ctx: Ctx): Cmd {
+export function linkToCommand(_: Ctx): Cmd {
     return async (commandId: string) => {
         const link = LINKED_COMMANDS.get(commandId);
-        if (ctx.client && link) {
+        if (link) {
             const { command, arguments: args = [] } = link;
             await vscode.commands.executeCommand(command, ...args);
         }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 26510011d43..d4f5ab3c88c 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -2,9 +2,9 @@ import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 
-import { Config } from "./config";
+import { Config, substituteVariablesInEnv, substituteVSCodeVariables } from "./config";
 import { createClient } from "./client";
-import { isRustEditor, RustEditor } from "./util";
+import { isRustEditor, log, RustEditor } from "./util";
 import { ServerStatusParams } from "./lsp_ext";
 
 export type Workspace =
@@ -17,35 +17,118 @@ export type Workspace =
       };
 
 export class Ctx {
-    private constructor(
-        readonly config: Config,
-        private readonly extCtx: vscode.ExtensionContext,
-        readonly client: lc.LanguageClient,
-        readonly serverPath: string,
-        readonly statusBar: vscode.StatusBarItem
-    ) {}
-
-    static async create(
+    private client: lc.LanguageClient | undefined;
+    readonly config: Config;
+    serverPath: string;
+    readonly statusBar: vscode.StatusBarItem;
+
+    traceOutputChannel: vscode.OutputChannel | undefined;
+    outputChannel: vscode.OutputChannel | undefined;
+
+    serverOptions:
+        | {
+              run: lc.Executable;
+              debug: lc.Executable;
+          }
+        | undefined;
+    workspace: Workspace;
+
+    constructor(
+        readonly extCtx: vscode.ExtensionContext,
         config: Config,
-        extCtx: vscode.ExtensionContext,
         serverPath: string,
         workspace: Workspace
-    ): Promise<Ctx> {
-        const client = await createClient(serverPath, workspace, config.serverExtraEnv);
-
-        const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
-        extCtx.subscriptions.push(statusBar);
-        statusBar.text = "rust-analyzer";
-        statusBar.tooltip = "ready";
-        statusBar.command = "rust-analyzer.analyzerStatus";
-        statusBar.show();
-
-        const res = new Ctx(config, extCtx, client, serverPath, statusBar);
-
-        res.pushCleanup(client.start());
-        await client.onReady();
-        client.onNotification(ra.serverStatus, (params) => res.setServerStatus(params));
-        return res;
+    ) {
+        this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
+        extCtx.subscriptions.push(this.statusBar);
+        extCtx.subscriptions.push({
+            dispose() {
+                this.dispose();
+            },
+        });
+        this.statusBar.text = "rust-analyzer";
+        this.statusBar.tooltip = "ready";
+        this.statusBar.command = "rust-analyzer.analyzerStatus";
+        this.statusBar.show();
+        this.serverPath = serverPath;
+        this.config = config;
+        this.workspace = workspace;
+    }
+
+    clientFetcher() {
+        return {
+            get client(): lc.LanguageClient | undefined {
+                return this.client;
+            },
+        };
+    }
+
+    async getClient() {
+        if (!this.traceOutputChannel) {
+            this.traceOutputChannel = vscode.window.createOutputChannel(
+                "Rust Analyzer Language Server Trace"
+            );
+        }
+        if (!this.outputChannel) {
+            this.outputChannel = vscode.window.createOutputChannel("Rust Analyzer Language Server");
+        }
+        if (!this.serverOptions) {
+            log.info("Creating server options client");
+            const newEnv = substituteVariablesInEnv(
+                Object.assign({}, process.env, this.config.serverExtraEnv)
+            );
+            const run: lc.Executable = {
+                command: this.serverPath,
+                options: { env: newEnv },
+            };
+            this.serverOptions = {
+                run,
+                debug: run,
+            };
+        } else {
+            this.serverOptions.run.command = this.serverPath;
+            this.serverOptions.debug.command = this.serverPath;
+        }
+        if (!this.client) {
+            log.info("Creating language client");
+            let rawInitializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
+
+            if (this.workspace.kind === "Detached Files") {
+                rawInitializationOptions = {
+                    detachedFiles: this.workspace.files.map((file) => file.uri.fsPath),
+                    ...rawInitializationOptions,
+                };
+            }
+
+            const initializationOptions = substituteVSCodeVariables(rawInitializationOptions);
+
+            this.client = await createClient(
+                this.traceOutputChannel,
+                this.outputChannel,
+                initializationOptions,
+                this.serverOptions
+            );
+            this.client.onNotification(ra.serverStatus, (params) => this.setServerStatus(params));
+        }
+        return this.client;
+    }
+
+    async activate() {
+        log.info("Activating language client");
+        const client = await this.getClient();
+        await client.start();
+        return client;
+    }
+
+    async deactivate() {
+        log.info("Deactivating language client");
+        await this.client?.stop();
+    }
+
+    async disposeClient() {
+        log.info("Deactivating language client");
+        await this.client?.dispose();
+        this.client = undefined;
     }
 
     get activeRustEditor(): RustEditor | undefined {
@@ -61,7 +144,7 @@ export class Ctx {
         const fullName = `rust-analyzer.${name}`;
         const cmd = factory(this);
         const d = vscode.commands.registerCommand(fullName, cmd);
-        this.pushCleanup(d);
+        this.pushExtCleanup(d);
     }
 
     get extensionPath(): string {
@@ -111,7 +194,7 @@ export class Ctx {
         statusBar.text = `${icon}rust-analyzer`;
     }
 
-    pushCleanup(d: Disposable) {
+    pushExtCleanup(d: Disposable) {
         this.extCtx.subscriptions.push(d);
     }
 }
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 41bde4195e0..4ff27e0b551 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -1,53 +1,36 @@
 import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
-import * as os from "os";
 
 import * as commands from "./commands";
-import { Ctx } from "./ctx";
-import { Config } from "./config";
-import { log, isValidExecutable, isRustDocument } from "./util";
+import { Ctx, Workspace } from "./ctx";
+import { log, isRustDocument } from "./util";
 import { PersistentState } from "./persistent_state";
 import { activateTaskProvider } from "./tasks";
 import { setContextValue } from "./util";
-import { exec } from "child_process";
-
-let ctx: Ctx | undefined;
+import { bootstrap } from "./bootstrap";
+import { Config } from "./config";
 
 const RUST_PROJECT_CONTEXT_NAME = "inRustProject";
 
-let TRACE_OUTPUT_CHANNEL: vscode.OutputChannel | null = null;
-export function traceOutputChannel() {
-    if (!TRACE_OUTPUT_CHANNEL) {
-        TRACE_OUTPUT_CHANNEL = vscode.window.createOutputChannel(
-            "Rust Analyzer Language Server Trace"
-        );
-    }
-    return TRACE_OUTPUT_CHANNEL;
-}
-let OUTPUT_CHANNEL: vscode.OutputChannel | null = null;
-export function outputChannel() {
-    if (!OUTPUT_CHANNEL) {
-        OUTPUT_CHANNEL = vscode.window.createOutputChannel("Rust Analyzer Language Server");
-    }
-    return OUTPUT_CHANNEL;
-}
-
 export interface RustAnalyzerExtensionApi {
-    client?: lc.LanguageClient;
+    // FIXME: this should be non-optional
+    readonly client?: lc.LanguageClient;
 }
 
 export async function activate(
     context: vscode.ExtensionContext
 ): Promise<RustAnalyzerExtensionApi> {
-    // VS Code doesn't show a notification when an extension fails to activate
-    // so we do it ourselves.
-    return await tryActivate(context).catch((err) => {
-        void vscode.window.showErrorMessage(`Cannot activate rust-analyzer: ${err.message}`);
-        throw err;
-    });
-}
+    if (vscode.extensions.getExtension("rust-lang.rust")) {
+        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.",
+                "Got it"
+            )
+            .then(() => {}, console.error);
+    }
 
-async function tryActivate(context: vscode.ExtensionContext): Promise<RustAnalyzerExtensionApi> {
     // We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
     // only those are in use.
     // (r-a still somewhat works with Live Share, because commands are tunneled to the host)
@@ -65,8 +48,17 @@ async function tryActivate(context: vscode.ExtensionContext): Promise<RustAnalyz
         return {};
     }
 
-    const config = new Config(context);
+    const workspace: Workspace =
+        folders.length === 0
+            ? {
+                  kind: "Detached Files",
+                  files: rustDocuments,
+              }
+            : { kind: "Workspace Folder" };
+
     const state = new PersistentState(context.globalState);
+    const config = new Config(context);
+
     const serverPath = await bootstrap(context, config, state).catch((err) => {
         let message = "bootstrap error. ";
 
@@ -77,42 +69,43 @@ async function tryActivate(context: vscode.ExtensionContext): Promise<RustAnalyz
         throw new Error(message);
     });
 
-    if (folders.length === 0) {
-        ctx = await Ctx.create(config, context, serverPath, {
-            kind: "Detached Files",
-            files: rustDocuments,
-        });
-    } else {
-        // Note: we try to start the server before we activate type hints so that it
-        // registers its `onDidChangeDocument` handler before us.
-        //
-        // This a horribly, horribly wrong way to deal with this problem.
-        ctx = await Ctx.create(config, context, serverPath, { kind: "Workspace Folder" });
-        ctx.pushCleanup(activateTaskProvider(ctx.config));
+    const ctx = new Ctx(context, config, serverPath, workspace);
+    // VS Code doesn't show a notification when an extension fails to activate
+    // so we do it ourselves.
+    return await activateServer(ctx).catch((err) => {
+        void vscode.window.showErrorMessage(`Cannot activate rust-analyzer: ${err.message}`);
+        throw err;
+    });
+}
+
+async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
+    if (ctx.workspace.kind === "Workspace Folder") {
+        ctx.pushExtCleanup(activateTaskProvider(ctx.config));
     }
-    await initCommonContext(context, ctx);
 
-    warnAboutExtensionConflicts();
+    await ctx.activate();
+    await initCommonContext(ctx);
 
-    if (config.typingContinueCommentsOnNewline) {
-        ctx.pushCleanup(configureLanguage());
+    if (ctx.config.typingContinueCommentsOnNewline) {
+        ctx.pushExtCleanup(configureLanguage());
     }
 
     vscode.workspace.onDidChangeConfiguration(
         (_) =>
-            ctx?.client
-                ?.sendNotification("workspace/didChangeConfiguration", { settings: "" })
+            ctx
+                .getClient()
+                .then((it) =>
+                    it.sendNotification("workspace/didChangeConfiguration", { settings: "" })
+                )
                 .catch(log.error),
         null,
         ctx.subscriptions
     );
 
-    return {
-        client: ctx.client,
-    };
+    return ctx.clientFetcher();
 }
 
-async function initCommonContext(context: vscode.ExtensionContext, ctx: Ctx) {
+async function initCommonContext(ctx: Ctx) {
     // Register a "dumb" onEnter command for the case where server fails to
     // start.
     //
@@ -130,24 +123,15 @@ async function initCommonContext(context: vscode.ExtensionContext, ctx: Ctx) {
     const defaultOnEnter = vscode.commands.registerCommand("rust-analyzer.onEnter", () =>
         vscode.commands.executeCommand("default:type", { text: "\n" })
     );
-    context.subscriptions.push(defaultOnEnter);
+    ctx.pushExtCleanup(defaultOnEnter);
 
     await setContextValue(RUST_PROJECT_CONTEXT_NAME, true);
 
     // Commands which invokes manually via command palette, shortcut, etc.
-
-    // Reloading is inspired by @DanTup maneuver: https://github.com/microsoft/vscode/issues/45774#issuecomment-373423895
     ctx.registerCommand("reload", (_) => async () => {
         void vscode.window.showInformationMessage("Reloading rust-analyzer...");
-        await doDeactivate();
-        while (context.subscriptions.length > 0) {
-            try {
-                context.subscriptions.pop()!.dispose();
-            } catch (err) {
-                log.error("Dispose error:", err);
-            }
-        }
-        await activate(context).catch(log.error);
+        await ctx.disposeClient();
+        await ctx.activate();
     });
 
     ctx.registerCommand("analyzerStatus", commands.analyzerStatus);
@@ -175,9 +159,6 @@ async function initCommonContext(context: vscode.ExtensionContext, ctx: Ctx) {
     ctx.registerCommand("moveItemDown", commands.moveItemDown);
     ctx.registerCommand("cancelFlycheck", commands.cancelFlycheck);
 
-    defaultOnEnter.dispose();
-    ctx.registerCommand("onEnter", commands.onEnter);
-
     ctx.registerCommand("ssr", commands.ssr);
     ctx.registerCommand("serverVersion", commands.serverVersion);
 
@@ -191,176 +172,9 @@ async function initCommonContext(context: vscode.ExtensionContext, ctx: Ctx) {
     ctx.registerCommand("gotoLocation", commands.gotoLocation);
 
     ctx.registerCommand("linkToCommand", commands.linkToCommand);
-}
 
-export async function deactivate() {
-    TRACE_OUTPUT_CHANNEL?.dispose();
-    TRACE_OUTPUT_CHANNEL = null;
-    OUTPUT_CHANNEL?.dispose();
-    OUTPUT_CHANNEL = null;
-    await doDeactivate();
-}
-
-async function doDeactivate() {
-    await setContextValue(RUST_PROJECT_CONTEXT_NAME, undefined);
-    await ctx?.client.stop();
-    ctx = undefined;
-}
-
-async function bootstrap(
-    context: vscode.ExtensionContext,
-    config: Config,
-    state: PersistentState
-): Promise<string> {
-    const path = await getServer(context, config, state);
-    if (!path) {
-        throw new Error(
-            "Rust Analyzer Language Server is not available. " +
-                "Please, ensure its [proper installation](https://rust-analyzer.github.io/manual.html#installation)."
-        );
-    }
-
-    log.info("Using server binary at", path);
-
-    if (!isValidExecutable(path)) {
-        if (config.serverPath) {
-            throw new Error(`Failed to execute ${path} --version. \`config.server.path\` or \`config.serverPath\` has been set explicitly.\
-            Consider removing this config or making a valid server binary available at that path.`);
-        } else {
-            throw new Error(`Failed to execute ${path} --version`);
-        }
-    }
-
-    return path;
-}
-
-async function patchelf(dest: vscode.Uri): Promise<void> {
-    await vscode.window.withProgress(
-        {
-            location: vscode.ProgressLocation.Notification,
-            title: "Patching rust-analyzer for NixOS",
-        },
-        async (progress, _) => {
-            const expression = `
-            {srcStr, pkgs ? import <nixpkgs> {}}:
-                pkgs.stdenv.mkDerivation {
-                    name = "rust-analyzer";
-                    src = /. + srcStr;
-                    phases = [ "installPhase" "fixupPhase" ];
-                    installPhase = "cp $src $out";
-                    fixupPhase = ''
-                    chmod 755 $out
-                    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out
-                    '';
-                }
-            `;
-            const origFile = vscode.Uri.file(dest.fsPath + "-orig");
-            await vscode.workspace.fs.rename(dest, origFile, { overwrite: true });
-            try {
-                progress.report({ message: "Patching executable", increment: 20 });
-                await new Promise((resolve, reject) => {
-                    const handle = exec(
-                        `nix-build -E - --argstr srcStr '${origFile.fsPath}' -o '${dest.fsPath}'`,
-                        (err, stdout, stderr) => {
-                            if (err != null) {
-                                reject(Error(stderr));
-                            } else {
-                                resolve(stdout);
-                            }
-                        }
-                    );
-                    handle.stdin?.write(expression);
-                    handle.stdin?.end();
-                });
-            } finally {
-                await vscode.workspace.fs.delete(origFile);
-            }
-        }
-    );
-}
-
-async function getServer(
-    context: vscode.ExtensionContext,
-    config: Config,
-    state: PersistentState
-): Promise<string | undefined> {
-    const explicitPath = serverPath(config);
-    if (explicitPath) {
-        if (explicitPath.startsWith("~/")) {
-            return os.homedir() + explicitPath.slice("~".length);
-        }
-        return explicitPath;
-    }
-    if (config.package.releaseTag === null) return "rust-analyzer";
-
-    const ext = process.platform === "win32" ? ".exe" : "";
-    const bundled = vscode.Uri.joinPath(context.extensionUri, "server", `rust-analyzer${ext}`);
-    const bundledExists = await vscode.workspace.fs.stat(bundled).then(
-        () => true,
-        () => false
-    );
-    if (bundledExists) {
-        let server = bundled;
-        if (await isNixOs()) {
-            await vscode.workspace.fs.createDirectory(config.globalStorageUri).then();
-            const dest = vscode.Uri.joinPath(config.globalStorageUri, `rust-analyzer${ext}`);
-            let exists = await vscode.workspace.fs.stat(dest).then(
-                () => true,
-                () => false
-            );
-            if (exists && config.package.version !== state.serverVersion) {
-                await vscode.workspace.fs.delete(dest);
-                exists = false;
-            }
-            if (!exists) {
-                await vscode.workspace.fs.copy(bundled, dest);
-                await patchelf(dest);
-            }
-            server = dest;
-        }
-        await state.updateServerVersion(config.package.version);
-        return server.fsPath;
-    }
-
-    await state.updateServerVersion(undefined);
-    await vscode.window.showErrorMessage(
-        "Unfortunately we don't ship binaries for your platform yet. " +
-            "You need to manually clone the rust-analyzer repository and " +
-            "run `cargo xtask install --server` to build the language server from sources. " +
-            "If you feel that your platform should be supported, please create an issue " +
-            "about that [here](https://github.com/rust-lang/rust-analyzer/issues) and we " +
-            "will consider it."
-    );
-    return undefined;
-}
-
-function serverPath(config: Config): string | null {
-    return process.env.__RA_LSP_SERVER_DEBUG ?? config.serverPath;
-}
-
-async function isNixOs(): Promise<boolean> {
-    try {
-        const contents = (
-            await vscode.workspace.fs.readFile(vscode.Uri.file("/etc/os-release"))
-        ).toString();
-        const idString = contents.split("\n").find((a) => a.startsWith("ID=")) || "ID=linux";
-        return idString.indexOf("nixos") !== -1;
-    } catch {
-        return false;
-    }
-}
-
-function warnAboutExtensionConflicts() {
-    if (vscode.extensions.getExtension("rust-lang.rust")) {
-        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.",
-                "Got it"
-            )
-            .then(() => {}, console.error);
-    }
+    defaultOnEnter.dispose();
+    ctx.registerCommand("onEnter", commands.onEnter);
 }
 
 /**
-- 
cgit 1.4.1-3-g733a5


From 8aaafddee8ad709438a663084e6eec8f458bfd50 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 17 Oct 2022 14:53:46 +0200
Subject: Properly reload changed configs for server start

---
 editors/code/src/commands.ts |  4 +++
 editors/code/src/config.ts   |  4 +--
 editors/code/src/ctx.ts      | 58 +++++++++++++++++++++++---------------------
 editors/code/src/main.ts     | 42 ++++++++++++--------------------
 4 files changed, 51 insertions(+), 57 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index cbdeb28c99f..cb088fc6c68 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -310,6 +310,10 @@ export function ssr(ctx: Ctx): Cmd {
 
 export function serverVersion(ctx: Ctx): Cmd {
     return async () => {
+        if (!ctx.serverPath) {
+            void vscode.window.showWarningMessage(`rust-analyzer server is not running`);
+            return;
+        }
         const { stdout } = spawnSync(ctx.serverPath, ["--version"], { encoding: "utf8" });
         const versionString = stdout.slice(`rust-analyzer `.length).trim();
 
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 199db6e30fc..10e243dc896 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -14,8 +14,6 @@ export class Config {
 
     readonly rootSection = "rust-analyzer";
     private readonly requiresWorkspaceReloadOpts = [
-        "serverPath",
-        "server",
         // FIXME: This shouldn't be here, changing this setting should reload
         // `continueCommentsOnNewline` behavior without restart
         "typing",
@@ -23,6 +21,8 @@ export class Config {
     private readonly requiresReloadOpts = [
         "cargo",
         "procMacro",
+        "serverPath",
+        "server",
         "files",
         "lens", // works as lens.*
     ]
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index d4f5ab3c88c..f62ccd1a652 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -6,6 +6,8 @@ import { Config, substituteVariablesInEnv, substituteVSCodeVariables } from "./c
 import { createClient } from "./client";
 import { isRustEditor, log, RustEditor } from "./util";
 import { ServerStatusParams } from "./lsp_ext";
+import { PersistentState } from "./persistent_state";
+import { bootstrap } from "./bootstrap";
 
 export type Workspace =
     | {
@@ -17,28 +19,18 @@ export type Workspace =
       };
 
 export class Ctx {
-    private client: lc.LanguageClient | undefined;
-    readonly config: Config;
-    serverPath: string;
     readonly statusBar: vscode.StatusBarItem;
+    readonly config: Config;
+
+    private client: lc.LanguageClient | undefined;
 
     traceOutputChannel: vscode.OutputChannel | undefined;
     outputChannel: vscode.OutputChannel | undefined;
-
-    serverOptions:
-        | {
-              run: lc.Executable;
-              debug: lc.Executable;
-          }
-        | undefined;
     workspace: Workspace;
+    state: PersistentState;
+    serverPath: string | undefined;
 
-    constructor(
-        readonly extCtx: vscode.ExtensionContext,
-        config: Config,
-        serverPath: string,
-        workspace: Workspace
-    ) {
+    constructor(readonly extCtx: vscode.ExtensionContext, workspace: Workspace) {
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
         extCtx.subscriptions.push(this.statusBar);
         extCtx.subscriptions.push({
@@ -50,9 +42,10 @@ export class Ctx {
         this.statusBar.tooltip = "ready";
         this.statusBar.command = "rust-analyzer.analyzerStatus";
         this.statusBar.show();
-        this.serverPath = serverPath;
-        this.config = config;
         this.workspace = workspace;
+
+        this.state = new PersistentState(extCtx.globalState);
+        this.config = new Config(extCtx);
     }
 
     clientFetcher() {
@@ -64,6 +57,7 @@ export class Ctx {
     }
 
     async getClient() {
+        // if server path changes -> dispose
         if (!this.traceOutputChannel) {
             this.traceOutputChannel = vscode.window.createOutputChannel(
                 "Rust Analyzer Language Server Trace"
@@ -72,8 +66,20 @@ export class Ctx {
         if (!this.outputChannel) {
             this.outputChannel = vscode.window.createOutputChannel("Rust Analyzer Language Server");
         }
-        if (!this.serverOptions) {
-            log.info("Creating server options client");
+
+        if (!this.client) {
+            log.info("Creating language client");
+
+            this.serverPath = await bootstrap(this.extCtx, this.config, this.state).catch((err) => {
+                let message = "bootstrap error. ";
+
+                message +=
+                    'See the logs in "OUTPUT > Rust Analyzer Client" (should open automatically). ';
+                message += 'To enable verbose logs use { "rust-analyzer.trace.extension": true }';
+
+                log.error("Bootstrap error", err);
+                throw new Error(message);
+            });
             const newEnv = substituteVariablesInEnv(
                 Object.assign({}, process.env, this.config.serverExtraEnv)
             );
@@ -81,16 +87,11 @@ export class Ctx {
                 command: this.serverPath,
                 options: { env: newEnv },
             };
-            this.serverOptions = {
+            const serverOptions = {
                 run,
                 debug: run,
             };
-        } else {
-            this.serverOptions.run.command = this.serverPath;
-            this.serverOptions.debug.command = this.serverPath;
-        }
-        if (!this.client) {
-            log.info("Creating language client");
+
             let rawInitializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
 
             if (this.workspace.kind === "Detached Files") {
@@ -106,7 +107,7 @@ export class Ctx {
                 this.traceOutputChannel,
                 this.outputChannel,
                 initializationOptions,
-                this.serverOptions
+                serverOptions
             );
             this.client.onNotification(ra.serverStatus, (params) => this.setServerStatus(params));
         }
@@ -128,6 +129,7 @@ export class Ctx {
     async disposeClient() {
         log.info("Deactivating language client");
         await this.client?.dispose();
+        this.serverPath = undefined;
         this.client = undefined;
     }
 
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 4ff27e0b551..84f0a5810f9 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -3,12 +3,9 @@ import * as lc from "vscode-languageclient/node";
 
 import * as commands from "./commands";
 import { Ctx, Workspace } from "./ctx";
-import { log, isRustDocument } from "./util";
-import { PersistentState } from "./persistent_state";
+import { isRustDocument } from "./util";
 import { activateTaskProvider } from "./tasks";
 import { setContextValue } from "./util";
-import { bootstrap } from "./bootstrap";
-import { Config } from "./config";
 
 const RUST_PROJECT_CONTEXT_NAME = "inRustProject";
 
@@ -56,24 +53,13 @@ export async function activate(
               }
             : { kind: "Workspace Folder" };
 
-    const state = new PersistentState(context.globalState);
-    const config = new Config(context);
-
-    const serverPath = await bootstrap(context, config, state).catch((err) => {
-        let message = "bootstrap error. ";
-
-        message += 'See the logs in "OUTPUT > Rust Analyzer Client" (should open automatically). ';
-        message += 'To enable verbose logs use { "rust-analyzer.trace.extension": true }';
-
-        log.error("Bootstrap error", err);
-        throw new Error(message);
-    });
-
-    const ctx = new Ctx(context, config, serverPath, workspace);
+    const ctx = new Ctx(context, workspace);
     // VS Code doesn't show a notification when an extension fails to activate
     // so we do it ourselves.
     return await activateServer(ctx).catch((err) => {
-        void vscode.window.showErrorMessage(`Cannot activate rust-analyzer: ${err.message}`);
+        void vscode.window.showErrorMessage(
+            `Cannot activate rust-analyzer extension: ${err.message}`
+        );
         throw err;
     });
 }
@@ -83,7 +69,6 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
         ctx.pushExtCleanup(activateTaskProvider(ctx.config));
     }
 
-    await ctx.activate();
     await initCommonContext(ctx);
 
     if (ctx.config.typingContinueCommentsOnNewline) {
@@ -91,17 +76,19 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
     }
 
     vscode.workspace.onDidChangeConfiguration(
-        (_) =>
-            ctx
-                .getClient()
-                .then((it) =>
-                    it.sendNotification("workspace/didChangeConfiguration", { settings: "" })
-                )
-                .catch(log.error),
+        async (_) => {
+            await ctx
+                .clientFetcher()
+                .client?.sendNotification("workspace/didChangeConfiguration", { settings: "" });
+        },
         null,
         ctx.subscriptions
     );
 
+    await ctx.activate().catch((err) => {
+        void vscode.window.showErrorMessage(`Cannot activate rust-analyzer server: ${err.message}`);
+    });
+
     return ctx.clientFetcher();
 }
 
@@ -130,6 +117,7 @@ async function initCommonContext(ctx: Ctx) {
     // Commands which invokes manually via command palette, shortcut, etc.
     ctx.registerCommand("reload", (_) => async () => {
         void vscode.window.showInformationMessage("Reloading rust-analyzer...");
+        // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
         await ctx.disposeClient();
         await ctx.activate();
     });
-- 
cgit 1.4.1-3-g733a5


From d68616a140b35dd9bc4e2982e0993257ab0942e0 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 17 Oct 2022 15:05:20 +0200
Subject: Make more things private

---
 editors/code/src/ast_inspector.ts |  2 --
 editors/code/src/commands.ts      |  3 +--
 editors/code/src/ctx.ts           | 35 +++++++++++++++++++++--------------
 editors/code/src/main.ts          | 10 +++++++---
 editors/code/src/run.ts           |  4 ++--
 5 files changed, 31 insertions(+), 23 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ast_inspector.ts b/editors/code/src/ast_inspector.ts
index 2a2c9326b6a..176040120f4 100644
--- a/editors/code/src/ast_inspector.ts
+++ b/editors/code/src/ast_inspector.ts
@@ -54,8 +54,6 @@ export class AstInspector implements vscode.HoverProvider, vscode.DefinitionProv
             this,
             ctx.subscriptions
         );
-
-        ctx.pushExtCleanup(this);
     }
     dispose() {
         this.setRustEditor(undefined);
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index cb088fc6c68..12ceb4f2df8 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -377,8 +377,7 @@ export function syntaxTree(ctx: Ctx): Cmd {
         }
     })();
 
-    void new AstInspector(ctx);
-
+    ctx.pushExtCleanup(new AstInspector(ctx));
     ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-syntax-tree", tdcp)
     );
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index f62ccd1a652..6b12d9ca1ec 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -23,12 +23,12 @@ export class Ctx {
     readonly config: Config;
 
     private client: lc.LanguageClient | undefined;
+    private _serverPath: string | undefined;
+    private traceOutputChannel: vscode.OutputChannel | undefined;
+    private outputChannel: vscode.OutputChannel | undefined;
+    private state: PersistentState;
 
-    traceOutputChannel: vscode.OutputChannel | undefined;
-    outputChannel: vscode.OutputChannel | undefined;
     workspace: Workspace;
-    state: PersistentState;
-    serverPath: string | undefined;
 
     constructor(readonly extCtx: vscode.ExtensionContext, workspace: Workspace) {
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
@@ -70,21 +70,24 @@ export class Ctx {
         if (!this.client) {
             log.info("Creating language client");
 
-            this.serverPath = await bootstrap(this.extCtx, this.config, this.state).catch((err) => {
-                let message = "bootstrap error. ";
+            this._serverPath = await bootstrap(this.extCtx, this.config, this.state).catch(
+                (err) => {
+                    let message = "bootstrap error. ";
 
-                message +=
-                    'See the logs in "OUTPUT > Rust Analyzer Client" (should open automatically). ';
-                message += 'To enable verbose logs use { "rust-analyzer.trace.extension": true }';
+                    message +=
+                        'See the logs in "OUTPUT > Rust Analyzer Client" (should open automatically). ';
+                    message +=
+                        'To enable verbose logs use { "rust-analyzer.trace.extension": true }';
 
-                log.error("Bootstrap error", err);
-                throw new Error(message);
-            });
+                    log.error("Bootstrap error", err);
+                    throw new Error(message);
+                }
+            );
             const newEnv = substituteVariablesInEnv(
                 Object.assign({}, process.env, this.config.serverExtraEnv)
             );
             const run: lc.Executable = {
-                command: this.serverPath,
+                command: this._serverPath,
                 options: { env: newEnv },
             };
             const serverOptions = {
@@ -129,7 +132,7 @@ export class Ctx {
     async disposeClient() {
         log.info("Deactivating language client");
         await this.client?.dispose();
-        this.serverPath = undefined;
+        this._serverPath = undefined;
         this.client = undefined;
     }
 
@@ -161,6 +164,10 @@ export class Ctx {
         return this.extCtx.subscriptions;
     }
 
+    get serverPath(): string | undefined {
+        return this._serverPath;
+    }
+
     setServerStatus(status: ServerStatusParams) {
         let icon = "";
         const statusBar = this.statusBar;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 84f0a5810f9..97ec41dce3a 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -14,6 +14,10 @@ export interface RustAnalyzerExtensionApi {
     readonly client?: lc.LanguageClient;
 }
 
+export async function deactivate() {
+    await setContextValue(RUST_PROJECT_CONTEXT_NAME, undefined);
+}
+
 export async function activate(
     context: vscode.ExtensionContext
 ): Promise<RustAnalyzerExtensionApi> {
@@ -56,12 +60,14 @@ export async function activate(
     const ctx = new Ctx(context, workspace);
     // VS Code doesn't show a notification when an extension fails to activate
     // so we do it ourselves.
-    return await activateServer(ctx).catch((err) => {
+    const api = await activateServer(ctx).catch((err) => {
         void vscode.window.showErrorMessage(
             `Cannot activate rust-analyzer extension: ${err.message}`
         );
         throw err;
     });
+    await setContextValue(RUST_PROJECT_CONTEXT_NAME, true);
+    return api;
 }
 
 async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
@@ -112,8 +118,6 @@ async function initCommonContext(ctx: Ctx) {
     );
     ctx.pushExtCleanup(defaultOnEnter);
 
-    await setContextValue(RUST_PROJECT_CONTEXT_NAME, true);
-
     // Commands which invokes manually via command palette, shortcut, etc.
     ctx.registerCommand("reload", (_) => async () => {
         void vscode.window.showInformationMessage("Reloading rust-analyzer...");
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index 22e5eda6827..dadaa41b1d1 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -18,9 +18,9 @@ export async function selectRunnable(
     showButtons: boolean = true
 ): Promise<RunnableQuickPick | undefined> {
     const editor = ctx.activeRustEditor;
-    const client = ctx.client;
-    if (!editor || !client) return;
+    if (!editor) return;
 
+    const client = await ctx.getClient();
     const textDocument: lc.TextDocumentIdentifier = {
         uri: editor.document.uri.toString(),
     };
-- 
cgit 1.4.1-3-g733a5


From 0421756b4256b8edf739b5889e754d7bc733ed38 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 17 Oct 2022 15:43:15 +0200
Subject: Implement stop and start server commands

---
 editors/code/package.json  | 11 +++++++++++
 editors/code/src/client.ts |  8 ++++++++
 editors/code/src/ctx.ts    |  2 --
 editors/code/src/main.ts   |  7 +++++++
 4 files changed, 26 insertions(+), 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index da4bac5ad84..10558e8c018 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -60,6 +60,7 @@
         "onCommand:rust-analyzer.analyzerStatus",
         "onCommand:rust-analyzer.memoryUsage",
         "onCommand:rust-analyzer.reloadWorkspace",
+        "onCommand:rust-analyzer.startServer",
         "workspaceContains:*/Cargo.toml",
         "workspaceContains:*/rust-project.json"
     ],
@@ -191,6 +192,16 @@
                 "title": "Restart server",
                 "category": "rust-analyzer"
             },
+            {
+                "command": "rust-analyzer.startServer",
+                "title": "Start server",
+                "category": "rust-analyzer"
+            },
+            {
+                "command": "rust-analyzer.stopServer",
+                "title": "Stop server",
+                "category": "rust-analyzer"
+            },
             {
                 "command": "rust-analyzer.onEnter",
                 "title": "Enhanced enter key",
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 3408a2ee84e..fb667619c86 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -76,6 +76,14 @@ export async function createClient(
         outputChannel,
         middleware: {
             workspace: {
+                // HACK: This is a workaround, when the client has been disposed, VSCode
+                // continues to emit events to the client and the default one for this event
+                // attempt to restart the client for no reason
+                async didChangeWatchedFile(event, next) {
+                    if (client.isRunning()) {
+                        await next(event);
+                    }
+                },
                 async configuration(
                     params: lc.ConfigurationParams,
                     token: vscode.CancellationToken,
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 6b12d9ca1ec..2080db7a2c1 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -68,8 +68,6 @@ export class Ctx {
         }
 
         if (!this.client) {
-            log.info("Creating language client");
-
             this._serverPath = await bootstrap(this.extCtx, this.config, this.state).catch(
                 (err) => {
                     let message = "bootstrap error. ";
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 97ec41dce3a..f65620aebc6 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -126,6 +126,13 @@ async function initCommonContext(ctx: Ctx) {
         await ctx.activate();
     });
 
+    ctx.registerCommand("startServer", (_) => async () => {
+        await ctx.activate();
+    });
+    ctx.registerCommand("stopServer", (_) => async () => {
+        // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
+        await ctx.disposeClient();
+    });
     ctx.registerCommand("analyzerStatus", commands.analyzerStatus);
     ctx.registerCommand("memoryUsage", commands.memoryUsage);
     ctx.registerCommand("shuffleCrateGraph", commands.shuffleCrateGraph);
-- 
cgit 1.4.1-3-g733a5


From d63c44e650f9a6ce2fc5f713b4688f3e9e2d9a8d Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 17 Oct 2022 16:01:39 +0200
Subject: Cleanup output channels

---
 editors/code/src/ctx.ts | 24 +++++++++---------------
 1 file changed, 9 insertions(+), 15 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 2080db7a2c1..e94d4365c37 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -62,9 +62,11 @@ export class Ctx {
             this.traceOutputChannel = vscode.window.createOutputChannel(
                 "Rust Analyzer Language Server Trace"
             );
+            this.pushExtCleanup(this.traceOutputChannel);
         }
         if (!this.outputChannel) {
             this.outputChannel = vscode.window.createOutputChannel("Rust Analyzer Language Server");
+            this.pushExtCleanup(this.outputChannel);
         }
 
         if (!this.client) {
@@ -139,25 +141,10 @@ export class Ctx {
         return editor && isRustEditor(editor) ? editor : undefined;
     }
 
-    get visibleRustEditors(): RustEditor[] {
-        return vscode.window.visibleTextEditors.filter(isRustEditor);
-    }
-
-    registerCommand(name: string, factory: (ctx: Ctx) => Cmd) {
-        const fullName = `rust-analyzer.${name}`;
-        const cmd = factory(this);
-        const d = vscode.commands.registerCommand(fullName, cmd);
-        this.pushExtCleanup(d);
-    }
-
     get extensionPath(): string {
         return this.extCtx.extensionPath;
     }
 
-    get globalState(): vscode.Memento {
-        return this.extCtx.globalState;
-    }
-
     get subscriptions(): Disposable[] {
         return this.extCtx.subscriptions;
     }
@@ -201,6 +188,13 @@ export class Ctx {
         statusBar.text = `${icon}rust-analyzer`;
     }
 
+    registerCommand(name: string, factory: (ctx: Ctx) => Cmd) {
+        const fullName = `rust-analyzer.${name}`;
+        const cmd = factory(this);
+        const d = vscode.commands.registerCommand(fullName, cmd);
+        this.pushExtCleanup(d);
+    }
+
     pushExtCleanup(d: Disposable) {
         this.extCtx.subscriptions.push(d);
     }
-- 
cgit 1.4.1-3-g733a5


From 69b845674c44cc14793a9d3727ff687c0141cf72 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 20 Oct 2022 11:32:02 +0200
Subject: Don't catch the server activation error

---
 editors/code/src/main.ts | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index f65620aebc6..c47680fbac5 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -91,10 +91,7 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
         ctx.subscriptions
     );
 
-    await ctx.activate().catch((err) => {
-        void vscode.window.showErrorMessage(`Cannot activate rust-analyzer server: ${err.message}`);
-    });
-
+    await ctx.activate();
     return ctx.clientFetcher();
 }
 
-- 
cgit 1.4.1-3-g733a5


From e05df93b8ee0936c37df8e368817dc201e07fb75 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Thu, 20 Oct 2022 17:56:51 +0000
Subject: Workaround the python vscode extension's polyfill

---
 editors/code/src/config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 10e243dc896..0aa998db625 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -191,7 +191,7 @@ export class Config {
 const VarRegex = new RegExp(/\$\{(.+?)\}/g);
 
 export function substituteVSCodeVariableInString(val: string): string {
-    return val.replaceAll(VarRegex, (substring: string, varName) => {
+    return val.replace(VarRegex, (substring: string, varName) => {
         if (typeof varName === "string") {
             return computeVscodeVar(varName) || substring;
         } else {
-- 
cgit 1.4.1-3-g733a5


From a8e0a20ce4396d3c77adf3b5deb48edfd27d6af2 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 20 Oct 2022 21:12:58 +0200
Subject: internal: Properly handle language configuration config changes

---
 editors/code/src/config.ts | 102 ++++++++++++++++++++++++++++++++++-----------
 editors/code/src/ctx.ts    |   8 +++-
 editors/code/src/main.ts   |  60 +++-----------------------
 3 files changed, 89 insertions(+), 81 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 10e243dc896..61125d7a83e 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -11,13 +11,9 @@ export type RunnableEnvCfg =
 
 export class Config {
     readonly extensionId = "rust-lang.rust-analyzer";
+    configureLang: vscode.Disposable | undefined;
 
     readonly rootSection = "rust-analyzer";
-    private readonly requiresWorkspaceReloadOpts = [
-        // FIXME: This shouldn't be here, changing this setting should reload
-        // `continueCommentsOnNewline` behavior without restart
-        "typing",
-    ].map((opt) => `${this.rootSection}.${opt}`);
     private readonly requiresReloadOpts = [
         "cargo",
         "procMacro",
@@ -25,9 +21,7 @@ export class Config {
         "server",
         "files",
         "lens", // works as lens.*
-    ]
-        .map((opt) => `${this.rootSection}.${opt}`)
-        .concat(this.requiresWorkspaceReloadOpts);
+    ].map((opt) => `${this.rootSection}.${opt}`);
 
     readonly package: {
         version: string;
@@ -45,6 +39,11 @@ export class Config {
             ctx.subscriptions
         );
         this.refreshLogging();
+        this.configureLanguage();
+    }
+
+    dispose() {
+        this.configureLang?.dispose();
     }
 
     private refreshLogging() {
@@ -58,33 +57,86 @@ export class Config {
     private async onDidChangeConfiguration(event: vscode.ConfigurationChangeEvent) {
         this.refreshLogging();
 
+        this.configureLanguage();
+
         const requiresReloadOpt = this.requiresReloadOpts.find((opt) =>
             event.affectsConfiguration(opt)
         );
 
         if (!requiresReloadOpt) return;
 
-        const requiresWorkspaceReloadOpt = this.requiresWorkspaceReloadOpts.find((opt) =>
-            event.affectsConfiguration(opt)
-        );
-
-        if (!requiresWorkspaceReloadOpt && this.restartServerOnConfigChange) {
+        if (this.restartServerOnConfigChange) {
             await vscode.commands.executeCommand("rust-analyzer.reload");
             return;
         }
 
-        const message = requiresWorkspaceReloadOpt
-            ? `Changing "${requiresWorkspaceReloadOpt}" requires a window reload`
-            : `Changing "${requiresReloadOpt}" requires a reload`;
-        const userResponse = await vscode.window.showInformationMessage(message, "Reload now");
-
-        if (userResponse === "Reload now") {
-            const command = requiresWorkspaceReloadOpt
-                ? "workbench.action.reloadWindow"
-                : "rust-analyzer.reload";
-            if (userResponse === "Reload now") {
-                await vscode.commands.executeCommand(command);
-            }
+        const message = `Changing "${requiresReloadOpt}" requires a server restart`;
+        const userResponse = await vscode.window.showInformationMessage(message, "Restart now");
+
+        if (userResponse) {
+            const command = "rust-analyzer.reload";
+            await vscode.commands.executeCommand(command);
+        }
+    }
+
+    /**
+     * Sets up additional language configuration that's impossible to do via a
+     * separate language-configuration.json file. See [1] for more information.
+     *
+     * [1]: https://github.com/Microsoft/vscode/issues/11514#issuecomment-244707076
+     */
+    private configureLanguage() {
+        if (this.typingContinueCommentsOnNewline && !this.configureLang) {
+            const indentAction = vscode.IndentAction.None;
+
+            this.configureLang = vscode.languages.setLanguageConfiguration("rust", {
+                onEnterRules: [
+                    {
+                        // Doc single-line comment
+                        // e.g. ///|
+                        beforeText: /^\s*\/{3}.*$/,
+                        action: { indentAction, appendText: "/// " },
+                    },
+                    {
+                        // Parent doc single-line comment
+                        // e.g. //!|
+                        beforeText: /^\s*\/{2}\!.*$/,
+                        action: { indentAction, appendText: "//! " },
+                    },
+                    {
+                        // Begins an auto-closed multi-line comment (standard or parent doc)
+                        // e.g. /** | */ or /*! | */
+                        beforeText: /^\s*\/\*(\*|\!)(?!\/)([^\*]|\*(?!\/))*$/,
+                        afterText: /^\s*\*\/$/,
+                        action: {
+                            indentAction: vscode.IndentAction.IndentOutdent,
+                            appendText: " * ",
+                        },
+                    },
+                    {
+                        // Begins a multi-line comment (standard or parent doc)
+                        // e.g. /** ...| or /*! ...|
+                        beforeText: /^\s*\/\*(\*|\!)(?!\/)([^\*]|\*(?!\/))*$/,
+                        action: { indentAction, appendText: " * " },
+                    },
+                    {
+                        // Continues a multi-line comment
+                        // e.g.  * ...|
+                        beforeText: /^(\ \ )*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
+                        action: { indentAction, appendText: "* " },
+                    },
+                    {
+                        // Dedents after closing a multi-line comment
+                        // e.g.  */|
+                        beforeText: /^(\ \ )*\ \*\/\s*$/,
+                        action: { indentAction, removeText: 1 },
+                    },
+                ],
+            });
+        }
+        if (!this.typingContinueCommentsOnNewline && this.configureLang) {
+            this.configureLang.dispose();
+            this.configureLang = undefined;
         }
     }
 
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index e94d4365c37..75c6d4698c1 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -38,6 +38,7 @@ export class Ctx {
                 this.dispose();
             },
         });
+        extCtx.subscriptions.push(this);
         this.statusBar.text = "rust-analyzer";
         this.statusBar.tooltip = "ready";
         this.statusBar.command = "rust-analyzer.analyzerStatus";
@@ -48,10 +49,15 @@ export class Ctx {
         this.config = new Config(extCtx);
     }
 
+    dispose() {
+        this.config.dispose();
+    }
+
     clientFetcher() {
+        const self = this;
         return {
             get client(): lc.LanguageClient | undefined {
-                return this.client;
+                return self.client;
             },
         };
     }
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index c47680fbac5..fa7dc6fe304 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -77,10 +77,6 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
 
     await initCommonContext(ctx);
 
-    if (ctx.config.typingContinueCommentsOnNewline) {
-        ctx.pushExtCleanup(configureLanguage());
-    }
-
     vscode.workspace.onDidChangeConfiguration(
         async (_) => {
             await ctx
@@ -129,6 +125,11 @@ async function initCommonContext(ctx: Ctx) {
     ctx.registerCommand("stopServer", (_) => async () => {
         // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
         await ctx.disposeClient();
+        ctx.setServerStatus({
+            health: "ok",
+            quiescent: true,
+            message: "server is not running",
+        });
     });
     ctx.registerCommand("analyzerStatus", commands.analyzerStatus);
     ctx.registerCommand("memoryUsage", commands.memoryUsage);
@@ -172,54 +173,3 @@ async function initCommonContext(ctx: Ctx) {
     defaultOnEnter.dispose();
     ctx.registerCommand("onEnter", commands.onEnter);
 }
-
-/**
- * Sets up additional language configuration that's impossible to do via a
- * separate language-configuration.json file. See [1] for more information.
- *
- * [1]: https://github.com/Microsoft/vscode/issues/11514#issuecomment-244707076
- */
-function configureLanguage(): vscode.Disposable {
-    const indentAction = vscode.IndentAction.None;
-    return vscode.languages.setLanguageConfiguration("rust", {
-        onEnterRules: [
-            {
-                // Doc single-line comment
-                // e.g. ///|
-                beforeText: /^\s*\/{3}.*$/,
-                action: { indentAction, appendText: "/// " },
-            },
-            {
-                // Parent doc single-line comment
-                // e.g. //!|
-                beforeText: /^\s*\/{2}\!.*$/,
-                action: { indentAction, appendText: "//! " },
-            },
-            {
-                // Begins an auto-closed multi-line comment (standard or parent doc)
-                // e.g. /** | */ or /*! | */
-                beforeText: /^\s*\/\*(\*|\!)(?!\/)([^\*]|\*(?!\/))*$/,
-                afterText: /^\s*\*\/$/,
-                action: { indentAction: vscode.IndentAction.IndentOutdent, appendText: " * " },
-            },
-            {
-                // Begins a multi-line comment (standard or parent doc)
-                // e.g. /** ...| or /*! ...|
-                beforeText: /^\s*\/\*(\*|\!)(?!\/)([^\*]|\*(?!\/))*$/,
-                action: { indentAction, appendText: " * " },
-            },
-            {
-                // Continues a multi-line comment
-                // e.g.  * ...|
-                beforeText: /^(\ \ )*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
-                action: { indentAction, appendText: "* " },
-            },
-            {
-                // Dedents after closing a multi-line comment
-                // e.g.  */|
-                beforeText: /^(\ \ )*\ \*\/\s*$/,
-                action: { indentAction, removeText: 1 },
-            },
-        ],
-    });
-}
-- 
cgit 1.4.1-3-g733a5


From 1cb46079e493af318a2dc6f97c93c2e0ac7ecd0e Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Fri, 21 Oct 2022 16:00:43 +0200
Subject: internal: Properly handle commands in the VSCode client when the
 server is stopped

---
 editors/code/src/ctx.ts  |  80 ++++++++++++++++++------
 editors/code/src/main.ts | 159 ++++++++++++++++++++++-------------------------
 2 files changed, 136 insertions(+), 103 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 75c6d4698c1..044a9470aa9 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -18,6 +18,11 @@ export type Workspace =
           files: vscode.TextDocument[];
       };
 
+export type CommandFactory = {
+    enabled: (ctx: Ctx) => Cmd;
+    disabled?: (ctx: Ctx) => Cmd;
+};
+
 export class Ctx {
     readonly statusBar: vscode.StatusBarItem;
     readonly config: Config;
@@ -26,31 +31,40 @@ export class Ctx {
     private _serverPath: string | undefined;
     private traceOutputChannel: vscode.OutputChannel | undefined;
     private outputChannel: vscode.OutputChannel | undefined;
+    private clientSubscriptions: Disposable[];
     private state: PersistentState;
+    private commandFactories: Record<string, CommandFactory>;
+    private commandDisposables: Disposable[];
 
     workspace: Workspace;
 
-    constructor(readonly extCtx: vscode.ExtensionContext, workspace: Workspace) {
-        this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
-        extCtx.subscriptions.push(this.statusBar);
-        extCtx.subscriptions.push({
-            dispose() {
-                this.dispose();
-            },
-        });
+    constructor(
+        readonly extCtx: vscode.ExtensionContext,
+        workspace: Workspace,
+        commandFactories: Record<string, CommandFactory>
+    ) {
         extCtx.subscriptions.push(this);
+        this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
         this.statusBar.text = "rust-analyzer";
         this.statusBar.tooltip = "ready";
         this.statusBar.command = "rust-analyzer.analyzerStatus";
         this.statusBar.show();
         this.workspace = workspace;
+        this.clientSubscriptions = [];
+        this.commandDisposables = [];
+        this.commandFactories = commandFactories;
 
         this.state = new PersistentState(extCtx.globalState);
         this.config = new Config(extCtx);
+
+        this.updateCommands();
     }
 
     dispose() {
         this.config.dispose();
+        this.statusBar.dispose();
+        void this.disposeClient();
+        this.commandDisposables.forEach((disposable) => disposable.dispose());
     }
 
     clientFetcher() {
@@ -63,7 +77,6 @@ export class Ctx {
     }
 
     async getClient() {
-        // if server path changes -> dispose
         if (!this.traceOutputChannel) {
             this.traceOutputChannel = vscode.window.createOutputChannel(
                 "Rust Analyzer Language Server Trace"
@@ -118,7 +131,11 @@ export class Ctx {
                 initializationOptions,
                 serverOptions
             );
-            this.client.onNotification(ra.serverStatus, (params) => this.setServerStatus(params));
+            this.pushClientCleanup(
+                this.client.onNotification(ra.serverStatus, (params) =>
+                    this.setServerStatus(params)
+                )
+            );
         }
         return this.client;
     }
@@ -127,16 +144,25 @@ export class Ctx {
         log.info("Activating language client");
         const client = await this.getClient();
         await client.start();
+        this.updateCommands();
         return client;
     }
 
     async deactivate() {
         log.info("Deactivating language client");
         await this.client?.stop();
+        this.updateCommands();
     }
 
-    async disposeClient() {
-        log.info("Deactivating language client");
+    async stop() {
+        log.info("Stopping language client");
+        await this.disposeClient();
+        this.updateCommands();
+    }
+
+    private async disposeClient() {
+        this.clientSubscriptions?.forEach((disposable) => disposable.dispose());
+        this.clientSubscriptions = [];
         await this.client?.dispose();
         this._serverPath = undefined;
         this.client = undefined;
@@ -159,6 +185,25 @@ export class Ctx {
         return this._serverPath;
     }
 
+    private updateCommands() {
+        this.commandDisposables.forEach((disposable) => disposable.dispose());
+        this.commandDisposables = [];
+        const fetchFactory = (factory: CommandFactory, fullName: string) => {
+            return this.client && this.client.isRunning()
+                ? factory.enabled
+                : factory.disabled ||
+                      ((_) => () =>
+                          vscode.window.showErrorMessage(
+                              `command ${fullName} failed: rust-analyzer server is not running`
+                          ));
+        };
+        for (const [name, factory] of Object.entries(this.commandFactories)) {
+            const fullName = `rust-analyzer.${name}`;
+            const callback = fetchFactory(factory, fullName)(this);
+            this.commandDisposables.push(vscode.commands.registerCommand(fullName, callback));
+        }
+    }
+
     setServerStatus(status: ServerStatusParams) {
         let icon = "";
         const statusBar = this.statusBar;
@@ -194,16 +239,13 @@ export class Ctx {
         statusBar.text = `${icon}rust-analyzer`;
     }
 
-    registerCommand(name: string, factory: (ctx: Ctx) => Cmd) {
-        const fullName = `rust-analyzer.${name}`;
-        const cmd = factory(this);
-        const d = vscode.commands.registerCommand(fullName, cmd);
-        this.pushExtCleanup(d);
-    }
-
     pushExtCleanup(d: Disposable) {
         this.extCtx.subscriptions.push(d);
     }
+
+    private pushClientCleanup(d: Disposable) {
+        this.clientSubscriptions.push(d);
+    }
 }
 
 export interface Disposable {
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index fa7dc6fe304..8c3a676ffb0 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -2,7 +2,7 @@ import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
 
 import * as commands from "./commands";
-import { Ctx, Workspace } from "./ctx";
+import { CommandFactory, Ctx, Workspace } from "./ctx";
 import { isRustDocument } from "./util";
 import { activateTaskProvider } from "./tasks";
 import { setContextValue } from "./util";
@@ -57,7 +57,7 @@ export async function activate(
               }
             : { kind: "Workspace Folder" };
 
-    const ctx = new Ctx(context, workspace);
+    const ctx = new Ctx(context, workspace, createCommands());
     // VS Code doesn't show a notification when an extension fails to activate
     // so we do it ourselves.
     const api = await activateServer(ctx).catch((err) => {
@@ -75,8 +75,6 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
         ctx.pushExtCleanup(activateTaskProvider(ctx.config));
     }
 
-    await initCommonContext(ctx);
-
     vscode.workspace.onDidChangeConfiguration(
         async (_) => {
             await ctx
@@ -91,85 +89,78 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
     return ctx.clientFetcher();
 }
 
-async function initCommonContext(ctx: Ctx) {
-    // Register a "dumb" onEnter command for the case where server fails to
-    // start.
-    //
-    // FIXME: refactor command registration code such that commands are
-    // **always** registered, even if the server does not start. Use API like
-    // this perhaps?
-    //
-    // ```TypeScript
-    // registerCommand(
-    //    factory: (Ctx) => ((Ctx) => any),
-    //    fallback: () => any = () => vscode.window.showErrorMessage(
-    //        "rust-analyzer is not available"
-    //    ),
-    // )
-    const defaultOnEnter = vscode.commands.registerCommand("rust-analyzer.onEnter", () =>
-        vscode.commands.executeCommand("default:type", { text: "\n" })
-    );
-    ctx.pushExtCleanup(defaultOnEnter);
-
-    // Commands which invokes manually via command palette, shortcut, etc.
-    ctx.registerCommand("reload", (_) => async () => {
-        void vscode.window.showInformationMessage("Reloading rust-analyzer...");
-        // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
-        await ctx.disposeClient();
-        await ctx.activate();
-    });
-
-    ctx.registerCommand("startServer", (_) => async () => {
-        await ctx.activate();
-    });
-    ctx.registerCommand("stopServer", (_) => async () => {
-        // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
-        await ctx.disposeClient();
-        ctx.setServerStatus({
-            health: "ok",
-            quiescent: true,
-            message: "server is not running",
-        });
-    });
-    ctx.registerCommand("analyzerStatus", commands.analyzerStatus);
-    ctx.registerCommand("memoryUsage", commands.memoryUsage);
-    ctx.registerCommand("shuffleCrateGraph", commands.shuffleCrateGraph);
-    ctx.registerCommand("reloadWorkspace", commands.reloadWorkspace);
-    ctx.registerCommand("matchingBrace", commands.matchingBrace);
-    ctx.registerCommand("joinLines", commands.joinLines);
-    ctx.registerCommand("parentModule", commands.parentModule);
-    ctx.registerCommand("syntaxTree", commands.syntaxTree);
-    ctx.registerCommand("viewHir", commands.viewHir);
-    ctx.registerCommand("viewFileText", commands.viewFileText);
-    ctx.registerCommand("viewItemTree", commands.viewItemTree);
-    ctx.registerCommand("viewCrateGraph", commands.viewCrateGraph);
-    ctx.registerCommand("viewFullCrateGraph", commands.viewFullCrateGraph);
-    ctx.registerCommand("expandMacro", commands.expandMacro);
-    ctx.registerCommand("run", commands.run);
-    ctx.registerCommand("copyRunCommandLine", commands.copyRunCommandLine);
-    ctx.registerCommand("debug", commands.debug);
-    ctx.registerCommand("newDebugConfig", commands.newDebugConfig);
-    ctx.registerCommand("openDocs", commands.openDocs);
-    ctx.registerCommand("openCargoToml", commands.openCargoToml);
-    ctx.registerCommand("peekTests", commands.peekTests);
-    ctx.registerCommand("moveItemUp", commands.moveItemUp);
-    ctx.registerCommand("moveItemDown", commands.moveItemDown);
-    ctx.registerCommand("cancelFlycheck", commands.cancelFlycheck);
-
-    ctx.registerCommand("ssr", commands.ssr);
-    ctx.registerCommand("serverVersion", commands.serverVersion);
-
-    // Internal commands which are invoked by the server.
-    ctx.registerCommand("runSingle", commands.runSingle);
-    ctx.registerCommand("debugSingle", commands.debugSingle);
-    ctx.registerCommand("showReferences", commands.showReferences);
-    ctx.registerCommand("applySnippetWorkspaceEdit", commands.applySnippetWorkspaceEditCommand);
-    ctx.registerCommand("resolveCodeAction", commands.resolveCodeAction);
-    ctx.registerCommand("applyActionGroup", commands.applyActionGroup);
-    ctx.registerCommand("gotoLocation", commands.gotoLocation);
-
-    ctx.registerCommand("linkToCommand", commands.linkToCommand);
+function createCommands(): Record<string, CommandFactory> {
+    return {
+        onEnter: {
+            enabled: commands.onEnter,
+            disabled: (_) => () => vscode.commands.executeCommand("default:type", { text: "\n" }),
+        },
+        reload: {
+            enabled: (ctx) => async () => {
+                void vscode.window.showInformationMessage("Reloading rust-analyzer...");
+                // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
+                await ctx.stop();
+                await ctx.activate();
+            },
+            disabled: (ctx) => async () => {
+                void vscode.window.showInformationMessage("Reloading rust-analyzer...");
+                await ctx.activate();
+            },
+        },
+        startServer: {
+            enabled: (ctx) => async () => {
+                await ctx.activate();
+            },
+            disabled: (ctx) => async () => {
+                await ctx.activate();
+            },
+        },
+        stopServer: {
+            enabled: (ctx) => async () => {
+                // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
+                await ctx.stop();
+                ctx.setServerStatus({
+                    health: "ok",
+                    quiescent: true,
+                    message: "server is not running",
+                });
+            },
+        },
 
-    defaultOnEnter.dispose();
-    ctx.registerCommand("onEnter", commands.onEnter);
+        analyzerStatus: { enabled: commands.analyzerStatus },
+        memoryUsage: { enabled: commands.memoryUsage },
+        shuffleCrateGraph: { enabled: commands.shuffleCrateGraph },
+        reloadWorkspace: { enabled: commands.reloadWorkspace },
+        matchingBrace: { enabled: commands.matchingBrace },
+        joinLines: { enabled: commands.joinLines },
+        parentModule: { enabled: commands.parentModule },
+        syntaxTree: { enabled: commands.syntaxTree },
+        viewHir: { enabled: commands.viewHir },
+        viewFileText: { enabled: commands.viewFileText },
+        viewItemTree: { enabled: commands.viewItemTree },
+        viewCrateGraph: { enabled: commands.viewCrateGraph },
+        viewFullCrateGraph: { enabled: commands.viewFullCrateGraph },
+        expandMacro: { enabled: commands.expandMacro },
+        run: { enabled: commands.run },
+        copyRunCommandLine: { enabled: commands.copyRunCommandLine },
+        debug: { enabled: commands.debug },
+        newDebugConfig: { enabled: commands.newDebugConfig },
+        openDocs: { enabled: commands.openDocs },
+        openCargoToml: { enabled: commands.openCargoToml },
+        peekTests: { enabled: commands.peekTests },
+        moveItemUp: { enabled: commands.moveItemUp },
+        moveItemDown: { enabled: commands.moveItemDown },
+        cancelFlycheck: { enabled: commands.cancelFlycheck },
+        ssr: { enabled: commands.ssr },
+        serverVersion: { enabled: commands.serverVersion },
+        // Internal commands which are invoked by the server.
+        applyActionGroup: { enabled: commands.applyActionGroup },
+        applySnippetWorkspaceEdit: { enabled: commands.applySnippetWorkspaceEditCommand },
+        debugSingle: { enabled: commands.debugSingle },
+        gotoLocation: { enabled: commands.gotoLocation },
+        linkToCommand: { enabled: commands.linkToCommand },
+        resolveCodeAction: { enabled: commands.resolveCodeAction },
+        runSingle: { enabled: commands.runSingle },
+        showReferences: { enabled: commands.showReferences },
+    };
 }
-- 
cgit 1.4.1-3-g733a5


From 274df5488530e7445553a680b1d56dd8573b99e8 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Fri, 28 Oct 2022 23:10:10 +0200
Subject: feat: Clicking the status bar item stops and starts the server

---
 editors/code/src/ctx.ts  | 13 ++++++++++---
 editors/code/src/main.ts |  4 +---
 2 files changed, 11 insertions(+), 6 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 044a9470aa9..8592950e102 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -204,13 +204,13 @@ export class Ctx {
         }
     }
 
-    setServerStatus(status: ServerStatusParams) {
+    setServerStatus(status: ServerStatusParams | { health: "stopped" }) {
         let icon = "";
         const statusBar = this.statusBar;
         switch (status.health) {
             case "ok":
-                statusBar.tooltip = status.message ?? "Ready";
-                statusBar.command = undefined;
+                statusBar.tooltip = (status.message ?? "Ready") + "Click to stop.";
+                statusBar.command = "rust-analyzer.stopServer";
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
                 break;
@@ -234,6 +234,13 @@ export class Ctx {
                 statusBar.backgroundColor = new vscode.ThemeColor("statusBarItem.errorBackground");
                 icon = "$(error) ";
                 break;
+            case "stopped":
+                statusBar.tooltip = "Server is stopped. Click to start.";
+                statusBar.command = "rust-analyzer.startServer";
+                statusBar.color = undefined;
+                statusBar.backgroundColor = undefined;
+                statusBar.text = `$(stop-circle) rust-analyzer`;
+                return;
         }
         if (!status.quiescent) icon = "$(sync~spin) ";
         statusBar.text = `${icon}rust-analyzer`;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 8c3a676ffb0..59705334726 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -120,9 +120,7 @@ function createCommands(): Record<string, CommandFactory> {
                 // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
                 await ctx.stop();
                 ctx.setServerStatus({
-                    health: "ok",
-                    quiescent: true,
-                    message: "server is not running",
+                    health: "stopped",
                 });
             },
         },
-- 
cgit 1.4.1-3-g733a5


From 2071d00fd25cee25fe881255d78e478f72749c7d Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sat, 29 Oct 2022 00:44:37 +0200
Subject: Always set up VSCode commands

---
 editors/code/src/commands.ts | 129 +++++++++++++++++++++----------------------
 editors/code/src/ctx.ts      | 102 ++++++++++++++++++++--------------
 editors/code/src/main.ts     |  30 +++++-----
 editors/code/src/run.ts      |   6 +-
 4 files changed, 139 insertions(+), 128 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 12ceb4f2df8..312087e4cff 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -3,7 +3,7 @@ import * as lc from "vscode-languageclient";
 import * as ra from "./lsp_ext";
 import * as path from "path";
 
-import { Ctx, Cmd } from "./ctx";
+import { Ctx, Cmd, CtxInit } from "./ctx";
 import { applySnippetWorkspaceEdit, applySnippetTextEdits } from "./snippets";
 import { spawnSync } from "child_process";
 import { RunnableQuickPick, selectRunnable, createTask, createArgs } from "./run";
@@ -16,14 +16,14 @@ import { LINKED_COMMANDS } from "./client";
 export * from "./ast_inspector";
 export * from "./run";
 
-export function analyzerStatus(ctx: Ctx): Cmd {
+export function analyzerStatus(ctx: CtxInit): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
         readonly uri = vscode.Uri.parse("rust-analyzer-status://status");
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
 
         async provideTextDocumentContent(_uri: vscode.Uri): Promise<string> {
             if (!vscode.window.activeTextEditor) return "";
-            const client = await ctx.getClient();
+            const client = ctx.client;
 
             const params: ra.AnalyzerStatusParams = {};
             const doc = ctx.activeRustEditor?.document;
@@ -52,7 +52,7 @@ export function analyzerStatus(ctx: Ctx): Cmd {
     };
 }
 
-export function memoryUsage(ctx: Ctx): Cmd {
+export function memoryUsage(ctx: CtxInit): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
         readonly uri = vscode.Uri.parse("rust-analyzer-memory://memory");
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
@@ -60,14 +60,9 @@ export function memoryUsage(ctx: Ctx): Cmd {
         provideTextDocumentContent(_uri: vscode.Uri): vscode.ProviderResult<string> {
             if (!vscode.window.activeTextEditor) return "";
 
-            return ctx
-                .getClient()
-                .then((it) => it.sendRequest(ra.memoryUsage))
-                .then((mem: any) => {
-                    return (
-                        "Per-query memory usage:\n" + mem + "\n(note: database has been cleared)"
-                    );
-                });
+            return ctx.client.sendRequest(ra.memoryUsage).then((mem: any) => {
+                return "Per-query memory usage:\n" + mem + "\n(note: database has been cleared)";
+            });
         }
 
         get onDidChange(): vscode.Event<vscode.Uri> {
@@ -86,18 +81,18 @@ export function memoryUsage(ctx: Ctx): Cmd {
     };
 }
 
-export function shuffleCrateGraph(ctx: Ctx): Cmd {
+export function shuffleCrateGraph(ctx: CtxInit): Cmd {
     return async () => {
-        return ctx.getClient().then((it) => it.sendRequest(ra.shuffleCrateGraph));
+        return ctx.client.sendRequest(ra.shuffleCrateGraph);
     };
 }
 
-export function matchingBrace(ctx: Ctx): Cmd {
+export function matchingBrace(ctx: CtxInit): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
 
-        const client = await ctx.getClient();
+        const client = ctx.client;
 
         const response = await client.sendRequest(ra.matchingBrace, {
             textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
@@ -114,12 +109,12 @@ export function matchingBrace(ctx: Ctx): Cmd {
     };
 }
 
-export function joinLines(ctx: Ctx): Cmd {
+export function joinLines(ctx: CtxInit): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
 
-        const client = await ctx.getClient();
+        const client = ctx.client;
 
         const items: lc.TextEdit[] = await client.sendRequest(ra.joinLines, {
             ranges: editor.selections.map((it) => client.code2ProtocolConverter.asRange(it)),
@@ -134,19 +129,19 @@ export function joinLines(ctx: Ctx): Cmd {
     };
 }
 
-export function moveItemUp(ctx: Ctx): Cmd {
+export function moveItemUp(ctx: CtxInit): Cmd {
     return moveItem(ctx, ra.Direction.Up);
 }
 
-export function moveItemDown(ctx: Ctx): Cmd {
+export function moveItemDown(ctx: CtxInit): Cmd {
     return moveItem(ctx, ra.Direction.Down);
 }
 
-export function moveItem(ctx: Ctx, direction: ra.Direction): Cmd {
+export function moveItem(ctx: CtxInit, direction: ra.Direction): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
-        const client = await ctx.getClient();
+        const client = ctx.client;
 
         const lcEdits = await client.sendRequest(ra.moveItem, {
             range: client.code2ProtocolConverter.asRange(editor.selection),
@@ -161,13 +156,13 @@ export function moveItem(ctx: Ctx, direction: ra.Direction): Cmd {
     };
 }
 
-export function onEnter(ctx: Ctx): Cmd {
+export function onEnter(ctx: CtxInit): Cmd {
     async function handleKeypress() {
         const editor = ctx.activeRustEditor;
 
         if (!editor) return false;
 
-        const client = await ctx.getClient();
+        const client = ctx.client;
         const lcEdits = await client
             .sendRequest(ra.onEnter, {
                 textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
@@ -193,13 +188,13 @@ export function onEnter(ctx: Ctx): Cmd {
     };
 }
 
-export function parentModule(ctx: Ctx): Cmd {
+export function parentModule(ctx: CtxInit): Cmd {
     return async () => {
         const editor = vscode.window.activeTextEditor;
         if (!editor) return;
         if (!(isRustDocument(editor.document) || isCargoTomlDocument(editor.document))) return;
 
-        const client = await ctx.getClient();
+        const client = ctx.client;
 
         const locations = await client.sendRequest(ra.parentModule, {
             textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
@@ -230,12 +225,12 @@ export function parentModule(ctx: Ctx): Cmd {
     };
 }
 
-export function openCargoToml(ctx: Ctx): Cmd {
+export function openCargoToml(ctx: CtxInit): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
 
-        const client = await ctx.getClient();
+        const client = ctx.client;
         const response = await client.sendRequest(ra.openCargoToml, {
             textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
         });
@@ -251,12 +246,12 @@ export function openCargoToml(ctx: Ctx): Cmd {
     };
 }
 
-export function ssr(ctx: Ctx): Cmd {
+export function ssr(ctx: CtxInit): Cmd {
     return async () => {
         const editor = vscode.window.activeTextEditor;
         if (!editor) return;
 
-        const client = await ctx.getClient();
+        const client = ctx.client;
 
         const position = editor.selection.active;
         const selections = editor.selections;
@@ -308,7 +303,7 @@ export function ssr(ctx: Ctx): Cmd {
     };
 }
 
-export function serverVersion(ctx: Ctx): Cmd {
+export function serverVersion(ctx: CtxInit): Cmd {
     return async () => {
         if (!ctx.serverPath) {
             void vscode.window.showWarningMessage(`rust-analyzer server is not running`);
@@ -324,7 +319,7 @@ export function serverVersion(ctx: Ctx): Cmd {
 // Opens the virtual file that will show the syntax tree
 //
 // The contents of the file come from the `TextDocumentContentProvider`
-export function syntaxTree(ctx: Ctx): Cmd {
+export function syntaxTree(ctx: CtxInit): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
         readonly uri = vscode.Uri.parse("rust-analyzer-syntax-tree://syntaxtree/tree.rast");
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
@@ -360,7 +355,7 @@ export function syntaxTree(ctx: Ctx): Cmd {
         ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
             if (!rustEditor) return "";
-            const client = await ctx.getClient();
+            const client = ctx.client;
 
             // When the range based query is enabled we take the range of the selection
             const range =
@@ -407,7 +402,7 @@ export function syntaxTree(ctx: Ctx): Cmd {
 // Opens the virtual file that will show the HIR of the function containing the cursor position
 //
 // The contents of the file come from the `TextDocumentContentProvider`
-export function viewHir(ctx: Ctx): Cmd {
+export function viewHir(ctx: CtxInit): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
         readonly uri = vscode.Uri.parse("rust-analyzer-hir://viewHir/hir.rs");
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
@@ -444,7 +439,7 @@ export function viewHir(ctx: Ctx): Cmd {
             const rustEditor = ctx.activeRustEditor;
             if (!rustEditor) return "";
 
-            const client = await ctx.getClient();
+            const client = ctx.client;
             const params = {
                 textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
                     rustEditor.document
@@ -473,7 +468,7 @@ export function viewHir(ctx: Ctx): Cmd {
     };
 }
 
-export function viewFileText(ctx: Ctx): Cmd {
+export function viewFileText(ctx: CtxInit): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
         readonly uri = vscode.Uri.parse("rust-analyzer-file-text://viewFileText/file.rs");
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
@@ -509,7 +504,7 @@ export function viewFileText(ctx: Ctx): Cmd {
         ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
             if (!rustEditor) return "";
-            const client = await ctx.getClient();
+            const client = ctx.client;
 
             const params = client.code2ProtocolConverter.asTextDocumentIdentifier(
                 rustEditor.document
@@ -536,7 +531,7 @@ export function viewFileText(ctx: Ctx): Cmd {
     };
 }
 
-export function viewItemTree(ctx: Ctx): Cmd {
+export function viewItemTree(ctx: CtxInit): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
         readonly uri = vscode.Uri.parse("rust-analyzer-item-tree://viewItemTree/itemtree.rs");
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
@@ -572,7 +567,7 @@ export function viewItemTree(ctx: Ctx): Cmd {
         ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
             if (!rustEditor) return "";
-            const client = await ctx.getClient();
+            const client = ctx.client;
 
             const params = {
                 textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
@@ -601,7 +596,7 @@ export function viewItemTree(ctx: Ctx): Cmd {
     };
 }
 
-function crateGraph(ctx: Ctx, full: boolean): Cmd {
+function crateGraph(ctx: CtxInit, full: boolean): Cmd {
     return async () => {
         const nodeModulesPath = vscode.Uri.file(path.join(ctx.extensionPath, "node_modules"));
 
@@ -618,7 +613,7 @@ function crateGraph(ctx: Ctx, full: boolean): Cmd {
         const params = {
             full: full,
         };
-        const client = await ctx.getClient();
+        const client = ctx.client;
         const dot = await client.sendRequest(ra.viewCrateGraph, params);
         const uri = panel.webview.asWebviewUri(nodeModulesPath);
 
@@ -664,18 +659,18 @@ function crateGraph(ctx: Ctx, full: boolean): Cmd {
     };
 }
 
-export function viewCrateGraph(ctx: Ctx): Cmd {
+export function viewCrateGraph(ctx: CtxInit): Cmd {
     return crateGraph(ctx, false);
 }
 
-export function viewFullCrateGraph(ctx: Ctx): Cmd {
+export function viewFullCrateGraph(ctx: CtxInit): Cmd {
     return crateGraph(ctx, true);
 }
 
 // Opens the virtual file that will show the syntax tree
 //
 // The contents of the file come from the `TextDocumentContentProvider`
-export function expandMacro(ctx: Ctx): Cmd {
+export function expandMacro(ctx: CtxInit): Cmd {
     function codeFormat(expanded: ra.ExpandedMacro): string {
         let result = `// Recursive expansion of ${expanded.name}! macro\n`;
         result += "// " + "=".repeat(result.length - 3);
@@ -691,7 +686,7 @@ export function expandMacro(ctx: Ctx): Cmd {
         async provideTextDocumentContent(_uri: vscode.Uri): Promise<string> {
             const editor = vscode.window.activeTextEditor;
             if (!editor) return "";
-            const client = await ctx.getClient();
+            const client = ctx.client;
 
             const position = editor.selection.active;
 
@@ -723,8 +718,8 @@ export function expandMacro(ctx: Ctx): Cmd {
     };
 }
 
-export function reloadWorkspace(ctx: Ctx): Cmd {
-    return async () => (await ctx.getClient()).sendRequest(ra.reloadWorkspace);
+export function reloadWorkspace(ctx: CtxInit): Cmd {
+    return async () => ctx.client.sendRequest(ra.reloadWorkspace);
 }
 
 async function showReferencesImpl(
@@ -743,13 +738,13 @@ async function showReferencesImpl(
     }
 }
 
-export function showReferences(ctx: Ctx): Cmd {
+export function showReferences(ctx: CtxInit): Cmd {
     return async (uri: string, position: lc.Position, locations: lc.Location[]) => {
-        await showReferencesImpl(await ctx.getClient(), uri, position, locations);
+        await showReferencesImpl(ctx.client, uri, position, locations);
     };
 }
 
-export function applyActionGroup(_ctx: Ctx): Cmd {
+export function applyActionGroup(_ctx: CtxInit): Cmd {
     return async (actions: { label: string; arguments: lc.CodeAction }[]) => {
         const selectedAction = await vscode.window.showQuickPick(actions);
         if (!selectedAction) return;
@@ -760,9 +755,9 @@ export function applyActionGroup(_ctx: Ctx): Cmd {
     };
 }
 
-export function gotoLocation(ctx: Ctx): Cmd {
+export function gotoLocation(ctx: CtxInit): Cmd {
     return async (locationLink: lc.LocationLink) => {
-        const client = await ctx.getClient();
+        const client = ctx.client;
         const uri = client.protocol2CodeConverter.asUri(locationLink.targetUri);
         let range = client.protocol2CodeConverter.asRange(locationLink.targetSelectionRange);
         // collapse the range to a cursor position
@@ -772,13 +767,13 @@ export function gotoLocation(ctx: Ctx): Cmd {
     };
 }
 
-export function openDocs(ctx: Ctx): Cmd {
+export function openDocs(ctx: CtxInit): Cmd {
     return async () => {
         const editor = vscode.window.activeTextEditor;
         if (!editor) {
             return;
         }
-        const client = await ctx.getClient();
+        const client = ctx.client;
 
         const position = editor.selection.active;
         const textDocument = { uri: editor.document.uri.toString() };
@@ -791,16 +786,16 @@ export function openDocs(ctx: Ctx): Cmd {
     };
 }
 
-export function cancelFlycheck(ctx: Ctx): Cmd {
+export function cancelFlycheck(ctx: CtxInit): Cmd {
     return async () => {
-        const client = await ctx.getClient();
+        const client = ctx.client;
         await client.sendRequest(ra.cancelFlycheck);
     };
 }
 
-export function resolveCodeAction(ctx: Ctx): Cmd {
+export function resolveCodeAction(ctx: CtxInit): Cmd {
     return async (params: lc.CodeAction) => {
-        const client = await ctx.getClient();
+        const client = ctx.client;
         params.command = undefined;
         const item = await client?.sendRequest(lc.CodeActionResolveRequest.type, params);
         if (!item?.edit) {
@@ -825,13 +820,13 @@ export function resolveCodeAction(ctx: Ctx): Cmd {
     };
 }
 
-export function applySnippetWorkspaceEditCommand(_ctx: Ctx): Cmd {
+export function applySnippetWorkspaceEditCommand(_ctx: CtxInit): Cmd {
     return async (edit: vscode.WorkspaceEdit) => {
         await applySnippetWorkspaceEdit(edit);
     };
 }
 
-export function run(ctx: Ctx): Cmd {
+export function run(ctx: CtxInit): Cmd {
     let prevRunnable: RunnableQuickPick | undefined;
 
     return async () => {
@@ -845,11 +840,11 @@ export function run(ctx: Ctx): Cmd {
     };
 }
 
-export function peekTests(ctx: Ctx): Cmd {
+export function peekTests(ctx: CtxInit): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
-        const client = await ctx.getClient();
+        const client = ctx.client;
 
         await vscode.window.withProgress(
             {
@@ -878,7 +873,7 @@ export function peekTests(ctx: Ctx): Cmd {
     };
 }
 
-export function runSingle(ctx: Ctx): Cmd {
+export function runSingle(ctx: CtxInit): Cmd {
     return async (runnable: ra.Runnable) => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
@@ -895,7 +890,7 @@ export function runSingle(ctx: Ctx): Cmd {
     };
 }
 
-export function copyRunCommandLine(ctx: Ctx) {
+export function copyRunCommandLine(ctx: CtxInit) {
     let prevRunnable: RunnableQuickPick | undefined;
     return async () => {
         const item = await selectRunnable(ctx, prevRunnable);
@@ -907,7 +902,7 @@ export function copyRunCommandLine(ctx: Ctx) {
     };
 }
 
-export function debug(ctx: Ctx): Cmd {
+export function debug(ctx: CtxInit): Cmd {
     let prevDebuggee: RunnableQuickPick | undefined;
 
     return async () => {
@@ -920,13 +915,13 @@ export function debug(ctx: Ctx): Cmd {
     };
 }
 
-export function debugSingle(ctx: Ctx): Cmd {
+export function debugSingle(ctx: CtxInit): Cmd {
     return async (config: ra.Runnable) => {
         await startDebugSession(ctx, config);
     };
 }
 
-export function newDebugConfig(ctx: Ctx): Cmd {
+export function newDebugConfig(ctx: CtxInit): Cmd {
     return async () => {
         const item = await selectRunnable(ctx, undefined, true, false);
         if (!item) return;
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 8592950e102..d198d4e9383 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -10,6 +10,7 @@ import { PersistentState } from "./persistent_state";
 import { bootstrap } from "./bootstrap";
 
 export type Workspace =
+    | { kind: "Empty" }
     | {
           kind: "Workspace Folder";
       }
@@ -19,15 +20,20 @@ export type Workspace =
       };
 
 export type CommandFactory = {
-    enabled: (ctx: Ctx) => Cmd;
+    enabled: (ctx: CtxInit) => Cmd;
     disabled?: (ctx: Ctx) => Cmd;
 };
 
+export type CtxInit = Ctx & {
+    readonly client: lc.LanguageClient;
+};
+
 export class Ctx {
     readonly statusBar: vscode.StatusBarItem;
     readonly config: Config;
+    readonly workspace: Workspace;
 
-    private client: lc.LanguageClient | undefined;
+    private _client: lc.LanguageClient | undefined;
     private _serverPath: string | undefined;
     private traceOutputChannel: vscode.OutputChannel | undefined;
     private outputChannel: vscode.OutputChannel | undefined;
@@ -36,18 +42,17 @@ export class Ctx {
     private commandFactories: Record<string, CommandFactory>;
     private commandDisposables: Disposable[];
 
-    workspace: Workspace;
+    get client() {
+        return this._client;
+    }
 
     constructor(
         readonly extCtx: vscode.ExtensionContext,
-        workspace: Workspace,
-        commandFactories: Record<string, CommandFactory>
+        commandFactories: Record<string, CommandFactory>,
+        workspace: Workspace
     ) {
         extCtx.subscriptions.push(this);
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
-        this.statusBar.text = "rust-analyzer";
-        this.statusBar.tooltip = "ready";
-        this.statusBar.command = "rust-analyzer.analyzerStatus";
         this.statusBar.show();
         this.workspace = workspace;
         this.clientSubscriptions = [];
@@ -57,7 +62,10 @@ export class Ctx {
         this.state = new PersistentState(extCtx.globalState);
         this.config = new Config(extCtx);
 
-        this.updateCommands();
+        this.updateCommands("disable");
+        this.setServerStatus({
+            health: "stopped",
+        });
     }
 
     dispose() {
@@ -67,16 +75,11 @@ export class Ctx {
         this.commandDisposables.forEach((disposable) => disposable.dispose());
     }
 
-    clientFetcher() {
-        const self = this;
-        return {
-            get client(): lc.LanguageClient | undefined {
-                return self.client;
-            },
-        };
-    }
+    private async getOrCreateClient() {
+        if (this.workspace.kind === "Empty") {
+            return;
+        }
 
-    async getClient() {
         if (!this.traceOutputChannel) {
             this.traceOutputChannel = vscode.window.createOutputChannel(
                 "Rust Analyzer Language Server Trace"
@@ -88,7 +91,7 @@ export class Ctx {
             this.pushExtCleanup(this.outputChannel);
         }
 
-        if (!this.client) {
+        if (!this._client) {
             this._serverPath = await bootstrap(this.extCtx, this.config, this.state).catch(
                 (err) => {
                     let message = "bootstrap error. ";
@@ -125,47 +128,55 @@ export class Ctx {
 
             const initializationOptions = substituteVSCodeVariables(rawInitializationOptions);
 
-            this.client = await createClient(
+            this._client = await createClient(
                 this.traceOutputChannel,
                 this.outputChannel,
                 initializationOptions,
                 serverOptions
             );
             this.pushClientCleanup(
-                this.client.onNotification(ra.serverStatus, (params) =>
+                this._client.onNotification(ra.serverStatus, (params) =>
                     this.setServerStatus(params)
                 )
             );
         }
-        return this.client;
+        return this._client;
     }
 
     async activate() {
         log.info("Activating language client");
-        const client = await this.getClient();
+        const client = await this.getOrCreateClient();
+        if (!client) {
+            return;
+        }
         await client.start();
         this.updateCommands();
-        return client;
     }
 
     async deactivate() {
+        if (!this._client) {
+            return;
+        }
         log.info("Deactivating language client");
-        await this.client?.stop();
-        this.updateCommands();
+        this.updateCommands("disable");
+        await this._client.stop();
     }
 
     async stop() {
+        if (!this._client) {
+            return;
+        }
         log.info("Stopping language client");
+        this.updateCommands("disable");
         await this.disposeClient();
-        this.updateCommands();
     }
 
     private async disposeClient() {
         this.clientSubscriptions?.forEach((disposable) => disposable.dispose());
         this.clientSubscriptions = [];
-        await this.client?.dispose();
+        await this._client?.dispose();
         this._serverPath = undefined;
-        this.client = undefined;
+        this._client = undefined;
     }
 
     get activeRustEditor(): RustEditor | undefined {
@@ -185,21 +196,30 @@ export class Ctx {
         return this._serverPath;
     }
 
-    private updateCommands() {
+    private updateCommands(forceDisable?: "disable") {
         this.commandDisposables.forEach((disposable) => disposable.dispose());
         this.commandDisposables = [];
-        const fetchFactory = (factory: CommandFactory, fullName: string) => {
-            return this.client && this.client.isRunning()
-                ? factory.enabled
-                : factory.disabled ||
-                      ((_) => () =>
-                          vscode.window.showErrorMessage(
-                              `command ${fullName} failed: rust-analyzer server is not running`
-                          ));
+
+        const clientRunning = (!forceDisable && this._client?.isRunning()) ?? false;
+        const isClientRunning = function (_ctx: Ctx): _ctx is CtxInit {
+            return clientRunning;
         };
+
         for (const [name, factory] of Object.entries(this.commandFactories)) {
             const fullName = `rust-analyzer.${name}`;
-            const callback = fetchFactory(factory, fullName)(this);
+            let callback;
+            if (isClientRunning(this)) {
+                // we asserted that `client` is defined
+                callback = factory.enabled(this);
+            } else if (factory.disabled) {
+                callback = factory.disabled(this);
+            } else {
+                callback = () =>
+                    vscode.window.showErrorMessage(
+                        `command ${fullName} failed: rust-analyzer server is not running`
+                    );
+            }
+
             this.commandDisposables.push(vscode.commands.registerCommand(fullName, callback));
         }
     }
@@ -209,7 +229,7 @@ export class Ctx {
         const statusBar = this.statusBar;
         switch (status.health) {
             case "ok":
-                statusBar.tooltip = (status.message ?? "Ready") + "Click to stop.";
+                statusBar.tooltip = (status.message ?? "Ready") + "\nClick to stop server.";
                 statusBar.command = "rust-analyzer.stopServer";
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
@@ -235,7 +255,7 @@ export class Ctx {
                 icon = "$(error) ";
                 break;
             case "stopped":
-                statusBar.tooltip = "Server is stopped. Click to start.";
+                statusBar.tooltip = "Server is stopped.\nClick to start.";
                 statusBar.command = "rust-analyzer.startServer";
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 59705334726..54e0c16e5e0 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -10,7 +10,6 @@ import { setContextValue } from "./util";
 const RUST_PROJECT_CONTEXT_NAME = "inRustProject";
 
 export interface RustAnalyzerExtensionApi {
-    // FIXME: this should be non-optional
     readonly client?: lc.LanguageClient;
 }
 
@@ -42,22 +41,18 @@ export async function activate(
         isRustDocument(document)
     );
 
-    if (folders.length === 0 && rustDocuments.length === 0) {
-        // FIXME: Ideally we would choose not to activate at all (and avoid registering
-        // non-functional editor commands), but VS Code doesn't seem to have a good way of doing
-        // that
-        return {};
-    }
-
+    // FIXME: This can change over time
     const workspace: Workspace =
         folders.length === 0
-            ? {
-                  kind: "Detached Files",
-                  files: rustDocuments,
-              }
+            ? rustDocuments.length === 0
+                ? { kind: "Empty" }
+                : {
+                      kind: "Detached Files",
+                      files: rustDocuments,
+                  }
             : { kind: "Workspace Folder" };
 
-    const ctx = new Ctx(context, workspace, createCommands());
+    const ctx = new Ctx(context, createCommands(), workspace);
     // VS Code doesn't show a notification when an extension fails to activate
     // so we do it ourselves.
     const api = await activateServer(ctx).catch((err) => {
@@ -77,16 +72,16 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
 
     vscode.workspace.onDidChangeConfiguration(
         async (_) => {
-            await ctx
-                .clientFetcher()
-                .client?.sendNotification("workspace/didChangeConfiguration", { settings: "" });
+            await ctx.client?.sendNotification("workspace/didChangeConfiguration", {
+                settings: "",
+            });
         },
         null,
         ctx.subscriptions
     );
 
     await ctx.activate();
-    return ctx.clientFetcher();
+    return ctx;
 }
 
 function createCommands(): Record<string, CommandFactory> {
@@ -123,6 +118,7 @@ function createCommands(): Record<string, CommandFactory> {
                     health: "stopped",
                 });
             },
+            disabled: (_) => async () => {},
         },
 
         analyzerStatus: { enabled: commands.analyzerStatus },
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index dadaa41b1d1..35627e2fc6b 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -3,7 +3,7 @@ import * as lc from "vscode-languageclient";
 import * as ra from "./lsp_ext";
 import * as tasks from "./tasks";
 
-import { Ctx } from "./ctx";
+import { CtxInit } from "./ctx";
 import { makeDebugConfig } from "./debug";
 import { Config, RunnableEnvCfg } from "./config";
 
@@ -12,7 +12,7 @@ const quickPickButtons = [
 ];
 
 export async function selectRunnable(
-    ctx: Ctx,
+    ctx: CtxInit,
     prevRunnable?: RunnableQuickPick,
     debuggeeOnly = false,
     showButtons: boolean = true
@@ -20,7 +20,7 @@ export async function selectRunnable(
     const editor = ctx.activeRustEditor;
     if (!editor) return;
 
-    const client = await ctx.getClient();
+    const client = ctx.client;
     const textDocument: lc.TextDocumentIdentifier = {
         uri: editor.document.uri.toString(),
     };
-- 
cgit 1.4.1-3-g733a5


From fccf8eb1fd582a4539e6a149fe376685caf43b22 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sat, 29 Oct 2022 01:28:32 +0200
Subject: Properly handle vscode workspace changes

---
 editors/code/src/ctx.ts  | 67 +++++++++++++++++++++++++++++++++++++++++++-----
 editors/code/src/main.ts | 45 ++++++++++----------------------
 2 files changed, 73 insertions(+), 39 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index d198d4e9383..3e366525ee2 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -4,11 +4,15 @@ import * as ra from "./lsp_ext";
 
 import { Config, substituteVariablesInEnv, substituteVSCodeVariables } from "./config";
 import { createClient } from "./client";
-import { isRustEditor, log, RustEditor } from "./util";
+import { isRustDocument, isRustEditor, log, RustEditor } from "./util";
 import { ServerStatusParams } from "./lsp_ext";
 import { PersistentState } from "./persistent_state";
 import { bootstrap } from "./bootstrap";
 
+// We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
+// only those are in use. We use "Empty" to represent these scenarios
+// (r-a still somewhat works with Live Share, because commands are tunneled to the host)
+
 export type Workspace =
     | { kind: "Empty" }
     | {
@@ -19,6 +23,24 @@ export type Workspace =
           files: vscode.TextDocument[];
       };
 
+export function fetchWorkspace(): Workspace {
+    const folders = (vscode.workspace.workspaceFolders || []).filter(
+        (folder) => folder.uri.scheme === "file"
+    );
+    const rustDocuments = vscode.workspace.textDocuments.filter((document) =>
+        isRustDocument(document)
+    );
+
+    return folders.length === 0
+        ? rustDocuments.length === 0
+            ? { kind: "Empty" }
+            : {
+                  kind: "Detached Files",
+                  files: rustDocuments,
+              }
+        : { kind: "Workspace Folder" };
+}
+
 export type CommandFactory = {
     enabled: (ctx: CtxInit) => Cmd;
     disabled?: (ctx: Ctx) => Cmd;
@@ -75,6 +97,31 @@ export class Ctx {
         this.commandDisposables.forEach((disposable) => disposable.dispose());
     }
 
+    async onWorkspaceFolderChanges() {
+        const workspace = fetchWorkspace();
+        if (workspace.kind === "Detached Files" && this.workspace.kind === "Detached Files") {
+            if (workspace.files !== this.workspace.files) {
+                if (this.client?.isRunning()) {
+                    // Ideally we wouldn't need to tear down the server here, but currently detached files
+                    // are only specified at server start
+                    await this.stopAndDispose();
+                    await this.start();
+                }
+                return;
+            }
+        }
+        if (workspace.kind === "Workspace Folder" && this.workspace.kind === "Workspace Folder") {
+            return;
+        }
+        if (workspace.kind === "Empty") {
+            await this.stopAndDispose();
+            return;
+        }
+        if (this.client?.isRunning()) {
+            await this.restart();
+        }
+    }
+
     private async getOrCreateClient() {
         if (this.workspace.kind === "Empty") {
             return;
@@ -143,8 +190,8 @@ export class Ctx {
         return this._client;
     }
 
-    async activate() {
-        log.info("Activating language client");
+    async start() {
+        log.info("Starting language client");
         const client = await this.getOrCreateClient();
         if (!client) {
             return;
@@ -153,20 +200,26 @@ export class Ctx {
         this.updateCommands();
     }
 
-    async deactivate() {
+    async restart() {
+        // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
+        await this.stopAndDispose();
+        await this.start();
+    }
+
+    async stop() {
         if (!this._client) {
             return;
         }
-        log.info("Deactivating language client");
+        log.info("Stopping language client");
         this.updateCommands("disable");
         await this._client.stop();
     }
 
-    async stop() {
+    async stopAndDispose() {
         if (!this._client) {
             return;
         }
-        log.info("Stopping language client");
+        log.info("Disposing language client");
         this.updateCommands("disable");
         await this.disposeClient();
     }
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 54e0c16e5e0..e76b657c1bf 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -2,8 +2,7 @@ import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
 
 import * as commands from "./commands";
-import { CommandFactory, Ctx, Workspace } from "./ctx";
-import { isRustDocument } from "./util";
+import { CommandFactory, Ctx, fetchWorkspace } from "./ctx";
 import { activateTaskProvider } from "./tasks";
 import { setContextValue } from "./util";
 
@@ -31,28 +30,7 @@ export async function activate(
             .then(() => {}, console.error);
     }
 
-    // We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
-    // only those are in use.
-    // (r-a still somewhat works with Live Share, because commands are tunneled to the host)
-    const folders = (vscode.workspace.workspaceFolders || []).filter(
-        (folder) => folder.uri.scheme === "file"
-    );
-    const rustDocuments = vscode.workspace.textDocuments.filter((document) =>
-        isRustDocument(document)
-    );
-
-    // FIXME: This can change over time
-    const workspace: Workspace =
-        folders.length === 0
-            ? rustDocuments.length === 0
-                ? { kind: "Empty" }
-                : {
-                      kind: "Detached Files",
-                      files: rustDocuments,
-                  }
-            : { kind: "Workspace Folder" };
-
-    const ctx = new Ctx(context, createCommands(), workspace);
+    const ctx = new Ctx(context, createCommands(), fetchWorkspace());
     // VS Code doesn't show a notification when an extension fails to activate
     // so we do it ourselves.
     const api = await activateServer(ctx).catch((err) => {
@@ -70,6 +48,11 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
         ctx.pushExtCleanup(activateTaskProvider(ctx.config));
     }
 
+    vscode.workspace.onDidChangeWorkspaceFolders(
+        async (_) => ctx.onWorkspaceFolderChanges(),
+        null,
+        ctx.subscriptions
+    );
     vscode.workspace.onDidChangeConfiguration(
         async (_) => {
             await ctx.client?.sendNotification("workspace/didChangeConfiguration", {
@@ -80,7 +63,7 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
         ctx.subscriptions
     );
 
-    await ctx.activate();
+    await ctx.start();
     return ctx;
 }
 
@@ -93,27 +76,25 @@ function createCommands(): Record<string, CommandFactory> {
         reload: {
             enabled: (ctx) => async () => {
                 void vscode.window.showInformationMessage("Reloading rust-analyzer...");
-                // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
-                await ctx.stop();
-                await ctx.activate();
+                await ctx.restart();
             },
             disabled: (ctx) => async () => {
                 void vscode.window.showInformationMessage("Reloading rust-analyzer...");
-                await ctx.activate();
+                await ctx.start();
             },
         },
         startServer: {
             enabled: (ctx) => async () => {
-                await ctx.activate();
+                await ctx.start();
             },
             disabled: (ctx) => async () => {
-                await ctx.activate();
+                await ctx.start();
             },
         },
         stopServer: {
             enabled: (ctx) => async () => {
                 // FIXME: We should re-use the client, that is ctx.deactivate() if none of the configs have changed
-                await ctx.stop();
+                await ctx.stopAndDispose();
                 ctx.setServerStatus({
                     health: "stopped",
                 });
-- 
cgit 1.4.1-3-g733a5


From 073a63b93ec39b51cb412119c38716c1af5db871 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Fri, 18 Nov 2022 19:47:45 +0100
Subject: feat: Allow viewing the full compiler diagnostic in a readonly
 textview

---
 crates/rust-analyzer/src/diagnostics/to_proto.rs | 19 ++++++-----
 editors/code/package.json                        |  5 +++
 editors/code/src/client.ts                       | 42 ++++++++++++++++++++++--
 editors/code/src/config.ts                       |  3 ++
 editors/code/src/ctx.ts                          |  3 +-
 editors/code/src/main.ts                         | 24 ++++++++++++++
 6 files changed, 84 insertions(+), 12 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index 189ac2fbf53..35f37c740b8 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -359,14 +359,15 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
         .iter()
         .flat_map(|primary_span| {
             let primary_location = primary_location(config, workspace_root, primary_span, snap);
-
-            let mut message = message.clone();
-            if needs_primary_span_label {
-                if let Some(primary_span_label) = &primary_span.label {
-                    format_to!(message, "\n{}", primary_span_label);
+            let message = {
+                let mut message = message.clone();
+                if needs_primary_span_label {
+                    if let Some(primary_span_label) = &primary_span.label {
+                        format_to!(message, "\n{}", primary_span_label);
+                    }
                 }
-            }
-
+                message
+            };
             // Each primary diagnostic span may result in multiple LSP diagnostics.
             let mut diagnostics = Vec::new();
 
@@ -417,7 +418,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
                     message: message.clone(),
                     related_information: Some(information_for_additional_diagnostic),
                     tags: if tags.is_empty() { None } else { Some(tags.clone()) },
-                    data: None,
+                    data: Some(serde_json::json!({ "rendered": rd.rendered })),
                 };
                 diagnostics.push(MappedRustDiagnostic {
                     url: secondary_location.uri,
@@ -449,7 +450,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
                         }
                     },
                     tags: if tags.is_empty() { None } else { Some(tags.clone()) },
-                    data: None,
+                    data: Some(serde_json::json!({ "rendered": rd.rendered })),
                 },
                 fix: None,
             });
diff --git a/editors/code/package.json b/editors/code/package.json
index 0c781659604..b1c3473b825 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -396,6 +396,11 @@
                     "default": true,
                     "type": "boolean"
                 },
+                "rust-analyzer.diagnostics.previewRustcOutput": {
+                    "markdownDescription": "Whether to show the main part of the rendered rustc output of a diagnostic message.",
+                    "default": false,
+                    "type": "boolean"
+                },
                 "$generated-start": {},
                 "rust-analyzer.assist.emitMustUse": {
                     "markdownDescription": "Whether to insert #[must_use] when generating `as_` methods\nfor enum variants.",
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index fb667619c86..23e039722ee 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -4,7 +4,7 @@ import * as ra from "../src/lsp_ext";
 import * as Is from "vscode-languageclient/lib/common/utils/is";
 import { assert } from "./util";
 import { WorkspaceEdit } from "vscode";
-import { substituteVSCodeVariables } from "./config";
+import { Config, substituteVSCodeVariables } from "./config";
 import { randomUUID } from "crypto";
 
 export interface Env {
@@ -66,7 +66,8 @@ export async function createClient(
     traceOutputChannel: vscode.OutputChannel,
     outputChannel: vscode.OutputChannel,
     initializationOptions: vscode.WorkspaceConfiguration,
-    serverOptions: lc.ServerOptions
+    serverOptions: lc.ServerOptions,
+    config: Config
 ): Promise<lc.LanguageClient> {
     const clientOptions: lc.LanguageClientOptions = {
         documentSelector: [{ scheme: "file", language: "rust" }],
@@ -99,6 +100,43 @@ export async function createClient(
                     }
                 },
             },
+            async handleDiagnostics(
+                uri: vscode.Uri,
+                diagnostics: vscode.Diagnostic[],
+                next: lc.HandleDiagnosticsSignature
+            ) {
+                const preview = config.previewRustcOutput;
+                diagnostics.forEach((diag, idx) => {
+                    // Abuse the fact that VSCode leaks the LSP diagnostics data field through the
+                    // Diagnostic class, if they ever break this we are out of luck and have to go
+                    // back to the worst diagnostics experience ever:)
+
+                    // We encode the rendered output of a rustc diagnostic in the rendered field of
+                    // the data payload of the lsp diagnostic. If that field exists, overwrite the
+                    // diagnostic code such that clicking it opens the diagnostic in a readonly
+                    // text editor for easy inspection
+                    const rendered = (diag as unknown as { data?: { rendered?: string } }).data
+                        ?.rendered;
+                    if (rendered) {
+                        if (preview) {
+                            const index = rendered.match(/^(note|help):/m)?.index || 0;
+                            diag.message = rendered
+                                .substring(0, index)
+                                .replace(/^ -->[^\n]+\n/m, "");
+                        }
+                        diag.code = {
+                            target: vscode.Uri.from({
+                                scheme: "rust-analyzer-diagnostics-view",
+                                path: "/diagnostic message",
+                                fragment: uri.toString(),
+                                query: idx.toString(),
+                            }),
+                            value: "Click for full compiler diagnostic",
+                        };
+                    }
+                });
+                return next(uri, diagnostics);
+            },
             async provideHover(
                 document: vscode.TextDocument,
                 position: vscode.Position,
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 632a7d86faa..d8dbd1df16d 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -238,6 +238,9 @@ export class Config {
             gotoTypeDef: this.get<boolean>("hover.actions.gotoTypeDef.enable"),
         };
     }
+    get previewRustcOutput() {
+        return this.get<boolean>("diagnostics.previewRustcOutput");
+    }
 }
 
 const VarRegex = new RegExp(/\$\{(.+?)\}/g);
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 3e366525ee2..d6cee5c8fc6 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -179,7 +179,8 @@ export class Ctx {
                 this.traceOutputChannel,
                 this.outputChannel,
                 initializationOptions,
-                serverOptions
+                serverOptions,
+                this.config
             );
             this.pushClientCleanup(
                 this._client.onNotification(ra.serverStatus, (params) =>
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index e76b657c1bf..25f1e83d109 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -48,6 +48,30 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
         ctx.pushExtCleanup(activateTaskProvider(ctx.config));
     }
 
+    ctx.pushExtCleanup(
+        vscode.workspace.registerTextDocumentContentProvider(
+            "rust-analyzer-diagnostics-view",
+            new (class implements vscode.TextDocumentContentProvider {
+                async provideTextDocumentContent(uri: vscode.Uri): Promise<string> {
+                    const diags = ctx.client?.diagnostics?.get(
+                        vscode.Uri.parse(uri.fragment, true)
+                    );
+                    if (!diags) {
+                        return "Unable to find original rustc diagnostic";
+                    }
+
+                    const diag = diags[parseInt(uri.query)];
+                    if (!diag) {
+                        return "Unable to find original rustc diagnostic";
+                    }
+                    const rendered = (diag as unknown as { data?: { rendered?: string } }).data
+                        ?.rendered;
+                    return rendered ?? "Unable to find original rustc diagnostic";
+                }
+            })()
+        )
+    );
+
     vscode.workspace.onDidChangeWorkspaceFolders(
         async (_) => ctx.onWorkspaceFolderChanges(),
         null,
-- 
cgit 1.4.1-3-g733a5


From 8661740626ae7f608051e1309d802c408b1e20e2 Mon Sep 17 00:00:00 2001
From: Maria José Solano <majosolano99@gmail.com>
Date: Sun, 27 Nov 2022 09:46:37 -0800
Subject: Use typed notification method

---
 editors/code/src/main.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 25f1e83d109..01a1a2db7fd 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -79,7 +79,7 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
     );
     vscode.workspace.onDidChangeConfiguration(
         async (_) => {
-            await ctx.client?.sendNotification("workspace/didChangeConfiguration", {
+            await ctx.client?.sendNotification(lc.DidChangeConfigurationNotification.type, {
                 settings: "",
             });
         },
-- 
cgit 1.4.1-3-g733a5


From a04feb915a0e5ef348075a3537a95875cb1b1ffe Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Fri, 16 Dec 2022 22:43:14 +0100
Subject: Add command for manually running flychecks

---
 crates/rust-analyzer/src/lsp_ext.rs   |  13 +++
 crates/rust-analyzer/src/main_loop.rs | 173 +++++++++++++++++++---------------
 docs/dev/lsp-extensions.md            |   2 +-
 editors/code/package.json             |   5 +
 editors/code/src/commands.ts          |  15 ++-
 editors/code/src/lsp_ext.ts           |   4 +
 editors/code/src/main.ts              |   1 +
 7 files changed, 133 insertions(+), 80 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index a1df0b6d7dd..a2d539cf6ca 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -138,6 +138,19 @@ impl Request for CancelFlycheck {
     const METHOD: &'static str = "rust-analyzer/cancelFlycheck";
 }
 
+pub enum RunFlycheck {}
+
+impl Notification for RunFlycheck {
+    type Params = RunFlycheckParams;
+    const METHOD: &'static str = "rust-analyzer/runFlycheck";
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RunFlycheckParams {
+    pub text_document: Option<TextDocumentIdentifier>,
+}
+
 pub enum MatchingBrace {}
 
 impl Request for MatchingBrace {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 274588ce0e0..d979317b218 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -703,6 +703,88 @@ impl GlobalState {
 
     /// Handles an incoming notification.
     fn on_notification(&mut self, not: Notification) -> Result<()> {
+        // FIXME: Move these implementations out into a module similar to on_request
+        fn run_flycheck(this: &mut GlobalState, vfs_path: VfsPath) -> bool {
+            let file_id = this.vfs.read().0.file_id(&vfs_path);
+            if let Some(file_id) = file_id {
+                let world = this.snapshot();
+                let mut updated = false;
+                let task = move || -> std::result::Result<(), ide::Cancelled> {
+                    // Trigger flychecks for all workspaces that depend on the saved file
+                    // Crates containing or depending on the saved file
+                    let crate_ids: Vec<_> = world
+                        .analysis
+                        .crates_for(file_id)?
+                        .into_iter()
+                        .flat_map(|id| world.analysis.transitive_rev_deps(id))
+                        .flatten()
+                        .sorted()
+                        .unique()
+                        .collect();
+
+                    let crate_root_paths: Vec<_> = crate_ids
+                        .iter()
+                        .filter_map(|&crate_id| {
+                            world
+                                .analysis
+                                .crate_root(crate_id)
+                                .map(|file_id| {
+                                    world
+                                        .file_id_to_file_path(file_id)
+                                        .as_path()
+                                        .map(ToOwned::to_owned)
+                                })
+                                .transpose()
+                        })
+                        .collect::<ide::Cancellable<_>>()?;
+                    let crate_root_paths: Vec<_> =
+                        crate_root_paths.iter().map(Deref::deref).collect();
+
+                    // Find all workspaces that have at least one target containing the saved file
+                    let workspace_ids =
+                        world.workspaces.iter().enumerate().filter(|(_, ws)| match ws {
+                            project_model::ProjectWorkspace::Cargo { cargo, .. } => {
+                                cargo.packages().any(|pkg| {
+                                    cargo[pkg].targets.iter().any(|&it| {
+                                        crate_root_paths.contains(&cargo[it].root.as_path())
+                                    })
+                                })
+                            }
+                            project_model::ProjectWorkspace::Json { project, .. } => project
+                                .crates()
+                                .any(|(c, _)| crate_ids.iter().any(|&crate_id| crate_id == c)),
+                            project_model::ProjectWorkspace::DetachedFiles { .. } => false,
+                        });
+
+                    // Find and trigger corresponding flychecks
+                    for flycheck in world.flycheck.iter() {
+                        for (id, _) in workspace_ids.clone() {
+                            if id == flycheck.id() {
+                                updated = true;
+                                flycheck.restart();
+                                continue;
+                            }
+                        }
+                    }
+                    // No specific flycheck was triggered, so let's trigger all of them.
+                    if !updated {
+                        for flycheck in world.flycheck.iter() {
+                            flycheck.restart();
+                        }
+                    }
+                    Ok(())
+                };
+                this.task_pool.handle.spawn_with_sender(move |_| {
+                    if let Err(e) = std::panic::catch_unwind(task) {
+                        tracing::error!("flycheck task panicked: {e:?}")
+                    }
+                });
+                true
+            } else {
+                false
+            }
+        }
+
         NotificationDispatcher { not: Some(not), global_state: self }
             .on::<lsp_types::notification::Cancel>(|this, params| {
                 let id: lsp_server::RequestId = match params.id {
@@ -782,6 +864,20 @@ impl GlobalState {
                 }
                 Ok(())
             })?
+            .on::<lsp_ext::RunFlycheck>(|this, params| {
+                if let Some(text_document) = params.text_document {
+                    if let Ok(vfs_path) = from_proto::vfs_path(&text_document.uri) {
+                        if run_flycheck(this, vfs_path) {
+                            return Ok(());
+                        }
+                    }
+                }
+                // No specific flycheck was triggered, so let's trigger all of them.
+                for flycheck in this.flycheck.iter() {
+                    flycheck.restart();
+                }
+                Ok(())
+            })?
             .on::<lsp_types::notification::DidSaveTextDocument>(|this, params| {
                 if let Ok(vfs_path) = from_proto::vfs_path(&params.text_document.uri) {
                     // Re-fetch workspaces if a workspace related file has changed
@@ -792,82 +888,7 @@ impl GlobalState {
                         }
                     }
 
-                    let file_id = this.vfs.read().0.file_id(&vfs_path);
-                    if let Some(file_id) = file_id {
-                        let world = this.snapshot();
-                        let mut updated = false;
-                        let task = move || -> std::result::Result<(), ide::Cancelled> {
-                            // Trigger flychecks for all workspaces that depend on the saved file
-                            // Crates containing or depending on the saved file
-                            let crate_ids: Vec<_> = world
-                                .analysis
-                                .crates_for(file_id)?
-                                .into_iter()
-                                .flat_map(|id| world.analysis.transitive_rev_deps(id))
-                                .flatten()
-                                .sorted()
-                                .unique()
-                                .collect();
-
-                            let crate_root_paths: Vec<_> = crate_ids
-                                .iter()
-                                .filter_map(|&crate_id| {
-                                    world
-                                        .analysis
-                                        .crate_root(crate_id)
-                                        .map(|file_id| {
-                                            world
-                                                .file_id_to_file_path(file_id)
-                                                .as_path()
-                                                .map(ToOwned::to_owned)
-                                        })
-                                        .transpose()
-                                })
-                                .collect::<ide::Cancellable<_>>()?;
-                            let crate_root_paths: Vec<_> =
-                                crate_root_paths.iter().map(Deref::deref).collect();
-
-                            // Find all workspaces that have at least one target containing the saved file
-                            let workspace_ids =
-                                world.workspaces.iter().enumerate().filter(|(_, ws)| match ws {
-                                    project_model::ProjectWorkspace::Cargo { cargo, .. } => {
-                                        cargo.packages().any(|pkg| {
-                                            cargo[pkg].targets.iter().any(|&it| {
-                                                crate_root_paths.contains(&cargo[it].root.as_path())
-                                            })
-                                        })
-                                    }
-                                    project_model::ProjectWorkspace::Json { project, .. } => {
-                                        project.crates().any(|(c, _)| {
-                                            crate_ids.iter().any(|&crate_id| crate_id == c)
-                                        })
-                                    }
-                                    project_model::ProjectWorkspace::DetachedFiles { .. } => false,
-                                });
-
-                            // Find and trigger corresponding flychecks
-                            for flycheck in world.flycheck.iter() {
-                                for (id, _) in workspace_ids.clone() {
-                                    if id == flycheck.id() {
-                                        updated = true;
-                                        flycheck.restart();
-                                        continue;
-                                    }
-                                }
-                            }
-                            // No specific flycheck was triggered, so let's trigger all of them.
-                            if !updated {
-                                for flycheck in world.flycheck.iter() {
-                                    flycheck.restart();
-                                }
-                            }
-                            Ok(())
-                        };
-                        this.task_pool.handle.spawn_with_sender(move |_| {
-                            if let Err(e) = std::panic::catch_unwind(task) {
-                                tracing::error!("DidSaveTextDocument flycheck task panicked: {e:?}")
-                            }
-                        });
+                    if run_flycheck(this, vfs_path) {
                         return Ok(());
                     }
                 }
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 5aced035d52..308a92bebe0 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: 61fe425627f9baaa
+lsp_ext.rs hash: 1cb29d3afa36e743
 
 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/editors/code/package.json b/editors/code/package.json
index 5b83701a682..bfaad1edcea 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -246,6 +246,11 @@
                 "command": "rust-analyzer.cancelFlycheck",
                 "title": "Cancel running flychecks",
                 "category": "rust-analyzer"
+            },
+            {
+                "command": "rust-analyzer.runFlycheck",
+                "title": "Run flycheck",
+                "category": "rust-analyzer"
             }
         ],
         "keybindings": [
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 312087e4cff..e0b4bb63c31 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -788,8 +788,17 @@ export function openDocs(ctx: CtxInit): Cmd {
 
 export function cancelFlycheck(ctx: CtxInit): Cmd {
     return async () => {
+        await ctx.client.sendRequest(ra.cancelFlycheck);
+    };
+}
+
+export function runFlycheck(ctx: CtxInit): Cmd {
+    return async () => {
+        const editor = ctx.activeRustEditor;
         const client = ctx.client;
-        await client.sendRequest(ra.cancelFlycheck);
+        const params = editor ? { uri: editor.document.uri.toString() } : null;
+
+        await client.sendNotification(ra.runFlycheck, { textDocument: params });
     };
 }
 
@@ -797,12 +806,12 @@ export function resolveCodeAction(ctx: CtxInit): Cmd {
     return async (params: lc.CodeAction) => {
         const client = ctx.client;
         params.command = undefined;
-        const item = await client?.sendRequest(lc.CodeActionResolveRequest.type, params);
+        const item = await client.sendRequest(lc.CodeActionResolveRequest.type, params);
         if (!item?.edit) {
             return;
         }
         const itemEdit = item.edit;
-        const edit = await client?.protocol2CodeConverter.asWorkspaceEdit(itemEdit);
+        const edit = await client.protocol2CodeConverter.asWorkspaceEdit(itemEdit);
         // filter out all text edits and recreate the WorkspaceEdit without them so we can apply
         // snippet edits on our own
         const lcFileSystemEdit = {
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 875261c48a6..78da4e959c6 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -81,6 +81,10 @@ export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, Te
 
 export const cancelFlycheck = new lc.RequestType0<void, void>("rust-analyzer/cancelFlycheck");
 
+export const runFlycheck = new lc.NotificationType<{
+    textDocument: lc.TextDocumentIdentifier | null;
+}>("rust-analyzer/runFlycheck");
+
 // Experimental extensions
 
 export interface SsrParams {
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 01a1a2db7fd..c5fc44b4f9f 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -150,6 +150,7 @@ function createCommands(): Record<string, CommandFactory> {
         moveItemUp: { enabled: commands.moveItemUp },
         moveItemDown: { enabled: commands.moveItemDown },
         cancelFlycheck: { enabled: commands.cancelFlycheck },
+        runFlycheck: { enabled: commands.runFlycheck },
         ssr: { enabled: commands.ssr },
         serverVersion: { enabled: commands.serverVersion },
         // Internal commands which are invoked by the server.
-- 
cgit 1.4.1-3-g733a5


From d8ddde27f9c37ba23b4eaab24759e2c1459e8ad4 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sat, 17 Dec 2022 23:29:25 +0100
Subject: Make cancelFlycheck request a notification

---
 crates/rust-analyzer/src/lsp_ext.rs   | 3 +--
 crates/rust-analyzer/src/main_loop.rs | 2 +-
 editors/code/src/commands.ts          | 2 +-
 editors/code/src/lsp_ext.ts           | 2 +-
 4 files changed, 4 insertions(+), 5 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index a2d539cf6ca..f03b8398c1d 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -132,9 +132,8 @@ pub struct ExpandedMacro {
 
 pub enum CancelFlycheck {}
 
-impl Request for CancelFlycheck {
+impl Notification for CancelFlycheck {
     type Params = ();
-    type Result = ();
     const METHOD: &'static str = "rust-analyzer/cancelFlycheck";
 }
 
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 8d621cc36aa..add999504d8 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -635,7 +635,6 @@ impl GlobalState {
             .on_sync_mut::<lsp_ext::ReloadWorkspace>(handlers::handle_workspace_reload)
             .on_sync_mut::<lsp_ext::MemoryUsage>(handlers::handle_memory_usage)
             .on_sync_mut::<lsp_ext::ShuffleCrateGraph>(handlers::handle_shuffle_crate_graph)
-            .on_sync_mut::<lsp_ext::CancelFlycheck>(handlers::handle_cancel_flycheck)
             .on_sync::<lsp_ext::JoinLines>(handlers::handle_join_lines)
             .on_sync::<lsp_ext::OnEnter>(handlers::handle_on_enter)
             .on_sync::<lsp_types::request::SelectionRangeRequest>(handlers::handle_selection_range)
@@ -822,6 +821,7 @@ impl GlobalState {
                 }
                 Ok(())
             })?
+            .on::<lsp_ext::CancelFlycheck>(handlers::handle_cancel_flycheck)?
             .on::<lsp_types::notification::DidChangeTextDocument>(|this, params| {
                 if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
                     match this.mem_docs.get_mut(&path) {
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index e0b4bb63c31..283771f270f 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -788,7 +788,7 @@ export function openDocs(ctx: CtxInit): Cmd {
 
 export function cancelFlycheck(ctx: CtxInit): Cmd {
     return async () => {
-        await ctx.client.sendRequest(ra.cancelFlycheck);
+        await ctx.client.sendNotification(ra.cancelFlycheck);
     };
 }
 
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 78da4e959c6..6f63084108a 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -79,7 +79,7 @@ export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, Te
     "rust-analyzer/relatedTests"
 );
 
-export const cancelFlycheck = new lc.RequestType0<void, void>("rust-analyzer/cancelFlycheck");
+export const cancelFlycheck = new lc.NotificationType0("rust-analyzer/cancelFlycheck");
 
 export const runFlycheck = new lc.NotificationType<{
     textDocument: lc.TextDocumentIdentifier | null;
-- 
cgit 1.4.1-3-g733a5


From cf8d89e46bdd636d0b28f047360943d21e3c6124 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sat, 17 Dec 2022 23:43:26 +0100
Subject: Add a command to clear flycheck diagnostics

---
 crates/rust-analyzer/src/lsp_ext.rs   |  7 ++++++
 crates/rust-analyzer/src/main_loop.rs |  4 ++++
 docs/dev/lsp-extensions.md            | 41 ++++++++++++++++++++++++++++++++++-
 editors/code/package.json             |  5 +++++
 editors/code/src/commands.ts          |  6 +++++
 editors/code/src/lsp_ext.ts           |  2 +-
 editors/code/src/main.ts              |  1 +
 7 files changed, 64 insertions(+), 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index f03b8398c1d..65620b4209b 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -144,6 +144,13 @@ impl Notification for RunFlycheck {
     const METHOD: &'static str = "rust-analyzer/runFlycheck";
 }
 
+pub enum ClearFlycheck {}
+
+impl Notification for ClearFlycheck {
+    type Params = ();
+    const METHOD: &'static str = "rust-analyzer/clearFlycheck";
+}
+
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RunFlycheckParams {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index add999504d8..47776f734b0 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -861,6 +861,10 @@ impl GlobalState {
                 }
                 Ok(())
             })?
+            .on::<lsp_ext::ClearFlycheck>(|this, ()| {
+                this.diagnostics.clear_check_all();
+                Ok(())
+            })?
             .on::<lsp_ext::RunFlycheck>(|this, params| {
                 if let Some(text_document) = params.text_document {
                     if let Ok(vfs_path) = from_proto::vfs_path(&text_document.uri) {
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 308a92bebe0..1bbb4c2323c 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: 1cb29d3afa36e743
+lsp_ext.rs hash: 45bd7985265725c5
 
 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:
@@ -459,6 +459,45 @@ Note that this functionality is intended primarily to inform the end user about
 In particular, it's valid for the client to completely ignore this extension.
 Clients are discouraged from but are allowed to use the `health` status to decide if it's worth sending a request to the server.
 
+### Controlling Flycheck
+
+The flycheck/checkOnSave feature can be controlled via notifications sent by the client to the server.
+
+**Method:** `rust-analyzer/runFlycheck`
+
+**Notification:**
+
+```typescript
+interface RunFlycheckParams {
+    /// The text document whose cargo workspace flycheck process should be started.
+    /// If the document is null or does not belong to a cargo workspace all flycheck processes will be started.
+    textDocument: lc.TextDocumentIdentifier | null;
+}
+```
+
+Triggers the flycheck processes.
+
+
+**Method:** `rust-analyzer/clearFlycheck`
+
+**Notification:**
+
+```typescript
+interface ClearFlycheckParams {}
+```
+
+Clears the flycheck diagnostics.
+
+**Method:** `rust-analyzer/cancelFlycheck`
+
+**Notification:**
+
+```typescript
+interface CancelFlycheckParams {}
+```
+
+Cancels all running flycheck processes.
+
 ## Syntax Tree
 
 **Method:** `rust-analyzer/syntaxTree`
diff --git a/editors/code/package.json b/editors/code/package.json
index bfaad1edcea..f9b0e28dadb 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -251,6 +251,11 @@
                 "command": "rust-analyzer.runFlycheck",
                 "title": "Run flycheck",
                 "category": "rust-analyzer"
+            },
+            {
+                "command": "rust-analyzer.clearFlycheck",
+                "title": "Clear flycheck diagnostics",
+                "category": "rust-analyzer"
             }
         ],
         "keybindings": [
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 283771f270f..cb4e13e2c60 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -792,6 +792,12 @@ export function cancelFlycheck(ctx: CtxInit): Cmd {
     };
 }
 
+export function clearFlycheck(ctx: CtxInit): Cmd {
+    return async () => {
+        await ctx.client.sendNotification(ra.clearFlycheck);
+    };
+}
+
 export function runFlycheck(ctx: CtxInit): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 6f63084108a..29349cc20f5 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -80,7 +80,7 @@ export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, Te
 );
 
 export const cancelFlycheck = new lc.NotificationType0("rust-analyzer/cancelFlycheck");
-
+export const clearFlycheck = new lc.NotificationType0("rust-analyzer/clearFlycheck");
 export const runFlycheck = new lc.NotificationType<{
     textDocument: lc.TextDocumentIdentifier | null;
 }>("rust-analyzer/runFlycheck");
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index c5fc44b4f9f..9a9667b2cd2 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -150,6 +150,7 @@ function createCommands(): Record<string, CommandFactory> {
         moveItemUp: { enabled: commands.moveItemUp },
         moveItemDown: { enabled: commands.moveItemDown },
         cancelFlycheck: { enabled: commands.cancelFlycheck },
+        clearFlycheck: { enabled: commands.clearFlycheck },
         runFlycheck: { enabled: commands.runFlycheck },
         ssr: { enabled: commands.ssr },
         serverVersion: { enabled: commands.serverVersion },
-- 
cgit 1.4.1-3-g733a5


From ddc0147d536b26a980c0446f86cda0e40378ea32 Mon Sep 17 00:00:00 2001
From: Alex Veber <alexveber@gmail.com>
Date: Tue, 27 Dec 2022 08:13:38 +0200
Subject: Fix diagnostic code

---
 editors/code/package.json  |  5 +++++
 editors/code/src/client.ts | 14 ++++++++++++--
 editors/code/src/config.ts |  4 ++++
 3 files changed, 21 insertions(+), 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index fad67ce8031..91532b3e96a 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -411,6 +411,11 @@
                     "default": false,
                     "type": "boolean"
                 },
+                "rust-analyzer.diagnostics.useRustcErrorCode": {
+                    "markdownDescription": "Whether to use the rustc error code.",
+                    "default": false,
+                    "type": "boolean"
+                },
                 "$generated-start": {},
                 "rust-analyzer.assist.emitMustUse": {
                     "markdownDescription": "Whether to insert #[must_use] when generating `as_` methods\nfor enum variants.",
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 23e039722ee..1470c1f581d 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -106,6 +106,7 @@ export async function createClient(
                 next: lc.HandleDiagnosticsSignature
             ) {
                 const preview = config.previewRustcOutput;
+                const errorCode = config.useRustcErrorCode;
                 diagnostics.forEach((diag, idx) => {
                     // Abuse the fact that VSCode leaks the LSP diagnostics data field through the
                     // Diagnostic class, if they ever break this we are out of luck and have to go
@@ -119,11 +120,20 @@ export async function createClient(
                         ?.rendered;
                     if (rendered) {
                         if (preview) {
-                            const index = rendered.match(/^(note|help):/m)?.index || 0;
+                            const index =
+                                rendered.match(/^(note|help):/m)?.index || rendered.length;
                             diag.message = rendered
                                 .substring(0, index)
                                 .replace(/^ -->[^\n]+\n/m, "");
                         }
+                        let value;
+                        if (errorCode) {
+                            if (typeof diag.code === "string" || typeof diag.code === "number") {
+                                value = diag.code;
+                            } else {
+                                value = diag.code?.value;
+                            }
+                        }
                         diag.code = {
                             target: vscode.Uri.from({
                                 scheme: "rust-analyzer-diagnostics-view",
@@ -131,7 +141,7 @@ export async function createClient(
                                 fragment: uri.toString(),
                                 query: idx.toString(),
                             }),
-                            value: "Click for full compiler diagnostic",
+                            value: value ?? "Click for full compiler diagnostic",
                         };
                     }
                 });
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index d8dbd1df16d..eb4f965291f 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -241,6 +241,10 @@ export class Config {
     get previewRustcOutput() {
         return this.get<boolean>("diagnostics.previewRustcOutput");
     }
+
+    get useRustcErrorCode() {
+        return this.get<boolean>("diagnostics.useRustcErrorCode");
+    }
 }
 
 const VarRegex = new RegExp(/\$\{(.+?)\}/g);
-- 
cgit 1.4.1-3-g733a5


From c4d8cf1dad9e2ad5710c56533c42979e91520c78 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 3 Jan 2023 12:32:38 +0100
Subject: Use ZWNJ to prevent VSCode from forming ligatures between hints and
 code

---
 editors/code/src/client.ts | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 1470c1f581d..e6595340aae 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -100,6 +100,24 @@ export async function createClient(
                     }
                 },
             },
+            async provideInlayHints(document, viewPort, token, next) {
+                const inlays = await next(document, viewPort, token);
+                if (!inlays) {
+                    return inlays;
+                }
+                // U+200C is a zero-width non-joiner to prevent the editor from forming a ligature
+                // between code and hints
+                for (const inlay of inlays) {
+                    if (typeof inlay.label === "string") {
+                        inlay.label = `\u{200c}${inlay.label}\u{200c}`;
+                    } else if (Array.isArray(inlay.label)) {
+                        for (const it of inlay.label) {
+                            it.value = `\u{200c}${it.value}\u{200c}`;
+                        }
+                    }
+                }
+                return inlays;
+            },
             async handleDiagnostics(
                 uri: vscode.Uri,
                 diagnostics: vscode.Diagnostic[],
-- 
cgit 1.4.1-3-g733a5


From 1b8141b54cb5f89bd3dee7bfbab41109d1b48cb6 Mon Sep 17 00:00:00 2001
From: Ian Chamberlain <ichamberlain@juniper.net>
Date: Tue, 3 Jan 2023 10:16:16 -0500
Subject: Parse + decorate rendered ANSI cargo output

Use ANSI control characters to display text decorations matching the
VScode terminal theme, and strip them out when providing text content
for rustc diagnostics.

This adds the small `anser` library to parse the control codes, and it
also supports HTML output so it should be fairly easy to switch to a
rendered HTML/webview implementation if desired.
---
 editors/code/package-lock.json  |  11 +++
 editors/code/package.json       |   1 +
 editors/code/src/client.ts      |  11 ++-
 editors/code/src/diagnostics.ts | 212 ++++++++++++++++++++++++++++++++++++++++
 editors/code/src/main.ts        |  61 ++++++++----
 5 files changed, 272 insertions(+), 24 deletions(-)
 create mode 100644 editors/code/src/diagnostics.ts

(limited to 'editors/code/src')

diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index ee69d224760..4844837a06f 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -9,6 +9,7 @@
             "version": "0.5.0-dev",
             "license": "MIT OR Apache-2.0",
             "dependencies": {
+                "anser": "^2.1.1",
                 "d3": "^7.6.1",
                 "d3-graphviz": "^5.0.2",
                 "vscode-languageclient": "^8.0.2"
@@ -394,6 +395,11 @@
                 "url": "https://github.com/sponsors/epoberezkin"
             }
         },
+        "node_modules/anser": {
+            "version": "2.1.1",
+            "resolved": "https://registry.npmjs.org/anser/-/anser-2.1.1.tgz",
+            "integrity": "sha512-nqLm4HxOTpeLOxcmB3QWmV5TcDFhW9y/fyQ+hivtDFcK4OQ+pQ5fzPnXHM1Mfcm0VkLtvVi1TCPr++Qy0Q/3EQ=="
+        },
         "node_modules/ansi-regex": {
             "version": "5.0.1",
             "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
@@ -4096,6 +4102,11 @@
                 "uri-js": "^4.2.2"
             }
         },
+        "anser": {
+            "version": "2.1.1",
+            "resolved": "https://registry.npmjs.org/anser/-/anser-2.1.1.tgz",
+            "integrity": "sha512-nqLm4HxOTpeLOxcmB3QWmV5TcDFhW9y/fyQ+hivtDFcK4OQ+pQ5fzPnXHM1Mfcm0VkLtvVi1TCPr++Qy0Q/3EQ=="
+        },
         "ansi-regex": {
             "version": "5.0.1",
             "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
diff --git a/editors/code/package.json b/editors/code/package.json
index 468368668fc..3fe189e2b3b 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -35,6 +35,7 @@
         "test": "cross-env TEST_VARIABLE=test node ./out/tests/runTests.js"
     },
     "dependencies": {
+        "anser": "^2.1.1",
         "d3": "^7.6.1",
         "d3-graphviz": "^5.0.2",
         "vscode-languageclient": "^8.0.2"
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index e6595340aae..74cf44f42f7 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -3,6 +3,7 @@ import * as vscode from "vscode";
 import * as ra from "../src/lsp_ext";
 import * as Is from "vscode-languageclient/lib/common/utils/is";
 import { assert } from "./util";
+import * as diagnostics from "./diagnostics";
 import { WorkspaceEdit } from "vscode";
 import { Config, substituteVSCodeVariables } from "./config";
 import { randomUUID } from "crypto";
@@ -120,12 +121,12 @@ export async function createClient(
             },
             async handleDiagnostics(
                 uri: vscode.Uri,
-                diagnostics: vscode.Diagnostic[],
+                diagnosticList: vscode.Diagnostic[],
                 next: lc.HandleDiagnosticsSignature
             ) {
                 const preview = config.previewRustcOutput;
                 const errorCode = config.useRustcErrorCode;
-                diagnostics.forEach((diag, idx) => {
+                diagnosticList.forEach((diag, idx) => {
                     // Abuse the fact that VSCode leaks the LSP diagnostics data field through the
                     // Diagnostic class, if they ever break this we are out of luck and have to go
                     // back to the worst diagnostics experience ever:)
@@ -154,8 +155,8 @@ export async function createClient(
                         }
                         diag.code = {
                             target: vscode.Uri.from({
-                                scheme: "rust-analyzer-diagnostics-view",
-                                path: "/diagnostic message",
+                                scheme: diagnostics.URI_SCHEME,
+                                path: `/diagnostic message [${idx.toString()}]`,
                                 fragment: uri.toString(),
                                 query: idx.toString(),
                             }),
@@ -163,7 +164,7 @@ export async function createClient(
                         };
                     }
                 });
-                return next(uri, diagnostics);
+                return next(uri, diagnosticList);
             },
             async provideHover(
                 document: vscode.TextDocument,
diff --git a/editors/code/src/diagnostics.ts b/editors/code/src/diagnostics.ts
new file mode 100644
index 00000000000..9695d8bf26d
--- /dev/null
+++ b/editors/code/src/diagnostics.ts
@@ -0,0 +1,212 @@
+import * as anser from "anser";
+import * as vscode from "vscode";
+import { ProviderResult, Range, TextEditorDecorationType, ThemeColor, window } from "vscode";
+import { Ctx } from "./ctx";
+
+export const URI_SCHEME = "rust-analyzer-diagnostics-view";
+
+export class TextDocumentProvider implements vscode.TextDocumentContentProvider {
+    private _onDidChange = new vscode.EventEmitter<vscode.Uri>();
+
+    public constructor(private readonly ctx: Ctx) {}
+
+    get onDidChange(): vscode.Event<vscode.Uri> {
+        return this._onDidChange.event;
+    }
+
+    triggerUpdate(uri: vscode.Uri) {
+        if (uri.scheme === URI_SCHEME) {
+            this._onDidChange.fire(uri);
+        }
+    }
+
+    dispose() {
+        this._onDidChange.dispose();
+    }
+
+    async provideTextDocumentContent(uri: vscode.Uri): Promise<string> {
+        const contents = getRenderedDiagnostic(this.ctx, uri);
+        return anser.ansiToText(contents);
+    }
+}
+
+function getRenderedDiagnostic(ctx: Ctx, uri: vscode.Uri): string {
+    const diags = ctx.client?.diagnostics?.get(vscode.Uri.parse(uri.fragment, true));
+    if (!diags) {
+        return "Unable to find original rustc diagnostic";
+    }
+
+    const diag = diags[parseInt(uri.query)];
+    if (!diag) {
+        return "Unable to find original rustc diagnostic";
+    }
+    const rendered = (diag as unknown as { data?: { rendered?: string } }).data?.rendered;
+
+    if (!rendered) {
+        return "Unable to find original rustc diagnostic";
+    }
+
+    return rendered;
+}
+
+interface AnserStyle {
+    fg: string;
+    bg: string;
+    fg_truecolor: string;
+    bg_truecolor: string;
+    decorations: Array<anser.DecorationName>;
+}
+
+export class AnsiDecorationProvider implements vscode.Disposable {
+    private _decorationTypes = new Map<AnserStyle, TextEditorDecorationType>();
+
+    public constructor(private readonly ctx: Ctx) {}
+
+    dispose(): void {
+        for (const decorationType of this._decorationTypes.values()) {
+            decorationType.dispose();
+        }
+
+        this._decorationTypes.clear();
+    }
+
+    async provideDecorations(editor: vscode.TextEditor) {
+        if (editor.document.uri.scheme !== URI_SCHEME) {
+            return;
+        }
+
+        const decorations = (await this._getDecorations(editor.document.uri)) || [];
+        for (const [decorationType, ranges] of decorations) {
+            editor.setDecorations(decorationType, ranges);
+        }
+    }
+
+    private _getDecorations(
+        uri: vscode.Uri
+    ): ProviderResult<[TextEditorDecorationType, Range[]][]> {
+        const stringContents = getRenderedDiagnostic(this.ctx, uri);
+        const lines = stringContents.split("\n");
+
+        const result = new Map<TextEditorDecorationType, Range[]>();
+        // Populate all known decoration types in the result. This forces any
+        // lingering decorations to be cleared if the text content changes to
+        // something without ANSI codes for a given decoration type.
+        for (const decorationType of this._decorationTypes.values()) {
+            result.set(decorationType, []);
+        }
+
+        for (const [lineNumber, line] of lines.entries()) {
+            const totalEscapeLength = 0;
+
+            // eslint-disable-next-line camelcase
+            const parsed = anser.ansiToJson(line, { use_classes: true });
+
+            let offset = 0;
+
+            for (const span of parsed) {
+                const { content, ...style } = span;
+
+                const range = new Range(
+                    lineNumber,
+                    offset - totalEscapeLength,
+                    lineNumber,
+                    offset + content.length - totalEscapeLength
+                );
+
+                offset += content.length;
+
+                const decorationType = this._getDecorationType(style);
+
+                if (!result.has(decorationType)) {
+                    result.set(decorationType, []);
+                }
+
+                result.get(decorationType)!.push(range);
+            }
+        }
+
+        return [...result];
+    }
+
+    private _getDecorationType(style: AnserStyle): TextEditorDecorationType {
+        let decorationType = this._decorationTypes.get(style);
+
+        if (decorationType) {
+            return decorationType;
+        }
+
+        const fontWeight = style.decorations.find((s) => s === "bold");
+        const fontStyle = style.decorations.find((s) => s === "italic");
+        const textDecoration = style.decorations.find((s) => s === "underline");
+
+        decorationType = window.createTextEditorDecorationType({
+            backgroundColor: AnsiDecorationProvider._convertColor(style.bg, style.bg_truecolor),
+            color: AnsiDecorationProvider._convertColor(style.fg, style.fg_truecolor),
+            fontWeight,
+            fontStyle,
+            textDecoration,
+        });
+
+        this._decorationTypes.set(style, decorationType);
+
+        return decorationType;
+    }
+
+    // NOTE: This could just be a kebab-case to camelCase conversion, but I think it's
+    // a short enough list to just write these by hand
+    static readonly _anserToThemeColor: Record<string, ThemeColor> = {
+        "ansi-black": "ansiBlack",
+        "ansi-white": "ansiWhite",
+        "ansi-red": "ansiRed",
+        "ansi-green": "ansiGreen",
+        "ansi-yellow": "ansiYellow",
+        "ansi-blue": "ansiBlue",
+        "ansi-magenta": "ansiMagenta",
+        "ansi-cyan": "ansiCyan",
+
+        "ansi-bright-black": "ansiBrightBlack",
+        "ansi-bright-white": "ansiBrightWhite",
+        "ansi-bright-red": "ansiBrightRed",
+        "ansi-bright-green": "ansiBrightGreen",
+        "ansi-bright-yellow": "ansiBrightYellow",
+        "ansi-bright-blue": "ansiBrightBlue",
+        "ansi-bright-magenta": "ansiBrightMagenta",
+        "ansi-bright-cyan": "ansiBrightCyan",
+    };
+
+    private static _convertColor(
+        color?: string,
+        truecolor?: string
+    ): ThemeColor | string | undefined {
+        if (!color) {
+            return undefined;
+        }
+
+        if (color === "ansi-truecolor") {
+            if (!truecolor) {
+                return undefined;
+            }
+            return `rgb(${truecolor})`;
+        }
+
+        const paletteMatch = color.match(/ansi-palette-(.+)/);
+        if (paletteMatch) {
+            const paletteColor = paletteMatch[1];
+            // anser won't return both the RGB and the color name at the same time,
+            // so just fake a single foreground control char with the palette number:
+            const spans = anser.ansiToJson(`\x1b[38;5;${paletteColor}m`);
+            const rgb = spans[1].fg;
+
+            if (rgb) {
+                return `rgb(${rgb})`;
+            }
+        }
+
+        const themeColor = AnsiDecorationProvider._anserToThemeColor[color];
+        if (themeColor) {
+            return new ThemeColor("terminal." + themeColor);
+        }
+
+        return undefined;
+    }
+}
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 9a9667b2cd2..dd439317c70 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -3,6 +3,7 @@ import * as lc from "vscode-languageclient/node";
 
 import * as commands from "./commands";
 import { CommandFactory, Ctx, fetchWorkspace } from "./ctx";
+import * as diagnostics from "./diagnostics";
 import { activateTaskProvider } from "./tasks";
 import { setContextValue } from "./util";
 
@@ -48,30 +49,52 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
         ctx.pushExtCleanup(activateTaskProvider(ctx.config));
     }
 
+    const diagnosticProvider = new diagnostics.TextDocumentProvider(ctx);
     ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider(
-            "rust-analyzer-diagnostics-view",
-            new (class implements vscode.TextDocumentContentProvider {
-                async provideTextDocumentContent(uri: vscode.Uri): Promise<string> {
-                    const diags = ctx.client?.diagnostics?.get(
-                        vscode.Uri.parse(uri.fragment, true)
-                    );
-                    if (!diags) {
-                        return "Unable to find original rustc diagnostic";
-                    }
-
-                    const diag = diags[parseInt(uri.query)];
-                    if (!diag) {
-                        return "Unable to find original rustc diagnostic";
-                    }
-                    const rendered = (diag as unknown as { data?: { rendered?: string } }).data
-                        ?.rendered;
-                    return rendered ?? "Unable to find original rustc diagnostic";
-                }
-            })()
+            diagnostics.URI_SCHEME,
+            diagnosticProvider
         )
     );
 
+    const decorationProvider = new diagnostics.AnsiDecorationProvider(ctx);
+    ctx.pushExtCleanup(decorationProvider);
+
+    async function decorateVisibleEditors(document: vscode.TextDocument) {
+        for (const editor of vscode.window.visibleTextEditors) {
+            if (document === editor.document) {
+                await decorationProvider.provideDecorations(editor);
+            }
+        }
+    }
+
+    vscode.workspace.onDidChangeTextDocument(
+        async (event) => await decorateVisibleEditors(event.document),
+        null,
+        ctx.subscriptions
+    );
+    vscode.workspace.onDidOpenTextDocument(decorateVisibleEditors, null, ctx.subscriptions);
+    vscode.window.onDidChangeActiveTextEditor(
+        async (editor) => {
+            if (editor) {
+                diagnosticProvider.triggerUpdate(editor.document.uri);
+                await decorateVisibleEditors(editor.document);
+            }
+        },
+        null,
+        ctx.subscriptions
+    );
+    vscode.window.onDidChangeVisibleTextEditors(
+        async (visibleEditors) => {
+            for (const editor of visibleEditors) {
+                diagnosticProvider.triggerUpdate(editor.document.uri);
+                await decorationProvider.provideDecorations(editor);
+            }
+        },
+        null,
+        ctx.subscriptions
+    );
+
     vscode.workspace.onDidChangeWorkspaceFolders(
         async (_) => ctx.onWorkspaceFolderChanges(),
         null,
-- 
cgit 1.4.1-3-g733a5


From 738ce83d858aa498c3ff28be3417101ab5f9ce6f Mon Sep 17 00:00:00 2001
From: Ian Chamberlain <ichamberlain@juniper.net>
Date: Tue, 3 Jan 2023 10:49:47 -0500
Subject: Strip colors before matching preview diagnostics

---
 editors/code/src/client.ts | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 74cf44f42f7..c6d64ebc1ed 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -1,3 +1,4 @@
+import * as anser from "anser";
 import * as lc from "vscode-languageclient/node";
 import * as vscode from "vscode";
 import * as ra from "../src/lsp_ext";
@@ -139,9 +140,10 @@ export async function createClient(
                         ?.rendered;
                     if (rendered) {
                         if (preview) {
+                            const decolorized = anser.ansiToText(rendered);
                             const index =
-                                rendered.match(/^(note|help):/m)?.index || rendered.length;
-                            diag.message = rendered
+                                decolorized.match(/^(note|help):/m)?.index || rendered.length;
+                            diag.message = decolorized
                                 .substring(0, index)
                                 .replace(/^ -->[^\n]+\n/m, "");
                         }
-- 
cgit 1.4.1-3-g733a5


From 65cf7abbe2ee75cce74592fa0af75356181566be Mon Sep 17 00:00:00 2001
From: Ian Chamberlain <ichamberlain@juniper.net>
Date: Wed, 4 Jan 2023 12:04:45 -0500
Subject: Use experimental capability to enable color codes

---
 crates/flycheck/src/lib.rs         | 18 ++++++++++++------
 crates/rust-analyzer/src/config.rs | 10 ++++++++--
 docs/user/generated_config.adoc    |  4 ++--
 editors/code/package.json          |  2 +-
 editors/code/src/client.ts         |  1 +
 5 files changed, 24 insertions(+), 11 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 2911c2589a3..11f7b068ecb 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -47,6 +47,7 @@ pub enum FlycheckConfig {
         features: Vec<String>,
         extra_args: Vec<String>,
         extra_env: FxHashMap<String, String>,
+        ansi_color_output: bool,
     },
     CustomCommand {
         command: String,
@@ -293,16 +294,21 @@ impl FlycheckActor {
                 extra_args,
                 features,
                 extra_env,
+                ansi_color_output,
             } => {
                 let mut cmd = Command::new(toolchain::cargo());
                 cmd.arg(command);
                 cmd.current_dir(&self.root);
-                cmd.args([
-                    "--workspace",
-                    "--message-format=json-diagnostic-rendered-ansi",
-                    "--manifest-path",
-                ])
-                .arg(self.root.join("Cargo.toml").as_os_str());
+                cmd.arg("--workspace");
+
+                cmd.arg(if *ansi_color_output {
+                    "--message-format=json-diagnostic-rendered-ansi"
+                } else {
+                    "--message-format=json"
+                });
+
+                cmd.arg("--manifest-path");
+                cmd.arg(self.root.join("Cargo.toml").as_os_str());
 
                 for target in target_triples {
                     cmd.args(["--target", target.as_str()]);
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 006256544f3..b0afbdc9a42 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -161,8 +161,8 @@ config_data! {
         /// Override the command rust-analyzer uses instead of `cargo check` for
         /// diagnostics on save. The command is required to output json and
         /// should therefore include `--message-format=json` or a similar option
-        /// (for colored diagnostics, use
-        /// `--message-format=json-diagnostic-rendered-ansi`).
+        /// (if your client supports the `colorDiagnosticOutput` experimental
+        /// capability, you can use `--message-format=json-diagnostic-rendered-ansi`).
         ///
         /// If you're changing this because you're using some tool wrapping
         /// Cargo, you might also want to change
@@ -1008,6 +1008,11 @@ impl Config {
         self.experimental("serverStatusNotification")
     }
 
+    /// Whether the client supports colored output for full diagnostics from `checkOnSave`.
+    pub fn color_diagnostic_output(&self) -> bool {
+        self.experimental("colorDiagnosticOutput")
+    }
+
     pub fn publish_diagnostics(&self) -> bool {
         self.data.diagnostics_enable
     }
@@ -1206,6 +1211,7 @@ impl Config {
                 },
                 extra_args: self.data.check_extraArgs.clone(),
                 extra_env: self.check_on_save_extra_env(),
+                ansi_color_output: self.color_diagnostic_output(),
             },
         }
     }
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index 5a3019831ae..b33a2e79525 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -174,8 +174,8 @@ Whether to pass `--no-default-features` to Cargo. Defaults to
 Override the command rust-analyzer uses instead of `cargo check` for
 diagnostics on save. The command is required to output json and
 should therefore include `--message-format=json` or a similar option
-(for colored diagnostics, use
-`--message-format=json-diagnostic-rendered-ansi`).
+(if your client supports the `colorDiagnosticOutput` experimental
+capability, you can use `--message-format=json-diagnostic-rendered-ansi`).
 
 If you're changing this because you're using some tool wrapping
 Cargo, you might also want to change
diff --git a/editors/code/package.json b/editors/code/package.json
index 77da5e54538..930564bd7ca 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -644,7 +644,7 @@
                     ]
                 },
                 "rust-analyzer.check.overrideCommand": {
-                    "markdownDescription": "Override the command rust-analyzer uses instead of `cargo check` for\ndiagnostics on save. The command is required to output json and\nshould therefore include `--message-format=json` or a similar option\n(for colored diagnostics, use\n`--message-format=json-diagnostic-rendered-ansi`).\n\nIf you're changing this because you're using some tool wrapping\nCargo, you might also want to change\n`#rust-analyzer.cargo.buildScripts.overrideCommand#`.\n\nIf there are multiple linked projects, this command is invoked for\neach of them, with the working directory being the project root\n(i.e., the folder containing the `Cargo.toml`).\n\nAn example command would be:\n\n```bash\ncargo check --workspace --message-format=json --all-targets\n```\n.",
+                    "markdownDescription": "Override the command rust-analyzer uses instead of `cargo check` for\ndiagnostics on save. The command is required to output json and\nshould therefore include `--message-format=json` or a similar option\n(if your client supports the `colorDiagnosticOutput` experimental\ncapability, you can use `--message-format=json-diagnostic-rendered-ansi`).\n\nIf you're changing this because you're using some tool wrapping\nCargo, you might also want to change\n`#rust-analyzer.cargo.buildScripts.overrideCommand#`.\n\nIf there are multiple linked projects, this command is invoked for\neach of them, with the working directory being the project root\n(i.e., the folder containing the `Cargo.toml`).\n\nAn example command would be:\n\n```bash\ncargo check --workspace --message-format=json --all-targets\n```\n.",
                     "default": null,
                     "type": [
                         "null",
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index c6d64ebc1ed..82cdf0390ac 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -333,6 +333,7 @@ class ExperimentalFeatures implements lc.StaticFeature {
         caps.codeActionGroup = true;
         caps.hoverActions = true;
         caps.serverStatusNotification = true;
+        caps.colorDiagnosticOutput = true;
         caps.commands = {
             commands: [
                 "rust-analyzer.runSingle",
-- 
cgit 1.4.1-3-g733a5


From 4267b11c4097b52ec59323c29709a8d06ed7b4cd Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 10 Jan 2023 09:43:08 +0100
Subject: Revert "Use ZWNJ to prevent VSCode from forming ligatures between
 hints and code"

---
 editors/code/src/client.ts | 18 ------------------
 1 file changed, 18 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 82cdf0390ac..1fbe9d4ea03 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -102,24 +102,6 @@ export async function createClient(
                     }
                 },
             },
-            async provideInlayHints(document, viewPort, token, next) {
-                const inlays = await next(document, viewPort, token);
-                if (!inlays) {
-                    return inlays;
-                }
-                // U+200C is a zero-width non-joiner to prevent the editor from forming a ligature
-                // between code and hints
-                for (const inlay of inlays) {
-                    if (typeof inlay.label === "string") {
-                        inlay.label = `\u{200c}${inlay.label}\u{200c}`;
-                    } else if (Array.isArray(inlay.label)) {
-                        for (const it of inlay.label) {
-                            it.value = `\u{200c}${it.value}\u{200c}`;
-                        }
-                    }
-                }
-                return inlays;
-            },
             async handleDiagnostics(
                 uri: vscode.Uri,
                 diagnosticList: vscode.Diagnostic[],
-- 
cgit 1.4.1-3-g733a5


From 1c454736a4f593eebac2c43de9dfb50f9200c250 Mon Sep 17 00:00:00 2001
From: DropDemBits <r3usrlnd@gmail.com>
Date: Tue, 17 Jan 2023 15:29:52 -0500
Subject: Suppress extra indent after the end of dot chains

---
 editors/code/src/config.ts | 118 +++++++++++++++++++++++++++------------------
 1 file changed, 70 insertions(+), 48 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index eb4f965291f..029dc3afd55 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -86,58 +86,80 @@ export class Config {
      * [1]: https://github.com/Microsoft/vscode/issues/11514#issuecomment-244707076
      */
     private configureLanguage() {
-        if (this.typingContinueCommentsOnNewline && !this.configureLang) {
+        if (this.configureLang) return;
+
+        let onEnterRules: vscode.OnEnterRule[] = [
+            {
+                // Carry indentation from the previous line
+                beforeText: /^\s*$/,
+                action: { indentAction: vscode.IndentAction.None },
+            },
+            {
+                // After the end of a function/field chain,
+                // with the semicolon on the same line
+                beforeText: /^\s+\..*;/,
+                action: { indentAction: vscode.IndentAction.Outdent },
+            },
+            {
+                // After the end of a function/field chain,
+                // with semicolon detached from the rest
+                beforeText: /^\s+;/,
+                previousLineText: /^\s+\..*/,
+                action: { indentAction: vscode.IndentAction.Outdent },
+            },
+        ];
+
+        if (this.typingContinueCommentsOnNewline) {
             const indentAction = vscode.IndentAction.None;
 
-            this.configureLang = vscode.languages.setLanguageConfiguration("rust", {
-                onEnterRules: [
-                    {
-                        // Doc single-line comment
-                        // e.g. ///|
-                        beforeText: /^\s*\/{3}.*$/,
-                        action: { indentAction, appendText: "/// " },
+            onEnterRules = [
+                ...onEnterRules,
+                {
+                    // Doc single-line comment
+                    // e.g. ///|
+                    beforeText: /^\s*\/{3}.*$/,
+                    action: { indentAction, appendText: "/// " },
+                },
+                {
+                    // Parent doc single-line comment
+                    // e.g. //!|
+                    beforeText: /^\s*\/{2}\!.*$/,
+                    action: { indentAction, appendText: "//! " },
+                },
+                {
+                    // Begins an auto-closed multi-line comment (standard or parent doc)
+                    // e.g. /** | */ or /*! | */
+                    beforeText: /^\s*\/\*(\*|\!)(?!\/)([^\*]|\*(?!\/))*$/,
+                    afterText: /^\s*\*\/$/,
+                    action: {
+                        indentAction: vscode.IndentAction.IndentOutdent,
+                        appendText: " * ",
                     },
-                    {
-                        // Parent doc single-line comment
-                        // e.g. //!|
-                        beforeText: /^\s*\/{2}\!.*$/,
-                        action: { indentAction, appendText: "//! " },
-                    },
-                    {
-                        // Begins an auto-closed multi-line comment (standard or parent doc)
-                        // e.g. /** | */ or /*! | */
-                        beforeText: /^\s*\/\*(\*|\!)(?!\/)([^\*]|\*(?!\/))*$/,
-                        afterText: /^\s*\*\/$/,
-                        action: {
-                            indentAction: vscode.IndentAction.IndentOutdent,
-                            appendText: " * ",
-                        },
-                    },
-                    {
-                        // Begins a multi-line comment (standard or parent doc)
-                        // e.g. /** ...| or /*! ...|
-                        beforeText: /^\s*\/\*(\*|\!)(?!\/)([^\*]|\*(?!\/))*$/,
-                        action: { indentAction, appendText: " * " },
-                    },
-                    {
-                        // Continues a multi-line comment
-                        // e.g.  * ...|
-                        beforeText: /^(\ \ )*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
-                        action: { indentAction, appendText: "* " },
-                    },
-                    {
-                        // Dedents after closing a multi-line comment
-                        // e.g.  */|
-                        beforeText: /^(\ \ )*\ \*\/\s*$/,
-                        action: { indentAction, removeText: 1 },
-                    },
-                ],
-            });
-        }
-        if (!this.typingContinueCommentsOnNewline && this.configureLang) {
-            this.configureLang.dispose();
-            this.configureLang = undefined;
+                },
+                {
+                    // Begins a multi-line comment (standard or parent doc)
+                    // e.g. /** ...| or /*! ...|
+                    beforeText: /^\s*\/\*(\*|\!)(?!\/)([^\*]|\*(?!\/))*$/,
+                    action: { indentAction, appendText: " * " },
+                },
+                {
+                    // Continues a multi-line comment
+                    // e.g.  * ...|
+                    beforeText: /^(\ \ )*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
+                    action: { indentAction, appendText: "* " },
+                },
+                {
+                    // Dedents after closing a multi-line comment
+                    // e.g.  */|
+                    beforeText: /^(\ \ )*\ \*\/\s*$/,
+                    action: { indentAction, removeText: 1 },
+                },
+            ];
         }
+
+        this.configureLang = vscode.languages.setLanguageConfiguration("rust", {
+            onEnterRules,
+        });
     }
 
     // We don't do runtime config validation here for simplicity. More on stackoverflow:
-- 
cgit 1.4.1-3-g733a5


From 992bafa773255cf9858bdc25c302abbd07d89c7b Mon Sep 17 00:00:00 2001
From: DropDemBits <r3usrlnd@gmail.com>
Date: Tue, 17 Jan 2023 16:25:46 -0500
Subject: Fix change detection for relevant lang config opts

---
 editors/code/src/config.ts | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 029dc3afd55..30ff9784829 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -11,7 +11,9 @@ export type RunnableEnvCfg =
 
 export class Config {
     readonly extensionId = "rust-lang.rust-analyzer";
-    configureLang: vscode.Disposable | undefined;
+    configureLang:
+        | { handle: vscode.Disposable; typingContinueCommentsOnNewline: boolean }
+        | undefined;
 
     readonly rootSection = "rust-analyzer";
     private readonly requiresReloadOpts = [
@@ -43,7 +45,7 @@ export class Config {
     }
 
     dispose() {
-        this.configureLang?.dispose();
+        this.configureLang?.handle.dispose();
     }
 
     private refreshLogging() {
@@ -86,7 +88,15 @@ export class Config {
      * [1]: https://github.com/Microsoft/vscode/issues/11514#issuecomment-244707076
      */
     private configureLanguage() {
-        if (this.configureLang) return;
+        // Only need to dispose of the config if there's a change
+        if (
+            this.configureLang &&
+            this.typingContinueCommentsOnNewline !==
+                this.configureLang.typingContinueCommentsOnNewline
+        ) {
+            this.configureLang.handle.dispose();
+            this.configureLang = undefined;
+        }
 
         let onEnterRules: vscode.OnEnterRule[] = [
             {
@@ -157,9 +167,12 @@ export class Config {
             ];
         }
 
-        this.configureLang = vscode.languages.setLanguageConfiguration("rust", {
-            onEnterRules,
-        });
+        this.configureLang = {
+            handle: vscode.languages.setLanguageConfiguration("rust", {
+                onEnterRules,
+            }),
+            typingContinueCommentsOnNewline: this.typingContinueCommentsOnNewline,
+        };
     }
 
     // We don't do runtime config validation here for simplicity. More on stackoverflow:
-- 
cgit 1.4.1-3-g733a5


From 7198cd04ac14a31fc9e401e6a4e411e401acc326 Mon Sep 17 00:00:00 2001
From: OmarTawfik <15987992+OmarTawfik@users.noreply.github.com>
Date: Fri, 20 Jan 2023 13:22:11 -0800
Subject: allow using vscode variables in `config.serverPath`

---
 editors/code/src/bootstrap.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/bootstrap.ts b/editors/code/src/bootstrap.ts
index 374c3b8144c..cabc7407172 100644
--- a/editors/code/src/bootstrap.ts
+++ b/editors/code/src/bootstrap.ts
@@ -1,6 +1,6 @@
 import * as vscode from "vscode";
 import * as os from "os";
-import { Config } from "./config";
+import { Config, substituteVSCodeVariables } from "./config";
 import { log, isValidExecutable } from "./util";
 import { PersistentState } from "./persistent_state";
 import { exec } from "child_process";
@@ -132,7 +132,7 @@ async function getServer(
     return undefined;
 }
 function serverPath(config: Config): string | null {
-    return process.env.__RA_LSP_SERVER_DEBUG ?? config.serverPath;
+    return process.env.__RA_LSP_SERVER_DEBUG ?? substituteVSCodeVariables(config.serverPath);
 }
 
 async function isNixOs(): Promise<boolean> {
-- 
cgit 1.4.1-3-g733a5


From b9fe5afb30d00e14aaf5d02ff12a74efb774d4f1 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 23 Jan 2023 13:10:25 +0100
Subject: Add a 'open server logs' button to the error notification

---
 crates/rust-analyzer/src/config.rs    |  4 +++
 crates/rust-analyzer/src/lsp_ext.rs   |  7 +++++
 crates/rust-analyzer/src/lsp_utils.rs | 50 +++++++++++++++++++++++++++--------
 docs/dev/lsp-extensions.md            |  2 +-
 editors/code/src/client.ts            |  1 +
 editors/code/src/ctx.ts               |  5 ++++
 editors/code/src/lsp_ext.ts           |  1 +
 7 files changed, 58 insertions(+), 12 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index c4d9ad7dff5..8ea161dbdc4 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -989,6 +989,10 @@ impl Config {
         self.experimental("codeActionGroup")
     }
 
+    pub fn open_server_logs(&self) -> bool {
+        self.experimental("openServerLogs")
+    }
+
     pub fn server_status_notification(&self) -> bool {
         self.experimental("serverStatusNotification")
     }
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index b117acd1b0f..08b2c837de3 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -151,6 +151,13 @@ impl Notification for ClearFlycheck {
     const METHOD: &'static str = "rust-analyzer/clearFlycheck";
 }
 
+pub enum OpenServerLogs {}
+
+impl Notification for OpenServerLogs {
+    type Params = ();
+    const METHOD: &'static str = "rust-analyzer/openServerLogs";
+}
+
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RunFlycheckParams {
diff --git a/crates/rust-analyzer/src/lsp_utils.rs b/crates/rust-analyzer/src/lsp_utils.rs
index dcaee92857a..baa77a005e2 100644
--- a/crates/rust-analyzer/src/lsp_utils.rs
+++ b/crates/rust-analyzer/src/lsp_utils.rs
@@ -2,12 +2,13 @@
 use std::{mem, ops::Range, sync::Arc};
 
 use lsp_server::Notification;
+use lsp_types::request::Request;
 
 use crate::{
     from_proto,
     global_state::GlobalState,
     line_index::{LineEndings, LineIndex, PositionEncoding},
-    LspError,
+    lsp_ext, LspError,
 };
 
 pub(crate) fn invalid_params_error(message: String) -> LspError {
@@ -46,20 +47,47 @@ impl GlobalState {
     /// If `additional_info` is [`Some`], appends a note to the notification telling to check the logs.
     /// This will always log `message` + `additional_info` to the server's error log.
     pub(crate) fn show_and_log_error(&mut self, message: String, additional_info: Option<String>) {
-        let mut message = message;
         match additional_info {
             Some(additional_info) => {
-                tracing::error!("{}\n\n{}", &message, &additional_info);
-                if tracing::enabled!(tracing::Level::ERROR) {
-                    message.push_str("\n\nCheck the server logs for additional info.");
+                tracing::error!("{}:\n{}", &message, &additional_info);
+                match self.config.open_server_logs() && tracing::enabled!(tracing::Level::ERROR) {
+                    true => self.send_request::<lsp_types::request::ShowMessageRequest>(
+                        lsp_types::ShowMessageRequestParams {
+                            typ: lsp_types::MessageType::ERROR,
+                            message,
+                            actions: Some(vec![lsp_types::MessageActionItem {
+                                title: "Open server logs".to_owned(),
+                                properties: Default::default(),
+                            }]),
+                        },
+                        |this, resp| {
+                            let lsp_server::Response { error: None, result: Some(result), .. } = resp
+                            else { return };
+                            if let Ok(Some(_item)) = crate::from_json::<
+                                <lsp_types::request::ShowMessageRequest as lsp_types::request::Request>::Result,
+                            >(
+                                lsp_types::request::ShowMessageRequest::METHOD, &result
+                            ) {
+                                this.send_notification::<lsp_ext::OpenServerLogs>(());
+                            }
+                        },
+                    ),
+                    false => self.send_notification::<lsp_types::notification::ShowMessage>(
+                        lsp_types::ShowMessageParams {
+                            typ: lsp_types::MessageType::ERROR,
+                            message,
+                        },
+                    ),
                 }
             }
-            None => tracing::error!("{}", &message),
-        }
+            None => {
+                tracing::error!("{}", &message);
 
-        self.send_notification::<lsp_types::notification::ShowMessage>(
-            lsp_types::ShowMessageParams { typ: lsp_types::MessageType::ERROR, message },
-        )
+                self.send_notification::<lsp_types::notification::ShowMessage>(
+                    lsp_types::ShowMessageParams { typ: lsp_types::MessageType::ERROR, message },
+                );
+            }
+        }
     }
 
     /// rust-analyzer is resilient -- if it fails, this doesn't usually affect
@@ -77,7 +105,7 @@ impl GlobalState {
         let from_source_build = option_env!("POKE_RA_DEVS").is_some();
         let profiling_enabled = std::env::var("RA_PROFILE").is_ok();
         if from_source_build || profiling_enabled {
-            self.show_message(lsp_types::MessageType::ERROR, message)
+            self.show_and_log_error(message, None);
         }
     }
 
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 0f24ddbbc00..a794e866181 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: d296ce1226e3568d
+lsp_ext.rs hash: ec29403e67dfd15b
 
 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/editors/code/src/client.ts b/editors/code/src/client.ts
index 1fbe9d4ea03..9335e9abb30 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -316,6 +316,7 @@ class ExperimentalFeatures implements lc.StaticFeature {
         caps.hoverActions = true;
         caps.serverStatusNotification = true;
         caps.colorDiagnosticOutput = true;
+        caps.openServerLogs = true;
         caps.commands = {
             commands: [
                 "rust-analyzer.runSingle",
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index d6cee5c8fc6..1860924c6de 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -187,6 +187,11 @@ export class Ctx {
                     this.setServerStatus(params)
                 )
             );
+            this.pushClientCleanup(
+                this._client.onNotification(ra.openServerLogs, () => {
+                    this.outputChannel!.show();
+                })
+            );
         }
         return this._client;
     }
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 29349cc20f5..6ddf83799c0 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -21,6 +21,7 @@ export interface ServerStatusParams {
 export const serverStatus = new lc.NotificationType<ServerStatusParams>(
     "experimental/serverStatus"
 );
+export const openServerLogs = new lc.NotificationType0("rust-analyzer/openServerLogs");
 
 export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");
 
-- 
cgit 1.4.1-3-g733a5


From 64110714f0b51c31c0c1a48717b725328f6730ba Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 23 Jan 2023 15:26:28 +0100
Subject: 🧹 lsp_ext.ts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 editors/code/src/client.ts   |  43 ++++----
 editors/code/src/commands.ts |   4 +-
 editors/code/src/lsp_ext.ts  | 241 +++++++++++++++++++------------------------
 3 files changed, 130 insertions(+), 158 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 9335e9abb30..62980ca0464 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -172,12 +172,10 @@ export async function createClient(
                     )
                     .then(
                         (result) => {
+                            if (!result) return null;
                             const hover = client.protocol2CodeConverter.asHover(result);
-                            if (hover) {
-                                const actions = (<any>result).actions;
-                                if (actions) {
-                                    hover.contents.push(renderHoverActions(actions));
-                                }
+                            if (!!result.actions) {
+                                hover.contents.push(renderHoverActions(result.actions));
                             }
                             return hover;
                         },
@@ -310,26 +308,27 @@ class ExperimentalFeatures implements lc.StaticFeature {
         return { kind: "static" };
     }
     fillClientCapabilities(capabilities: lc.ClientCapabilities): void {
-        const caps: any = capabilities.experimental ?? {};
-        caps.snippetTextEdit = true;
-        caps.codeActionGroup = true;
-        caps.hoverActions = true;
-        caps.serverStatusNotification = true;
-        caps.colorDiagnosticOutput = true;
-        caps.openServerLogs = true;
-        caps.commands = {
-            commands: [
-                "rust-analyzer.runSingle",
-                "rust-analyzer.debugSingle",
-                "rust-analyzer.showReferences",
-                "rust-analyzer.gotoLocation",
-                "editor.action.triggerParameterHints",
-            ],
+        capabilities.experimental = {
+            snippetTextEdit: true,
+            codeActionGroup: true,
+            hoverActions: true,
+            serverStatusNotification: true,
+            colorDiagnosticOutput: true,
+            openServerLogs: true,
+            commands: {
+                commands: [
+                    "rust-analyzer.runSingle",
+                    "rust-analyzer.debugSingle",
+                    "rust-analyzer.showReferences",
+                    "rust-analyzer.gotoLocation",
+                    "editor.action.triggerParameterHints",
+                ],
+            },
+            ...capabilities.experimental,
         };
-        capabilities.experimental = caps;
     }
     initialize(
-        _capabilities: lc.ServerCapabilities<any>,
+        _capabilities: lc.ServerCapabilities,
         _documentSelector: lc.DocumentSelector | undefined
     ): void {}
     dispose(): void {}
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index cb4e13e2c60..b5b64e33e07 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -130,11 +130,11 @@ export function joinLines(ctx: CtxInit): Cmd {
 }
 
 export function moveItemUp(ctx: CtxInit): Cmd {
-    return moveItem(ctx, ra.Direction.Up);
+    return moveItem(ctx, "Up");
 }
 
 export function moveItemDown(ctx: CtxInit): Cmd {
-    return moveItem(ctx, ra.Direction.Down);
+    return moveItem(ctx, "Down");
 }
 
 export function moveItem(ctx: CtxInit, direction: ra.Direction): Cmd {
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 6ddf83799c0..f6f5124dc41 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -4,131 +4,134 @@
 
 import * as lc from "vscode-languageclient";
 
-export interface AnalyzerStatusParams {
-    textDocument?: lc.TextDocumentIdentifier;
-}
+// rust-analyzer overrides
+
+export const hover = new lc.RequestType<
+    HoverParams,
+    (lc.Hover & { actions: CommandLinkGroup[] }) | null,
+    void
+>("textDocument/hover");
+export type HoverParams = { position: lc.Position | lc.Range } & Omit<
+    lc.TextDocumentPositionParams,
+    "position"
+> &
+    lc.WorkDoneProgressParams;
+export type CommandLink = {
+    /**
+     * A tooltip for the command, when represented in the UI.
+     */
+    tooltip?: string;
+} & lc.Command;
+export type CommandLinkGroup = {
+    title?: string;
+    commands: CommandLink[];
+};
+
+// rust-analyzer extensions
+
 export const analyzerStatus = new lc.RequestType<AnalyzerStatusParams, string, void>(
     "rust-analyzer/analyzerStatus"
 );
-export const memoryUsage = new lc.RequestType0<string, void>("rust-analyzer/memoryUsage");
-export const shuffleCrateGraph = new lc.RequestType0<null, void>("rust-analyzer/shuffleCrateGraph");
-
-export interface ServerStatusParams {
-    health: "ok" | "warning" | "error";
-    quiescent: boolean;
-    message?: string;
-}
-export const serverStatus = new lc.NotificationType<ServerStatusParams>(
-    "experimental/serverStatus"
+export const cancelFlycheck = new lc.NotificationType0("rust-analyzer/cancelFlycheck");
+export const clearFlycheck = new lc.NotificationType0("rust-analyzer/clearFlycheck");
+export const expandMacro = new lc.RequestType<ExpandMacroParams, ExpandedMacro | null, void>(
+    "rust-analyzer/expandMacro"
 );
+export const memoryUsage = new lc.RequestType0<string, void>("rust-analyzer/memoryUsage");
 export const openServerLogs = new lc.NotificationType0("rust-analyzer/openServerLogs");
-
+export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, TestInfo[], void>(
+    "rust-analyzer/relatedTests"
+);
 export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");
-
-export const hover = new lc.RequestType<HoverParams, lc.Hover | null, void>("textDocument/hover");
-
-export interface HoverParams extends lc.WorkDoneProgressParams {
-    textDocument: lc.TextDocumentIdentifier;
-    position: lc.Range | lc.Position;
-}
-
-export interface SyntaxTreeParams {
-    textDocument: lc.TextDocumentIdentifier;
-    range: lc.Range | null;
-}
+export const runFlycheck = new lc.NotificationType<{
+    textDocument: lc.TextDocumentIdentifier | null;
+}>("rust-analyzer/runFlycheck");
+export const shuffleCrateGraph = new lc.RequestType0<null, void>("rust-analyzer/shuffleCrateGraph");
 export const syntaxTree = new lc.RequestType<SyntaxTreeParams, string, void>(
     "rust-analyzer/syntaxTree"
 );
-
-export const viewHir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(
-    "rust-analyzer/viewHir"
+export const viewCrateGraph = new lc.RequestType<ViewCrateGraphParams, string, void>(
+    "rust-analyzer/viewCrateGraph"
 );
-
 export const viewFileText = new lc.RequestType<lc.TextDocumentIdentifier, string, void>(
     "rust-analyzer/viewFileText"
 );
-
-export interface ViewItemTreeParams {
-    textDocument: lc.TextDocumentIdentifier;
-}
-
+export const viewHir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(
+    "rust-analyzer/viewHir"
+);
 export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>(
     "rust-analyzer/viewItemTree"
 );
 
-export interface ViewCrateGraphParams {
-    full: boolean;
-}
-
-export const viewCrateGraph = new lc.RequestType<ViewCrateGraphParams, string, void>(
-    "rust-analyzer/viewCrateGraph"
-);
+export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };
 
-export interface ExpandMacroParams {
+export type ExpandMacroParams = {
     textDocument: lc.TextDocumentIdentifier;
     position: lc.Position;
-}
-export interface ExpandedMacro {
+};
+export type ExpandedMacro = {
     name: string;
     expansion: string;
-}
-export const expandMacro = new lc.RequestType<ExpandMacroParams, ExpandedMacro | null, void>(
-    "rust-analyzer/expandMacro"
-);
-
-export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, TestInfo[], void>(
-    "rust-analyzer/relatedTests"
-);
-
-export const cancelFlycheck = new lc.NotificationType0("rust-analyzer/cancelFlycheck");
-export const clearFlycheck = new lc.NotificationType0("rust-analyzer/clearFlycheck");
-export const runFlycheck = new lc.NotificationType<{
-    textDocument: lc.TextDocumentIdentifier | null;
-}>("rust-analyzer/runFlycheck");
-
-// Experimental extensions
-
-export interface SsrParams {
-    query: string;
-    parseOnly: boolean;
+};
+export type TestInfo = { runnable: Runnable };
+export type SyntaxTreeParams = {
     textDocument: lc.TextDocumentIdentifier;
-    position: lc.Position;
-    selections: readonly lc.Range[];
-}
-export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>("experimental/ssr");
+    range: lc.Range | null;
+};
+export type ViewCrateGraphParams = { full: boolean };
+export type ViewItemTreeParams = { textDocument: lc.TextDocumentIdentifier };
 
-export interface MatchingBraceParams {
-    textDocument: lc.TextDocumentIdentifier;
-    positions: lc.Position[];
-}
+// experimental extensions
+
+export const joinLines = new lc.RequestType<JoinLinesParams, lc.TextEdit[], void>(
+    "experimental/joinLines"
+);
 export const matchingBrace = new lc.RequestType<MatchingBraceParams, lc.Position[], void>(
     "experimental/matchingBrace"
 );
-
+export const moveItem = new lc.RequestType<MoveItemParams, lc.TextEdit[], void>(
+    "experimental/moveItem"
+);
+export const onEnter = new lc.RequestType<lc.TextDocumentPositionParams, lc.TextEdit[], void>(
+    "experimental/onEnter"
+);
+export const openCargoToml = new lc.RequestType<OpenCargoTomlParams, lc.Location, void>(
+    "experimental/openCargoToml"
+);
+export const openDocs = new lc.RequestType<lc.TextDocumentPositionParams, string | void, void>(
+    "experimental/externalDocs"
+);
 export const parentModule = new lc.RequestType<
     lc.TextDocumentPositionParams,
     lc.LocationLink[] | null,
     void
 >("experimental/parentModule");
-
-export interface JoinLinesParams {
-    textDocument: lc.TextDocumentIdentifier;
-    ranges: lc.Range[];
-}
-export const joinLines = new lc.RequestType<JoinLinesParams, lc.TextEdit[], void>(
-    "experimental/joinLines"
+export const runnables = new lc.RequestType<RunnablesParams, Runnable[], void>(
+    "experimental/runnables"
 );
-
-export const onEnter = new lc.RequestType<lc.TextDocumentPositionParams, lc.TextEdit[], void>(
-    "experimental/onEnter"
+export const serverStatus = new lc.NotificationType<ServerStatusParams>(
+    "experimental/serverStatus"
 );
+export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>("experimental/ssr");
 
-export interface RunnablesParams {
+export type JoinLinesParams = {
     textDocument: lc.TextDocumentIdentifier;
-    position: lc.Position | null;
-}
-
-export interface Runnable {
+    ranges: lc.Range[];
+};
+export type MatchingBraceParams = {
+    textDocument: lc.TextDocumentIdentifier;
+    positions: lc.Position[];
+};
+export type MoveItemParams = {
+    textDocument: lc.TextDocumentIdentifier;
+    range: lc.Range;
+    direction: Direction;
+};
+export type Direction = "Up" | "Down";
+export type OpenCargoTomlParams = {
+    textDocument: lc.TextDocumentIdentifier;
+};
+export type Runnable = {
     label: string;
     location?: lc.LocationLink;
     kind: "cargo";
@@ -140,50 +143,20 @@ export interface Runnable {
         expectTest?: boolean;
         overrideCargo?: string;
     };
-}
-export const runnables = new lc.RequestType<RunnablesParams, Runnable[], void>(
-    "experimental/runnables"
-);
-
-export interface TestInfo {
-    runnable: Runnable;
-}
-
-export interface CommandLink extends lc.Command {
-    /**
-     * A tooltip for the command, when represented in the UI.
-     */
-    tooltip?: string;
-}
-
-export interface CommandLinkGroup {
-    title?: string;
-    commands: CommandLink[];
-}
-
-export const openDocs = new lc.RequestType<lc.TextDocumentPositionParams, string | void, void>(
-    "experimental/externalDocs"
-);
-
-export const openCargoToml = new lc.RequestType<OpenCargoTomlParams, lc.Location, void>(
-    "experimental/openCargoToml"
-);
-
-export interface OpenCargoTomlParams {
+};
+export type RunnablesParams = {
     textDocument: lc.TextDocumentIdentifier;
-}
-
-export const moveItem = new lc.RequestType<MoveItemParams, lc.TextEdit[], void>(
-    "experimental/moveItem"
-);
-
-export interface MoveItemParams {
+    position: lc.Position | null;
+};
+export type ServerStatusParams = {
+    health: "ok" | "warning" | "error";
+    quiescent: boolean;
+    message?: string;
+};
+export type SsrParams = {
+    query: string;
+    parseOnly: boolean;
     textDocument: lc.TextDocumentIdentifier;
-    range: lc.Range;
-    direction: Direction;
-}
-
-export const enum Direction {
-    Up = "Up",
-    Down = "Down",
-}
+    position: lc.Position;
+    selections: readonly lc.Range[];
+};
-- 
cgit 1.4.1-3-g733a5


From ec9476015ce966fc4238408baef7a7ad1b3db5d8 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 24 Jan 2023 13:43:56 +0100
Subject: Substitute VSCode variables more generally

---
 editors/code/src/bootstrap.ts | 98 +++++++++++++++++++++----------------------
 editors/code/src/config.ts    | 64 +++++++++++++++-------------
 editors/code/src/ctx.ts       |  6 +--
 editors/code/src/debug.ts     |  2 +-
 editors/code/src/util.ts      |  2 +-
 5 files changed, 87 insertions(+), 85 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/bootstrap.ts b/editors/code/src/bootstrap.ts
index cabc7407172..b38fa06a85c 100644
--- a/editors/code/src/bootstrap.ts
+++ b/editors/code/src/bootstrap.ts
@@ -1,6 +1,6 @@
 import * as vscode from "vscode";
 import * as os from "os";
-import { Config, substituteVSCodeVariables } from "./config";
+import { Config } from "./config";
 import { log, isValidExecutable } from "./util";
 import { PersistentState } from "./persistent_state";
 import { exec } from "child_process";
@@ -31,58 +31,12 @@ export async function bootstrap(
 
     return path;
 }
-
-async function patchelf(dest: vscode.Uri): Promise<void> {
-    await vscode.window.withProgress(
-        {
-            location: vscode.ProgressLocation.Notification,
-            title: "Patching rust-analyzer for NixOS",
-        },
-        async (progress, _) => {
-            const expression = `
-            {srcStr, pkgs ? import <nixpkgs> {}}:
-                pkgs.stdenv.mkDerivation {
-                    name = "rust-analyzer";
-                    src = /. + srcStr;
-                    phases = [ "installPhase" "fixupPhase" ];
-                    installPhase = "cp $src $out";
-                    fixupPhase = ''
-                    chmod 755 $out
-                    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out
-                    '';
-                }
-            `;
-            const origFile = vscode.Uri.file(dest.fsPath + "-orig");
-            await vscode.workspace.fs.rename(dest, origFile, { overwrite: true });
-            try {
-                progress.report({ message: "Patching executable", increment: 20 });
-                await new Promise((resolve, reject) => {
-                    const handle = exec(
-                        `nix-build -E - --argstr srcStr '${origFile.fsPath}' -o '${dest.fsPath}'`,
-                        (err, stdout, stderr) => {
-                            if (err != null) {
-                                reject(Error(stderr));
-                            } else {
-                                resolve(stdout);
-                            }
-                        }
-                    );
-                    handle.stdin?.write(expression);
-                    handle.stdin?.end();
-                });
-            } finally {
-                await vscode.workspace.fs.delete(origFile);
-            }
-        }
-    );
-}
-
 async function getServer(
     context: vscode.ExtensionContext,
     config: Config,
     state: PersistentState
 ): Promise<string | undefined> {
-    const explicitPath = serverPath(config);
+    const explicitPath = process.env.__RA_LSP_SERVER_DEBUG ?? config.serverPath;
     if (explicitPath) {
         if (explicitPath.startsWith("~/")) {
             return os.homedir() + explicitPath.slice("~".length);
@@ -131,9 +85,6 @@ async function getServer(
     );
     return undefined;
 }
-function serverPath(config: Config): string | null {
-    return process.env.__RA_LSP_SERVER_DEBUG ?? substituteVSCodeVariables(config.serverPath);
-}
 
 async function isNixOs(): Promise<boolean> {
     try {
@@ -146,3 +97,48 @@ async function isNixOs(): Promise<boolean> {
         return false;
     }
 }
+
+async function patchelf(dest: vscode.Uri): Promise<void> {
+    await vscode.window.withProgress(
+        {
+            location: vscode.ProgressLocation.Notification,
+            title: "Patching rust-analyzer for NixOS",
+        },
+        async (progress, _) => {
+            const expression = `
+            {srcStr, pkgs ? import <nixpkgs> {}}:
+                pkgs.stdenv.mkDerivation {
+                    name = "rust-analyzer";
+                    src = /. + srcStr;
+                    phases = [ "installPhase" "fixupPhase" ];
+                    installPhase = "cp $src $out";
+                    fixupPhase = ''
+                    chmod 755 $out
+                    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out
+                    '';
+                }
+            `;
+            const origFile = vscode.Uri.file(dest.fsPath + "-orig");
+            await vscode.workspace.fs.rename(dest, origFile, { overwrite: true });
+            try {
+                progress.report({ message: "Patching executable", increment: 20 });
+                await new Promise((resolve, reject) => {
+                    const handle = exec(
+                        `nix-build -E - --argstr srcStr '${origFile.fsPath}' -o '${dest.fsPath}'`,
+                        (err, stdout, stderr) => {
+                            if (err != null) {
+                                reject(Error(stderr));
+                            } else {
+                                resolve(stdout);
+                            }
+                        }
+                    );
+                    handle.stdin?.write(expression);
+                    handle.stdin?.end();
+                });
+            } finally {
+                await vscode.workspace.fs.delete(origFile);
+            }
+        }
+    );
+}
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index eb4f965291f..ce1142df3a8 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -1,5 +1,6 @@
-import * as path from "path";
+import * as Is from "vscode-languageclient/lib/common/utils/is";
 import * as os from "os";
+import * as path from "path";
 import * as vscode from "vscode";
 import { Env } from "./client";
 import { log } from "./util";
@@ -47,7 +48,7 @@ export class Config {
     }
 
     private refreshLogging() {
-        log.setEnabled(this.traceExtension);
+        log.setEnabled(this.traceExtension ?? false);
         log.info("Extension version:", this.package.version);
 
         const cfg = Object.entries(this.cfg).filter(([_, val]) => !(val instanceof Function));
@@ -163,18 +164,24 @@ export class Config {
      * ```
      * So this getter handles this quirk by not requiring the caller to use postfix `!`
      */
-    private get<T>(path: string): T {
-        return this.cfg.get<T>(path)!;
+    private get<T>(path: string): T | undefined {
+        return substituteVSCodeVariables(this.cfg.get<T>(path));
     }
 
     get serverPath() {
         return this.get<null | string>("server.path") ?? this.get<null | string>("serverPath");
     }
+
     get serverExtraEnv(): Env {
         const extraEnv =
             this.get<{ [key: string]: string | number } | null>("server.extraEnv") ?? {};
-        return Object.fromEntries(
-            Object.entries(extraEnv).map(([k, v]) => [k, typeof v !== "string" ? v.toString() : v])
+        return substituteVariablesInEnv(
+            Object.fromEntries(
+                Object.entries(extraEnv).map(([k, v]) => [
+                    k,
+                    typeof v !== "string" ? v.toString() : v,
+                ])
+            )
         );
     }
     get traceExtension() {
@@ -216,13 +223,13 @@ export class Config {
         if (sourceFileMap !== "auto") {
             // "/rustc/<id>" used by suggestions only.
             const { ["/rustc/<id>"]: _, ...trimmed } =
-                this.get<Record<string, string>>("debug.sourceFileMap");
+                this.get<Record<string, string>>("debug.sourceFileMap") ?? {};
             sourceFileMap = trimmed;
         }
 
         return {
             engine: this.get<string>("debug.engine"),
-            engineSettings: this.get<object>("debug.engineSettings"),
+            engineSettings: this.get<object>("debug.engineSettings") ?? {},
             openDebugPane: this.get<boolean>("debug.openDebugPane"),
             sourceFileMap: sourceFileMap,
         };
@@ -247,37 +254,27 @@ export class Config {
     }
 }
 
-const VarRegex = new RegExp(/\$\{(.+?)\}/g);
-
-export function substituteVSCodeVariableInString(val: string): string {
-    return val.replace(VarRegex, (substring: string, varName) => {
-        if (typeof varName === "string") {
-            return computeVscodeVar(varName) || substring;
-        } else {
-            return substring;
-        }
-    });
-}
-
-export function substituteVSCodeVariables(resp: any): any {
-    if (typeof resp === "string") {
-        return substituteVSCodeVariableInString(resp);
-    } else if (resp && Array.isArray(resp)) {
+export function substituteVSCodeVariables<T>(resp: T): T {
+    if (Is.string(resp)) {
+        return substituteVSCodeVariableInString(resp) as T;
+    } else if (resp && Is.array<any>(resp)) {
         return resp.map((val) => {
             return substituteVSCodeVariables(val);
-        });
+        }) as T;
     } else if (resp && typeof resp === "object") {
         const res: { [key: string]: any } = {};
         for (const key in resp) {
             const val = resp[key];
             res[key] = substituteVSCodeVariables(val);
         }
-        return res;
-    } else if (typeof resp === "function") {
-        return null;
+        return res as T;
+    } else if (Is.func(resp)) {
+        throw new Error("Unexpected function type in substitution");
     }
     return resp;
 }
+
+// FIXME: Merge this with `substituteVSCodeVariables` above
 export function substituteVariablesInEnv(env: Env): Env {
     const missingDeps = new Set<string>();
     // vscode uses `env:ENV_NAME` for env vars resolution, and it's easier
@@ -355,6 +352,17 @@ export function substituteVariablesInEnv(env: Env): Env {
     return resolvedEnv;
 }
 
+const VarRegex = new RegExp(/\$\{(.+?)\}/g);
+function substituteVSCodeVariableInString(val: string): string {
+    return val.replace(VarRegex, (substring: string, varName) => {
+        if (Is.string(varName)) {
+            return computeVscodeVar(varName) || substring;
+        } else {
+            return substring;
+        }
+    });
+}
+
 function computeVscodeVar(varName: string): string | null {
     const workspaceFolder = () => {
         const folders = vscode.workspace.workspaceFolders ?? [];
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 1860924c6de..8b04182155d 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -2,7 +2,7 @@ import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 
-import { Config, substituteVariablesInEnv, substituteVSCodeVariables } from "./config";
+import { Config, substituteVSCodeVariables } from "./config";
 import { createClient } from "./client";
 import { isRustDocument, isRustEditor, log, RustEditor } from "./util";
 import { ServerStatusParams } from "./lsp_ext";
@@ -152,9 +152,7 @@ export class Ctx {
                     throw new Error(message);
                 }
             );
-            const newEnv = substituteVariablesInEnv(
-                Object.assign({}, process.env, this.config.serverExtraEnv)
-            );
+            const newEnv = Object.assign({}, process.env, this.config.serverExtraEnv);
             const run: lc.Executable = {
                 command: this._serverPath,
                 options: { env: newEnv },
diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
index bd45599227e..268b70b4fbb 100644
--- a/editors/code/src/debug.ts
+++ b/editors/code/src/debug.ts
@@ -84,7 +84,7 @@ async function getDebugConfiguration(
             debugEngine = vscode.extensions.getExtension(engineId);
             if (debugEngine) break;
         }
-    } else {
+    } else if (debugOptions.engine) {
         debugEngine = vscode.extensions.getExtension(debugOptions.engine);
     }
 
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index cd91932bb60..a92c90f7ff4 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -117,7 +117,7 @@ export function isValidExecutable(path: string): boolean {
 
     const res = spawnSync(path, ["--version"], { encoding: "utf8" });
 
-    const printOutput = res.error && (res.error as any).code !== "ENOENT" ? log.warn : log.debug;
+    const printOutput = res.error ? log.warn : log.info;
     printOutput(path, "--version:", res);
 
     return res.status === 0;
-- 
cgit 1.4.1-3-g733a5


From e6ad8a2edcbe5e9614f71308d43f6fb0cbf7ceef Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Wed, 25 Jan 2023 09:17:49 +0100
Subject: fix: config substitution failing extension activation

---
 editors/code/src/config.ts | 2 --
 1 file changed, 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index ce1142df3a8..114abf062b9 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -268,8 +268,6 @@ export function substituteVSCodeVariables<T>(resp: T): T {
             res[key] = substituteVSCodeVariables(val);
         }
         return res as T;
-    } else if (Is.func(resp)) {
-        throw new Error("Unexpected function type in substitution");
     }
     return resp;
 }
-- 
cgit 1.4.1-3-g733a5


From 56f81ebc3e52ac7e6dd8a3359e290d8765975edc Mon Sep 17 00:00:00 2001
From: Jonas Schievink <jonas.schievink@ferrous-systems.com>
Date: Tue, 31 Jan 2023 15:43:47 +0100
Subject: Lazily create the trace output channel

---
 editors/code/src/ctx.ts  |  6 ++----
 editors/code/src/util.ts | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 48 insertions(+), 4 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 8b04182155d..e2a30e0cc45 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -4,7 +4,7 @@ import * as ra from "./lsp_ext";
 
 import { Config, substituteVSCodeVariables } from "./config";
 import { createClient } from "./client";
-import { isRustDocument, isRustEditor, log, RustEditor } from "./util";
+import { isRustDocument, isRustEditor, LazyOutputChannel, log, RustEditor } from "./util";
 import { ServerStatusParams } from "./lsp_ext";
 import { PersistentState } from "./persistent_state";
 import { bootstrap } from "./bootstrap";
@@ -128,9 +128,7 @@ export class Ctx {
         }
 
         if (!this.traceOutputChannel) {
-            this.traceOutputChannel = vscode.window.createOutputChannel(
-                "Rust Analyzer Language Server Trace"
-            );
+            this.traceOutputChannel = new LazyOutputChannel("Rust Analyzer Language Server Trace");
             this.pushExtCleanup(this.traceOutputChannel);
         }
         if (!this.outputChannel) {
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index a92c90f7ff4..33d42986ad9 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -166,3 +166,49 @@ export function execute(command: string, options: ExecOptions): Promise<string>
         });
     });
 }
+
+export class LazyOutputChannel implements vscode.OutputChannel {
+    constructor(name: string) {
+        this.name = name;
+    }
+
+    name: string;
+    _channel: vscode.OutputChannel | undefined;
+
+    get channel(): vscode.OutputChannel {
+        if (!this._channel) {
+            this._channel = vscode.window.createOutputChannel(this.name);
+        }
+        return this._channel;
+    }
+
+    append(value: string): void {
+        this.channel.append(value);
+    }
+    appendLine(value: string): void {
+        this.channel.appendLine(value);
+    }
+    replace(value: string): void {
+        this.channel.replace(value);
+    }
+    clear(): void {
+        if (this._channel) {
+            this._channel.clear();
+        }
+    }
+    show(preserveFocus?: boolean): void;
+    show(column?: vscode.ViewColumn, preserveFocus?: boolean): void;
+    show(column?: vscode.ViewColumn, preserveFocus?: boolean): void {
+        this.channel.show(column, preserveFocus);
+    }
+    hide(): void {
+        if (this._channel) {
+            this._channel.hide();
+        }
+    }
+    dispose(): void {
+        if (this._channel) {
+            this._channel.dispose();
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 5b1187a04654d3d95926265e3d9762f695b31c1d Mon Sep 17 00:00:00 2001
From: Jonas Schievink <jonas.schievink@ferrous-systems.com>
Date: Tue, 31 Jan 2023 15:49:39 +0100
Subject: Remove some types ¯\_(ツ)_/¯
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 editors/code/src/util.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 33d42986ad9..d93b9caeb16 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -198,7 +198,7 @@ export class LazyOutputChannel implements vscode.OutputChannel {
     }
     show(preserveFocus?: boolean): void;
     show(column?: vscode.ViewColumn, preserveFocus?: boolean): void;
-    show(column?: vscode.ViewColumn, preserveFocus?: boolean): void {
+    show(column?: any, preserveFocus?: any): void {
         this.channel.show(column, preserveFocus);
     }
     hide(): void {
-- 
cgit 1.4.1-3-g733a5


From c7bd3c682f9141f88b23d2e79c31a0be055c1c83 Mon Sep 17 00:00:00 2001
From: DropDemBits <r3usrlnd@gmail.com>
Date: Fri, 10 Feb 2023 14:55:17 -0500
Subject: Always reload onEnter configuration

Configuration reload doesn't happen often anyway,
and there will always be a set of onEnter rules to load
---
 editors/code/src/config.ts | 23 +++++++----------------
 1 file changed, 7 insertions(+), 16 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 30ff9784829..561b69f0100 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -11,9 +11,7 @@ export type RunnableEnvCfg =
 
 export class Config {
     readonly extensionId = "rust-lang.rust-analyzer";
-    configureLang:
-        | { handle: vscode.Disposable; typingContinueCommentsOnNewline: boolean }
-        | undefined;
+    configureLang: vscode.Disposable | undefined;
 
     readonly rootSection = "rust-analyzer";
     private readonly requiresReloadOpts = [
@@ -45,7 +43,7 @@ export class Config {
     }
 
     dispose() {
-        this.configureLang?.handle.dispose();
+        this.configureLang?.dispose();
     }
 
     private refreshLogging() {
@@ -89,12 +87,8 @@ export class Config {
      */
     private configureLanguage() {
         // Only need to dispose of the config if there's a change
-        if (
-            this.configureLang &&
-            this.typingContinueCommentsOnNewline !==
-                this.configureLang.typingContinueCommentsOnNewline
-        ) {
-            this.configureLang.handle.dispose();
+        if (this.configureLang) {
+            this.configureLang.dispose();
             this.configureLang = undefined;
         }
 
@@ -167,12 +161,9 @@ export class Config {
             ];
         }
 
-        this.configureLang = {
-            handle: vscode.languages.setLanguageConfiguration("rust", {
-                onEnterRules,
-            }),
-            typingContinueCommentsOnNewline: this.typingContinueCommentsOnNewline,
-        };
+        this.configureLang = vscode.languages.setLanguageConfiguration("rust", {
+            onEnterRules,
+        });
     }
 
     // We don't do runtime config validation here for simplicity. More on stackoverflow:
-- 
cgit 1.4.1-3-g733a5


From 95fa278f30673db0e464825a8a3c77865fe33f78 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 14 Feb 2023 14:45:48 +0100
Subject: Don't assume VSCode internal commands in the server

---
 crates/rust-analyzer/src/to_proto.rs | 2 +-
 editors/code/src/commands.ts         | 6 ++++++
 editors/code/src/main.ts             | 1 +
 3 files changed, 8 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 78cd4b8e2b1..7f4b7e2a32b 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -1360,7 +1360,7 @@ pub(crate) mod command {
     pub(crate) fn trigger_parameter_hints() -> lsp_types::Command {
         lsp_types::Command {
             title: "triggerParameterHints".into(),
-            command: "editor.action.triggerParameterHints".into(),
+            command: "rust-analyzer.triggerParameterHints".into(),
             arguments: None,
         }
     }
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index b5b64e33e07..49a8ca4edba 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -87,6 +87,12 @@ export function shuffleCrateGraph(ctx: CtxInit): Cmd {
     };
 }
 
+export function triggerParameterHints(_: CtxInit): Cmd {
+    return async () => {
+        await vscode.commands.executeCommand("editor.action.triggerParameterHints");
+    };
+}
+
 export function matchingBrace(ctx: CtxInit): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index dd439317c70..5987368e6e0 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -186,5 +186,6 @@ function createCommands(): Record<string, CommandFactory> {
         resolveCodeAction: { enabled: commands.resolveCodeAction },
         runSingle: { enabled: commands.runSingle },
         showReferences: { enabled: commands.showReferences },
+        triggerParameterHints: { enabled: commands.triggerParameterHints },
     };
 }
-- 
cgit 1.4.1-3-g733a5


From e4b184a776ef20e33ff2922f583349928061a18b Mon Sep 17 00:00:00 2001
From: Tomoki Nakagawa <tomokinat@google.com>
Date: Fri, 24 Feb 2023 15:26:25 +0900
Subject: Respect $CARGO_HOME when looking up toolchains.

---
 crates/toolchain/src/lib.rs   | 21 +++++++++++++++++----
 editors/code/src/toolchain.ts | 30 ++++++++++++++++++------------
 2 files changed, 35 insertions(+), 16 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/toolchain/src/lib.rs b/crates/toolchain/src/lib.rs
index 67bdad2aadd..729f84a8150 100644
--- a/crates/toolchain/src/lib.rs
+++ b/crates/toolchain/src/lib.rs
@@ -31,8 +31,9 @@ fn get_path_for_executable(executable_name: &'static str) -> PathBuf {
     //      example: for cargo, this checks $CARGO environment variable; for rustc, $RUSTC; etc
     // 2) `<executable_name>`
     //      example: for cargo, this tries just `cargo`, which will succeed if `cargo` is on the $PATH
-    // 3) `~/.cargo/bin/<executable_name>`
-    //      example: for cargo, this tries ~/.cargo/bin/cargo
+    // 3) `$CARGO_HOME/bin/<executable_name>`
+    //      where $CARGO_HOME defaults to ~/.cargo (see https://doc.rust-lang.org/cargo/guide/cargo-home.html)
+    //      example: for cargo, this tries $CARGO_HOME/bin/cargo, or ~/.cargo/bin/cargo if $CARGO_HOME is unset.
     //      It seems that this is a reasonable place to try for cargo, rustc, and rustup
     let env_var = executable_name.to_ascii_uppercase();
     if let Some(path) = env::var_os(env_var) {
@@ -43,8 +44,7 @@ fn get_path_for_executable(executable_name: &'static str) -> PathBuf {
         return executable_name.into();
     }
 
-    if let Some(mut path) = home::home_dir() {
-        path.push(".cargo");
+    if let Some(mut path) = get_cargo_home() {
         path.push("bin");
         path.push(executable_name);
         if let Some(path) = probe(path) {
@@ -60,6 +60,19 @@ fn lookup_in_path(exec: &str) -> bool {
     env::split_paths(&paths).map(|path| path.join(exec)).find_map(probe).is_some()
 }
 
+fn get_cargo_home() -> Option<PathBuf> {
+    if let Some(path) = env::var_os("CARGO_HOME") {
+        return Some(path.into());
+    }
+
+    if let Some(mut path) = home::home_dir() {
+        path.push(".cargo");
+        return Some(path);
+    }
+
+    None
+}
+
 fn probe(path: PathBuf) -> Option<PathBuf> {
     let with_extension = match env::consts::EXE_EXTENSION {
         "" => None,
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index e1ca4954280..eb70b88871e 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -156,19 +156,10 @@ export const getPathForExecutable = memoizeAsync(
 
         if (await lookupInPath(executableName)) return executableName;
 
-        try {
-            // hmm, `os.homedir()` seems to be infallible
-            // it is not mentioned in docs and cannot be inferred by the type signature...
-            const standardPath = vscode.Uri.joinPath(
-                vscode.Uri.file(os.homedir()),
-                ".cargo",
-                "bin",
-                executableName
-            );
-
+        const cargoHome = getCargoHome();
+        if (cargoHome) {
+            const standardPath = vscode.Uri.joinPath(cargoHome, "bin", executableName);
             if (await isFileAtUri(standardPath)) return standardPath.fsPath;
-        } catch (err) {
-            log.error("Failed to read the fs info", err);
         }
         return executableName;
     }
@@ -190,6 +181,21 @@ async function lookupInPath(exec: string): Promise<boolean> {
     return false;
 }
 
+function getCargoHome(): vscode.Uri | null {
+    const envVar = process.env["CARGO_HOME"];
+    if (envVar) return vscode.Uri.file(envVar);
+
+    try {
+        // hmm, `os.homedir()` seems to be infallible
+        // it is not mentioned in docs and cannot be inferred by the type signature...
+        return vscode.Uri.joinPath(vscode.Uri.file(os.homedir()), ".cargo");
+    } catch (err) {
+        log.error("Failed to read the fs info", err);
+    }
+
+    return null;
+}
+
 async function isFileAtPath(path: string): Promise<boolean> {
     return isFileAtUri(vscode.Uri.file(path));
 }
-- 
cgit 1.4.1-3-g733a5


From ac04bfd7a7223cc7077f6745c35f8b655ea13c73 Mon Sep 17 00:00:00 2001
From: hkalbasi <hamidrezakalbasi@protonmail.com>
Date: Sun, 26 Feb 2023 16:04:41 +0330
Subject: Add `View Mir` command and fix some bugs

---
 crates/hir-ty/src/db.rs                            |   5 +-
 crates/hir-ty/src/display.rs                       |   1 +
 crates/hir-ty/src/mir.rs                           |  39 ++-
 crates/hir-ty/src/mir/borrowck.rs                  |  73 +++--
 crates/hir-ty/src/mir/lower.rs                     |  70 +++--
 crates/hir-ty/src/mir/pretty.rs                    | 348 +++++++++++++++++++++
 crates/hir/src/has_source.rs                       |  12 +-
 crates/hir/src/lib.rs                              |  58 ++--
 crates/ide-db/src/rename.rs                        |   3 +-
 .../src/handlers/mutability_errors.rs              | 257 +++++++++++++--
 crates/ide/src/lib.rs                              |   5 +
 crates/ide/src/rename.rs                           |  22 ++
 crates/ide/src/view_mir.rs                         |  29 ++
 crates/rust-analyzer/src/handlers.rs               |  10 +
 crates/rust-analyzer/src/lsp_ext.rs                |   8 +
 crates/rust-analyzer/src/main_loop.rs              |   1 +
 crates/syntax/src/ast/traits.rs                    |   2 +
 docs/dev/lsp-extensions.md                         |  13 +-
 editors/code/package.json                          |   5 +
 editors/code/src/commands.ts                       |  27 +-
 editors/code/src/lsp_ext.ts                        |   3 +
 editors/code/src/main.ts                           |   1 +
 lib/la-arena/src/map.rs                            |   6 +
 23 files changed, 876 insertions(+), 122 deletions(-)
 create mode 100644 crates/hir-ty/src/mir/pretty.rs
 create mode 100644 crates/ide/src/view_mir.rs

(limited to 'editors/code/src')

diff --git a/crates/hir-ty/src/db.rs b/crates/hir-ty/src/db.rs
index 60e51b65f6b..304c78767f1 100644
--- a/crates/hir-ty/src/db.rs
+++ b/crates/hir-ty/src/db.rs
@@ -18,7 +18,7 @@ use crate::{
     chalk_db,
     consteval::ConstEvalError,
     method_resolution::{InherentImpls, TraitImpls, TyFingerprint},
-    mir::{MirBody, MirLowerError},
+    mir::{BorrowckResult, MirBody, MirLowerError},
     Binders, CallableDefId, Const, FnDefId, GenericArg, ImplTraitId, InferenceResult, Interner,
     PolyFnSig, QuantifiedWhereClause, ReturnTypeImplTraits, Substitution, TraitRef, Ty, TyDefId,
     ValueTyDefId,
@@ -38,6 +38,9 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     #[salsa::cycle(crate::mir::mir_body_recover)]
     fn mir_body(&self, def: DefWithBodyId) -> Result<Arc<MirBody>, MirLowerError>;
 
+    #[salsa::invoke(crate::mir::borrowck_query)]
+    fn borrowck(&self, def: DefWithBodyId) -> Result<Arc<BorrowckResult>, MirLowerError>;
+
     #[salsa::invoke(crate::lower::ty_query)]
     #[salsa::cycle(crate::lower::ty_recover)]
     fn ty(&self, def: TyDefId) -> Binders<Ty>;
diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index 6dde4773602..bd3eccfe43d 100644
--- a/crates/hir-ty/src/display.rs
+++ b/crates/hir-ty/src/display.rs
@@ -531,6 +531,7 @@ fn render_const_scalar(
             hir_def::AdtId::UnionId(u) => write!(f, "{}", f.db.union_data(u).name),
             hir_def::AdtId::EnumId(_) => f.write_str("<enum-not-supported>"),
         },
+        chalk_ir::TyKind::FnDef(..) => ty.hir_fmt(f),
         _ => f.write_str("<not-supported>"),
     }
 }
diff --git a/crates/hir-ty/src/mir.rs b/crates/hir-ty/src/mir.rs
index 5d8a81a3ee3..c18a34a1920 100644
--- a/crates/hir-ty/src/mir.rs
+++ b/crates/hir-ty/src/mir.rs
@@ -1,6 +1,6 @@
 //! MIR definitions and implementation
 
-use std::iter;
+use std::{fmt::Display, iter};
 
 use crate::{
     infer::PointerCast, Const, ConstScalar, InferenceResult, Interner, MemoryMap, Substitution, Ty,
@@ -14,8 +14,10 @@ use la_arena::{Arena, ArenaMap, Idx, RawIdx};
 
 mod eval;
 mod lower;
-pub mod borrowck;
+mod borrowck;
+mod pretty;
 
+pub use borrowck::{borrowck_query, BorrowckResult, MutabilityReason};
 pub use eval::{interpret_mir, pad16, Evaluator, MirEvalError};
 pub use lower::{lower_to_mir, mir_body_query, mir_body_recover, MirLowerError};
 use smallvec::{smallvec, SmallVec};
@@ -32,13 +34,7 @@ fn return_slot() -> LocalId {
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct Local {
-    pub mutability: Mutability,
-    //pub local_info: Option<Box<LocalInfo>>,
-    //pub internal: bool,
-    //pub is_block_tail: Option<BlockTailInfo>,
     pub ty: Ty,
-    //pub user_ty: Option<Box<UserTypeProjections>>,
-    //pub source_info: SourceInfo,
 }
 
 /// An operand in MIR represents a "value" in Rust, the definition of which is undecided and part of
@@ -564,6 +560,30 @@ pub enum BinOp {
     Offset,
 }
 
+impl Display for BinOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            BinOp::Add => "+",
+            BinOp::Sub => "-",
+            BinOp::Mul => "*",
+            BinOp::Div => "/",
+            BinOp::Rem => "%",
+            BinOp::BitXor => "^",
+            BinOp::BitAnd => "&",
+            BinOp::BitOr => "|",
+            BinOp::Shl => "<<",
+            BinOp::Shr => ">>",
+            BinOp::Eq => "==",
+            BinOp::Lt => "<",
+            BinOp::Le => "<=",
+            BinOp::Ne => "!=",
+            BinOp::Ge => ">=",
+            BinOp::Gt => ">",
+            BinOp::Offset => "`offset`",
+        })
+    }
+}
+
 impl From<hir_def::expr::ArithOp> for BinOp {
     fn from(value: hir_def::expr::ArithOp) -> Self {
         match value {
@@ -822,10 +842,9 @@ pub struct MirBody {
     pub owner: DefWithBodyId,
     pub arg_count: usize,
     pub binding_locals: ArenaMap<BindingId, LocalId>,
+    pub param_locals: Vec<LocalId>,
 }
 
-impl MirBody {}
-
 fn const_as_usize(c: &Const) -> usize {
     try_const_usize(c).unwrap() as usize
 }
diff --git a/crates/hir-ty/src/mir/borrowck.rs b/crates/hir-ty/src/mir/borrowck.rs
index fcf9a67fe83..7bd0f888b30 100644
--- a/crates/hir-ty/src/mir/borrowck.rs
+++ b/crates/hir-ty/src/mir/borrowck.rs
@@ -1,22 +1,43 @@
 //! MIR borrow checker, which is used in diagnostics like `unused_mut`
 
 // Currently it is an ad-hoc implementation, only useful for mutability analysis. Feel free to remove all of these
-// and implement a proper borrow checker.
+// if needed for implementing a proper borrow checker.
 
+use std::sync::Arc;
+
+use hir_def::DefWithBodyId;
 use la_arena::ArenaMap;
 use stdx::never;
 
+use crate::db::HirDatabase;
+
 use super::{
-    BasicBlockId, BorrowKind, LocalId, MirBody, MirSpan, Place, ProjectionElem, Rvalue,
-    StatementKind, Terminator,
+    BasicBlockId, BorrowKind, LocalId, MirBody, MirLowerError, MirSpan, Place, ProjectionElem,
+    Rvalue, StatementKind, Terminator,
 };
 
-#[derive(Debug)]
-pub enum Mutability {
-    Mut { span: MirSpan },
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// Stores spans which implies that the local should be mutable.
+pub enum MutabilityReason {
+    Mut { spans: Vec<MirSpan> },
     Not,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BorrowckResult {
+    pub mir_body: Arc<MirBody>,
+    pub mutability_of_locals: ArenaMap<LocalId, MutabilityReason>,
+}
+
+pub fn borrowck_query(
+    db: &dyn HirDatabase,
+    def: DefWithBodyId,
+) -> Result<Arc<BorrowckResult>, MirLowerError> {
+    let body = db.mir_body(def)?;
+    let r = BorrowckResult { mutability_of_locals: mutability_of_locals(&body), mir_body: body };
+    Ok(Arc::new(r))
+}
+
 fn is_place_direct(lvalue: &Place) -> bool {
     !lvalue.projection.iter().any(|x| *x == ProjectionElem::Deref)
 }
@@ -116,28 +137,28 @@ fn ever_initialized_map(body: &MirBody) -> ArenaMap<BasicBlockId, ArenaMap<Local
             }
         }
     }
-    for (b, block) in body.basic_blocks.iter() {
-        for statement in &block.statements {
-            if let StatementKind::Assign(p, _) = &statement.kind {
-                if p.projection.len() == 0 {
-                    let l = p.local;
-                    if !result[b].contains_idx(l) {
-                        result[b].insert(l, false);
-                        dfs(body, b, l, &mut result);
-                    }
-                }
-            }
+    for &l in &body.param_locals {
+        result[body.start_block].insert(l, true);
+        dfs(body, body.start_block, l, &mut result);
+    }
+    for l in body.locals.iter().map(|x| x.0) {
+        if !result[body.start_block].contains_idx(l) {
+            result[body.start_block].insert(l, false);
+            dfs(body, body.start_block, l, &mut result);
         }
     }
     result
 }
 
-pub fn mutability_of_locals(body: &MirBody) -> ArenaMap<LocalId, Mutability> {
-    let mut result: ArenaMap<LocalId, Mutability> =
-        body.locals.iter().map(|x| (x.0, Mutability::Not)).collect();
+fn mutability_of_locals(body: &MirBody) -> ArenaMap<LocalId, MutabilityReason> {
+    let mut result: ArenaMap<LocalId, MutabilityReason> =
+        body.locals.iter().map(|x| (x.0, MutabilityReason::Not)).collect();
+    let mut push_mut_span = |local, span| match &mut result[local] {
+        MutabilityReason::Mut { spans } => spans.push(span),
+        x @ MutabilityReason::Not => *x = MutabilityReason::Mut { spans: vec![span] },
+    };
     let ever_init_maps = ever_initialized_map(body);
-    for (block_id, ever_init_map) in ever_init_maps.iter() {
-        let mut ever_init_map = ever_init_map.clone();
+    for (block_id, mut ever_init_map) in ever_init_maps.into_iter() {
         let block = &body.basic_blocks[block_id];
         for statement in &block.statements {
             match &statement.kind {
@@ -145,20 +166,20 @@ pub fn mutability_of_locals(body: &MirBody) -> ArenaMap<LocalId, Mutability> {
                     match place_case(place) {
                         ProjectionCase::Direct => {
                             if ever_init_map.get(place.local).copied().unwrap_or_default() {
-                                result[place.local] = Mutability::Mut { span: statement.span };
+                                push_mut_span(place.local, statement.span);
                             } else {
                                 ever_init_map.insert(place.local, true);
                             }
                         }
                         ProjectionCase::DirectPart => {
                             // Partial initialization is not supported, so it is definitely `mut`
-                            result[place.local] = Mutability::Mut { span: statement.span };
+                            push_mut_span(place.local, statement.span);
                         }
                         ProjectionCase::Indirect => (),
                     }
                     if let Rvalue::Ref(BorrowKind::Mut { .. }, p) = value {
                         if is_place_direct(p) {
-                            result[p.local] = Mutability::Mut { span: statement.span };
+                            push_mut_span(p.local, statement.span);
                         }
                     }
                 }
@@ -189,7 +210,7 @@ pub fn mutability_of_locals(body: &MirBody) -> ArenaMap<LocalId, Mutability> {
             Terminator::Call { destination, .. } => {
                 if destination.projection.len() == 0 {
                     if ever_init_map.get(destination.local).copied().unwrap_or_default() {
-                        result[destination.local] = Mutability::Mut { span: MirSpan::Unknown };
+                        push_mut_span(destination.local, MirSpan::Unknown);
                     } else {
                         ever_init_map.insert(destination.local, true);
                     }
diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
index 73ae5eaeeff..e89e16079d6 100644
--- a/crates/hir-ty/src/mir/lower.rs
+++ b/crates/hir-ty/src/mir/lower.rs
@@ -16,7 +16,7 @@ use hir_def::{
 use la_arena::ArenaMap;
 
 use crate::{
-    consteval::ConstEvalError, db::HirDatabase, infer::TypeMismatch,
+    consteval::ConstEvalError, db::HirDatabase, display::HirDisplay, infer::TypeMismatch,
     inhabitedness::is_ty_uninhabited_from, layout::layout_of_ty, mapping::ToChalk, utils::generics,
     Adjust, AutoBorrow, CallableDefId, TyBuilder, TyExt,
 };
@@ -46,6 +46,7 @@ pub enum MirLowerError {
     LayoutError(LayoutError),
     IncompleteExpr,
     UnresolvedName(String),
+    RecordLiteralWithoutPath,
     UnresolvedMethod,
     UnresolvedField,
     MissingFunctionDefinition,
@@ -88,7 +89,7 @@ impl MirLowerCtx<'_> {
         if matches!(ty.kind(Interner), TyKind::Slice(_) | TyKind::Dyn(_)) {
             not_supported!("unsized temporaries");
         }
-        Ok(self.result.locals.alloc(Local { mutability: Mutability::Not, ty }))
+        Ok(self.result.locals.alloc(Local { ty }))
     }
 
     fn lower_expr_as_place(&self, expr_id: ExprId) -> Option<Place> {
@@ -251,7 +252,7 @@ impl MirLowerCtx<'_> {
         match &self.body.exprs[expr_id] {
             Expr::Missing => Err(MirLowerError::IncompleteExpr),
             Expr::Path(p) => {
-                let unresolved_name = || MirLowerError::UnresolvedName("".to_string());
+                let unresolved_name = || MirLowerError::UnresolvedName(p.display(self.db).to_string());
                 let resolver = resolver_for_expr(self.db.upcast(), self.owner, expr_id);
                 let pr = resolver
                     .resolve_path_in_value_ns(self.db.upcast(), p.mod_path())
@@ -259,19 +260,29 @@ impl MirLowerCtx<'_> {
                 let pr = match pr {
                     ResolveValueResult::ValueNs(v) => v,
                     ResolveValueResult::Partial(..) => {
-                        return match self
+                        if let Some(assoc) = self
                             .infer
                             .assoc_resolutions_for_expr(expr_id)
-                            .ok_or_else(unresolved_name)?
-                            .0
-                            //.ok_or(ConstEvalError::SemanticError("unresolved assoc item"))?
                         {
-                            hir_def::AssocItemId::ConstId(c) => {
-                                self.lower_const(c, current, place, expr_id.into())?;
-                                Ok(Some(current))
-                            },
-                            _ => return Err(unresolved_name()),
-                        };
+                            match assoc.0 {
+                                hir_def::AssocItemId::ConstId(c) => {
+                                    self.lower_const(c, current, place, expr_id.into())?;
+                                    return Ok(Some(current))
+                                },
+                                _ => not_supported!("associated functions and types"),
+                            }
+                        } else if let Some(variant) = self
+                            .infer
+                            .variant_resolution_for_expr(expr_id)
+                        {
+                            match variant {
+                                VariantId::EnumVariantId(e) => ValueNs::EnumVariantId(e),
+                                VariantId::StructId(s) => ValueNs::StructId(s),
+                                VariantId::UnionId(_) => return Err(MirLowerError::ImplementationError("Union variant as path")),
+                            }
+                        } else {
+                            return Err(unresolved_name());
+                        }
                     }
                 };
                 match pr {
@@ -597,11 +608,14 @@ impl MirLowerCtx<'_> {
                 Ok(None)
             }
             Expr::Yield { .. } => not_supported!("yield"),
-            Expr::RecordLit { fields, .. } => {
+            Expr::RecordLit { fields, path, .. } => {
                 let variant_id = self
                     .infer
                     .variant_resolution_for_expr(expr_id)
-                    .ok_or_else(|| MirLowerError::UnresolvedName("".to_string()))?;
+                    .ok_or_else(|| match path {
+                        Some(p) => MirLowerError::UnresolvedName(p.display(self.db).to_string()),
+                        None => MirLowerError::RecordLiteralWithoutPath,
+                    })?;
                 let subst = match self.expr_ty(expr_id).kind(Interner) {
                     TyKind::Adt(_, s) => s.clone(),
                     _ => not_supported!("Non ADT record literal"),
@@ -1437,17 +1451,17 @@ pub fn lower_to_mir(
         basic_blocks.alloc(BasicBlock { statements: vec![], terminator: None, is_cleanup: false });
     let mut locals = Arena::new();
     // 0 is return local
-    locals.alloc(Local { mutability: Mutability::Mut, ty: infer[root_expr].clone() });
+    locals.alloc(Local { ty: infer[root_expr].clone() });
     let mut binding_locals: ArenaMap<BindingId, LocalId> = ArenaMap::new();
-    let param_locals: ArenaMap<PatId, LocalId> = if let DefWithBodyId::FunctionId(fid) = owner {
+    // 1 to param_len is for params
+    let param_locals: Vec<LocalId> = if let DefWithBodyId::FunctionId(fid) = owner {
         let substs = TyBuilder::placeholder_subst(db, fid);
         let callable_sig = db.callable_item_signature(fid.into()).substitute(Interner, &substs);
-        // 1 to param_len is for params
         body.params
             .iter()
             .zip(callable_sig.params().iter())
             .map(|(&x, ty)| {
-                let local_id = locals.alloc(Local { mutability: Mutability::Not, ty: ty.clone() });
+                let local_id = locals.alloc(Local { ty: ty.clone() });
                 if let Pat::Bind { id, subpat: None } = body[x] {
                     if matches!(
                         body.bindings[id].mode,
@@ -1456,22 +1470,19 @@ pub fn lower_to_mir(
                         binding_locals.insert(id, local_id);
                     }
                 }
-                (x, local_id)
+                local_id
             })
             .collect()
     } else {
         if !body.params.is_empty() {
             return Err(MirLowerError::TypeError("Unexpected parameter for non function body"));
         }
-        ArenaMap::new()
+        vec![]
     };
     // and then rest of bindings
     for (id, _) in body.bindings.iter() {
         if !binding_locals.contains_idx(id) {
-            binding_locals.insert(
-                id,
-                locals.alloc(Local { mutability: Mutability::Not, ty: infer[id].clone() }),
-            );
+            binding_locals.insert(id, locals.alloc(Local { ty: infer[id].clone() }));
         }
     }
     let mir = MirBody {
@@ -1479,6 +1490,7 @@ pub fn lower_to_mir(
         locals,
         start_block,
         binding_locals,
+        param_locals,
         owner,
         arg_count: body.params.len(),
     };
@@ -1492,17 +1504,17 @@ pub fn lower_to_mir(
         discr_temp: None,
     };
     let mut current = start_block;
-    for &param in &body.params {
+    for (&param, local) in body.params.iter().zip(ctx.result.param_locals.clone().into_iter()) {
         if let Pat::Bind { id, .. } = body[param] {
-            if param_locals[param] == ctx.result.binding_locals[id] {
+            if local == ctx.result.binding_locals[id] {
                 continue;
             }
         }
         let r = ctx.pattern_match(
             current,
             None,
-            param_locals[param].into(),
-            ctx.result.locals[param_locals[param]].ty.clone(),
+            local.into(),
+            ctx.result.locals[local].ty.clone(),
             param,
             BindingAnnotation::Unannotated,
         )?;
diff --git a/crates/hir-ty/src/mir/pretty.rs b/crates/hir-ty/src/mir/pretty.rs
new file mode 100644
index 00000000000..ffc08b7e346
--- /dev/null
+++ b/crates/hir-ty/src/mir/pretty.rs
@@ -0,0 +1,348 @@
+//! A pretty-printer for MIR.
+
+use std::fmt::{Display, Write};
+
+use hir_def::{body::Body, expr::BindingId};
+use hir_expand::name::Name;
+use la_arena::ArenaMap;
+
+use crate::{
+    db::HirDatabase,
+    display::HirDisplay,
+    mir::{PlaceElem, ProjectionElem, StatementKind, Terminator},
+};
+
+use super::{
+    AggregateKind, BasicBlockId, BorrowKind, LocalId, MirBody, Operand, Place, Rvalue, UnOp,
+};
+
+impl MirBody {
+    pub fn pretty_print(&self, db: &dyn HirDatabase) -> String {
+        let hir_body = db.body(self.owner);
+        let mut ctx = MirPrettyCtx::new(self, &hir_body, db);
+        ctx.for_body();
+        ctx.result
+    }
+}
+
+struct MirPrettyCtx<'a> {
+    body: &'a MirBody,
+    hir_body: &'a Body,
+    db: &'a dyn HirDatabase,
+    result: String,
+    ident: String,
+    local_to_binding: ArenaMap<LocalId, BindingId>,
+}
+
+macro_rules! w {
+    ($dst:expr, $($arg:tt)*) => {
+        { let _ = write!($dst, $($arg)*); }
+    };
+}
+
+macro_rules! wln {
+    ($dst:expr) => {
+        { let _ = writeln!($dst); }
+    };
+    ($dst:expr, $($arg:tt)*) => {
+        { let _ = writeln!($dst, $($arg)*); }
+    };
+}
+
+impl Write for MirPrettyCtx<'_> {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        let mut it = s.split('\n'); // note: `.lines()` is wrong here
+        self.write(it.next().unwrap_or_default());
+        for line in it {
+            self.write_line();
+            self.write(line);
+        }
+        Ok(())
+    }
+}
+
+enum LocalName {
+    Unknown(LocalId),
+    Binding(Name, LocalId),
+}
+
+impl Display for LocalName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LocalName::Unknown(l) => write!(f, "_{}", u32::from(l.into_raw())),
+            LocalName::Binding(n, l) => write!(f, "{n}_{}", u32::from(l.into_raw())),
+        }
+    }
+}
+
+impl<'a> MirPrettyCtx<'a> {
+    fn for_body(&mut self) {
+        self.with_block(|this| {
+            this.locals();
+            wln!(this);
+            this.blocks();
+        });
+    }
+
+    fn with_block(&mut self, f: impl FnOnce(&mut MirPrettyCtx<'_>)) {
+        self.ident += "    ";
+        wln!(self, "{{");
+        f(self);
+        for _ in 0..4 {
+            self.result.pop();
+            self.ident.pop();
+        }
+        wln!(self, "}}");
+    }
+
+    fn new(body: &'a MirBody, hir_body: &'a Body, db: &'a dyn HirDatabase) -> Self {
+        let local_to_binding = body.binding_locals.iter().map(|(x, y)| (*y, x)).collect();
+        MirPrettyCtx {
+            body,
+            db,
+            result: String::new(),
+            ident: String::new(),
+            local_to_binding,
+            hir_body,
+        }
+    }
+
+    fn write_line(&mut self) {
+        self.result.push('\n');
+        self.result += &self.ident;
+    }
+
+    fn write(&mut self, line: &str) {
+        self.result += line;
+    }
+
+    fn locals(&mut self) {
+        for (id, local) in self.body.locals.iter() {
+            wln!(self, "let {}: {};", self.local_name(id), local.ty.display(self.db));
+        }
+    }
+
+    fn local_name(&self, local: LocalId) -> LocalName {
+        match self.local_to_binding.get(local) {
+            Some(b) => LocalName::Binding(self.hir_body.bindings[*b].name.clone(), local),
+            None => LocalName::Unknown(local),
+        }
+    }
+
+    fn basic_block_id(&self, basic_block_id: BasicBlockId) -> String {
+        format!("'bb{}", u32::from(basic_block_id.into_raw()))
+    }
+
+    fn blocks(&mut self) {
+        for (id, block) in self.body.basic_blocks.iter() {
+            wln!(self);
+            w!(self, "{}: ", self.basic_block_id(id));
+            self.with_block(|this| {
+                for statement in &block.statements {
+                    match &statement.kind {
+                        StatementKind::Assign(l, r) => {
+                            this.place(l);
+                            w!(this, " = ");
+                            this.rvalue(r);
+                            wln!(this, ";");
+                        }
+                        StatementKind::StorageDead(p) => {
+                            wln!(this, "StorageDead({})", this.local_name(*p));
+                        }
+                        StatementKind::StorageLive(p) => {
+                            wln!(this, "StorageLive({})", this.local_name(*p));
+                        }
+                        StatementKind::Deinit(p) => {
+                            w!(this, "Deinit(");
+                            this.place(p);
+                            wln!(this, ");");
+                        }
+                        StatementKind::Nop => wln!(this, "Nop;"),
+                    }
+                }
+                match &block.terminator {
+                    Some(terminator) => match terminator {
+                        Terminator::Goto { target } => {
+                            wln!(this, "goto 'bb{};", u32::from(target.into_raw()))
+                        }
+                        Terminator::SwitchInt { discr, targets } => {
+                            w!(this, "switch ");
+                            this.operand(discr);
+                            w!(this, " ");
+                            this.with_block(|this| {
+                                for (c, b) in targets.iter() {
+                                    wln!(this, "{c} => {},", this.basic_block_id(b));
+                                }
+                                wln!(this, "_ => {},", this.basic_block_id(targets.otherwise()));
+                            });
+                        }
+                        Terminator::Call { func, args, destination, target, .. } => {
+                            w!(this, "Call ");
+                            this.with_block(|this| {
+                                w!(this, "func: ");
+                                this.operand(func);
+                                wln!(this, ",");
+                                w!(this, "args: [");
+                                this.operand_list(args);
+                                wln!(this, "],");
+                                w!(this, "destination: ");
+                                this.place(destination);
+                                wln!(this, ",");
+                                w!(this, "target: ");
+                                match target {
+                                    Some(t) => w!(this, "{}", this.basic_block_id(*t)),
+                                    None => w!(this, "<unreachable>"),
+                                }
+                                wln!(this, ",");
+                            });
+                        }
+                        _ => wln!(this, "{:?};", terminator),
+                    },
+                    None => wln!(this, "<no-terminator>;"),
+                }
+            })
+        }
+    }
+
+    fn place(&mut self, p: &Place) {
+        fn f(this: &mut MirPrettyCtx<'_>, local: LocalId, projections: &[PlaceElem]) {
+            let Some((last, head)) = projections.split_last() else {
+                // no projection
+                w!(this, "{}", this.local_name(local));
+                return;
+            };
+            match last {
+                ProjectionElem::Deref => {
+                    w!(this, "(*");
+                    f(this, local, head);
+                    w!(this, ")");
+                }
+                ProjectionElem::Field(field) => {
+                    let variant_data = field.parent.variant_data(this.db.upcast());
+                    let name = &variant_data.fields()[field.local_id].name;
+                    match field.parent {
+                        hir_def::VariantId::EnumVariantId(e) => {
+                            w!(this, "(");
+                            f(this, local, head);
+                            let variant_name =
+                                &this.db.enum_data(e.parent).variants[e.local_id].name;
+                            w!(this, " as {}).{}", variant_name, name);
+                        }
+                        hir_def::VariantId::StructId(_) | hir_def::VariantId::UnionId(_) => {
+                            f(this, local, head);
+                            w!(this, ".{name}");
+                        }
+                    }
+                }
+                ProjectionElem::TupleField(x) => {
+                    f(this, local, head);
+                    w!(this, ".{}", x);
+                }
+                ProjectionElem::Index(l) => {
+                    f(this, local, head);
+                    w!(this, "[{}]", this.local_name(*l));
+                }
+                x => {
+                    f(this, local, head);
+                    w!(this, ".{:?}", x);
+                }
+            }
+        }
+        f(self, p.local, &p.projection);
+    }
+
+    fn operand(&mut self, r: &Operand) {
+        match r {
+            Operand::Copy(p) | Operand::Move(p) => {
+                // MIR at the time of writing doesn't have difference between move and copy, so we show them
+                // equally. Feel free to change it.
+                self.place(p);
+            }
+            Operand::Constant(c) => w!(self, "Const({})", c.display(self.db)),
+        }
+    }
+
+    fn rvalue(&mut self, r: &Rvalue) {
+        match r {
+            Rvalue::Use(op) => self.operand(op),
+            Rvalue::Ref(r, p) => {
+                match r {
+                    BorrowKind::Shared => w!(self, "&"),
+                    BorrowKind::Shallow => w!(self, "&shallow "),
+                    BorrowKind::Unique => w!(self, "&uniq "),
+                    BorrowKind::Mut { .. } => w!(self, "&mut "),
+                }
+                self.place(p);
+            }
+            Rvalue::Aggregate(AggregateKind::Tuple(_), x) => {
+                w!(self, "(");
+                self.operand_list(x);
+                w!(self, ")");
+            }
+            Rvalue::Aggregate(AggregateKind::Array(_), x) => {
+                w!(self, "[");
+                self.operand_list(x);
+                w!(self, "]");
+            }
+            Rvalue::Aggregate(AggregateKind::Adt(_, _), x) => {
+                w!(self, "Adt(");
+                self.operand_list(x);
+                w!(self, ")");
+            }
+            Rvalue::Aggregate(AggregateKind::Union(_, _), x) => {
+                w!(self, "Union(");
+                self.operand_list(x);
+                w!(self, ")");
+            }
+            Rvalue::Len(p) => {
+                w!(self, "Len(");
+                self.place(p);
+                w!(self, ")");
+            }
+            Rvalue::Cast(ck, op, ty) => {
+                w!(self, "Discriminant({ck:?}");
+                self.operand(op);
+                w!(self, "{})", ty.display(self.db));
+            }
+            Rvalue::CheckedBinaryOp(b, o1, o2) => {
+                self.operand(o1);
+                w!(self, " {b} ");
+                self.operand(o2);
+            }
+            Rvalue::UnaryOp(u, o) => {
+                let u = match u {
+                    UnOp::Not => "!",
+                    UnOp::Neg => "-",
+                };
+                w!(self, "{u} ");
+                self.operand(o);
+            }
+            Rvalue::Discriminant(p) => {
+                w!(self, "Discriminant(");
+                self.place(p);
+                w!(self, ")");
+            }
+            Rvalue::ShallowInitBox(op, _) => {
+                w!(self, "ShallowInitBox(");
+                self.operand(op);
+                w!(self, ")");
+            }
+            Rvalue::CopyForDeref(p) => {
+                w!(self, "CopyForDeref(");
+                self.place(p);
+                w!(self, ")");
+            }
+        }
+    }
+
+    fn operand_list(&mut self, x: &[Operand]) {
+        let mut it = x.iter();
+        if let Some(first) = it.next() {
+            self.operand(first);
+            for op in it {
+                w!(self, ", ");
+                self.operand(op);
+            }
+        }
+    }
+}
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index a28b2d577aa..e84f5ebb366 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -10,8 +10,8 @@ use hir_expand::InFile;
 use syntax::ast;
 
 use crate::{
-    db::HirDatabase, Adt, Const, Enum, Field, FieldSource, Function, Impl, LifetimeParam, Macro,
-    Module, Static, Struct, Trait, TraitAlias, TypeAlias, TypeOrConstParam, Union, Variant,
+    db::HirDatabase, Adt, Const, Enum, Field, FieldSource, Function, Impl, LifetimeParam,
+    LocalSource, Macro, Module, Static, Struct, Trait, TypeAlias, TraitAlias, TypeOrConstParam, Union, Variant,
 };
 
 pub trait HasSource {
@@ -178,3 +178,11 @@ impl HasSource for LifetimeParam {
         Some(child_source.map(|it| it[self.id.local_id].clone()))
     }
 }
+
+impl HasSource for LocalSource {
+    type Ast = Either<ast::IdentPat, ast::SelfParam>;
+
+    fn source(self, _: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
+        Some(self.source)
+    }
+}
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 4b65a93cac1..248f4ff8589 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -1327,6 +1327,15 @@ impl DefWithBody {
         body.pretty_print(db.upcast(), self.id())
     }
 
+    /// A textual representation of the MIR of this def's body for debugging purposes.
+    pub fn debug_mir(self, db: &dyn HirDatabase) -> String {
+        let body = db.mir_body(self.id());
+        match body {
+            Ok(body) => body.pretty_print(db),
+            Err(e) => format!("error:\n{e:?}"),
+        }
+    }
+
     pub fn diagnostics(self, db: &dyn HirDatabase, acc: &mut Vec<AnyDiagnostic>) {
         let krate = self.module(db).id.krate();
 
@@ -1502,32 +1511,35 @@ impl DefWithBody {
 
         let hir_body = db.body(self.into());
 
-        if let Ok(mir_body) = db.mir_body(self.into()) {
-            let mol = mir::borrowck::mutability_of_locals(&mir_body);
+        if let Ok(borrowck_result) = db.borrowck(self.into()) {
+            let mir_body = &borrowck_result.mir_body;
+            let mol = &borrowck_result.mutability_of_locals;
             for (binding_id, _) in hir_body.bindings.iter() {
                 let need_mut = &mol[mir_body.binding_locals[binding_id]];
                 let local = Local { parent: self.into(), binding_id };
                 match (need_mut, local.is_mut(db)) {
-                    (mir::borrowck::Mutability::Mut { .. }, true)
-                    | (mir::borrowck::Mutability::Not, false) => (),
-                    (mir::borrowck::Mutability::Mut { span }, false) => {
-                        let span: InFile<SyntaxNodePtr> = match span {
-                            mir::MirSpan::ExprId(e) => match source_map.expr_syntax(*e) {
-                                Ok(s) => s.map(|x| x.into()),
-                                Err(_) => continue,
-                            },
-                            mir::MirSpan::PatId(p) => match source_map.pat_syntax(*p) {
-                                Ok(s) => s.map(|x| match x {
-                                    Either::Left(e) => e.into(),
-                                    Either::Right(e) => e.into(),
-                                }),
-                                Err(_) => continue,
-                            },
-                            mir::MirSpan::Unknown => continue,
-                        };
-                        acc.push(NeedMut { local, span }.into());
+                    (mir::MutabilityReason::Mut { .. }, true)
+                    | (mir::MutabilityReason::Not, false) => (),
+                    (mir::MutabilityReason::Mut { spans }, false) => {
+                        for span in spans {
+                            let span: InFile<SyntaxNodePtr> = match span {
+                                mir::MirSpan::ExprId(e) => match source_map.expr_syntax(*e) {
+                                    Ok(s) => s.map(|x| x.into()),
+                                    Err(_) => continue,
+                                },
+                                mir::MirSpan::PatId(p) => match source_map.pat_syntax(*p) {
+                                    Ok(s) => s.map(|x| match x {
+                                        Either::Left(e) => e.into(),
+                                        Either::Right(e) => e.into(),
+                                    }),
+                                    Err(_) => continue,
+                                },
+                                mir::MirSpan::Unknown => continue,
+                            };
+                            acc.push(NeedMut { local, span }.into());
+                        }
                     }
-                    (mir::borrowck::Mutability::Not, true) => acc.push(UnusedMut { local }.into()),
+                    (mir::MutabilityReason::Not, true) => acc.push(UnusedMut { local }.into()),
                 }
             }
         }
@@ -2519,6 +2531,10 @@ impl LocalSource {
         self.source.file_id.original_file(db.upcast())
     }
 
+    pub fn name(&self) -> Option<ast::Name> {
+        self.source.value.name()
+    }
+
     pub fn syntax(&self) -> &SyntaxNode {
         self.source.value.syntax()
     }
diff --git a/crates/ide-db/src/rename.rs b/crates/ide-db/src/rename.rs
index 298c7141390..f710211c8cb 100644
--- a/crates/ide-db/src/rename.rs
+++ b/crates/ide-db/src/rename.rs
@@ -121,8 +121,7 @@ impl Definition {
             Definition::Trait(it) => name_range(it, sema),
             Definition::TraitAlias(it) => name_range(it, sema),
             Definition::TypeAlias(it) => name_range(it, sema),
-            // A local might be `self` or have multiple definitons like `let (a | a) = 2`, so it should be handled as a special case
-            Definition::Local(_) => return None,
+            Definition::Local(it) => name_range(it.primary_source(sema.db), sema),
             Definition::GenericParam(generic_param) => match generic_param {
                 hir::GenericParam::LifetimeParam(lifetime_param) => {
                     let src = lifetime_param.source(sema.db)?;
diff --git a/crates/ide-diagnostics/src/handlers/mutability_errors.rs b/crates/ide-diagnostics/src/handlers/mutability_errors.rs
index a78b58fdc80..4f5d958354d 100644
--- a/crates/ide-diagnostics/src/handlers/mutability_errors.rs
+++ b/crates/ide-diagnostics/src/handlers/mutability_errors.rs
@@ -1,31 +1,85 @@
-use crate::{Diagnostic, DiagnosticsContext, Severity};
+use ide_db::source_change::SourceChange;
+use syntax::{AstNode, SyntaxKind, SyntaxNode, SyntaxToken, T};
+use text_edit::TextEdit;
+
+use crate::{fix, Diagnostic, DiagnosticsContext, Severity};
 
 // Diagnostic: need-mut
 //
 // This diagnostic is triggered on mutating an immutable variable.
 pub(crate) fn need_mut(ctx: &DiagnosticsContext<'_>, d: &hir::NeedMut) -> Diagnostic {
+    let fixes = (|| {
+        if d.local.is_ref(ctx.sema.db) {
+            // There is no simple way to add `mut` to `ref x` and `ref mut x`
+            return None;
+        }
+        let file_id = d.span.file_id.file_id()?;
+        let mut edit_builder = TextEdit::builder();
+        let use_range = d.span.value.text_range();
+        for source in d.local.sources(ctx.sema.db) {
+            let Some(ast) = source.name() else { continue };
+            edit_builder.insert(ast.syntax().text_range().start(), "mut ".to_string());
+        }
+        let edit = edit_builder.finish();
+        Some(vec![fix(
+            "remove_mut",
+            "Remove unnecessary `mut`",
+            SourceChange::from_text_edit(file_id, edit),
+            use_range,
+        )])
+    })();
     Diagnostic::new(
         "need-mut",
         format!("cannot mutate immutable variable `{}`", d.local.name(ctx.sema.db)),
         ctx.sema.diagnostics_display_range(d.span.clone()).range,
     )
+    .with_fixes(fixes)
 }
 
 // Diagnostic: unused-mut
 //
 // This diagnostic is triggered when a mutable variable isn't actually mutated.
 pub(crate) fn unused_mut(ctx: &DiagnosticsContext<'_>, d: &hir::UnusedMut) -> Diagnostic {
+    let ast = d.local.primary_source(ctx.sema.db).syntax_ptr();
+    let fixes = (|| {
+        let file_id = ast.file_id.file_id()?;
+        let mut edit_builder = TextEdit::builder();
+        let use_range = ast.value.text_range();
+        for source in d.local.sources(ctx.sema.db) {
+            let ast = source.syntax();
+            let Some(mut_token) = token(ast, T![mut]) else { continue };
+            edit_builder.delete(mut_token.text_range());
+            if let Some(token) = mut_token.next_token() {
+                if token.kind() == SyntaxKind::WHITESPACE {
+                    edit_builder.delete(token.text_range());
+                }
+            }
+        }
+        let edit = edit_builder.finish();
+        Some(vec![fix(
+            "remove_mut",
+            "Remove unnecessary `mut`",
+            SourceChange::from_text_edit(file_id, edit),
+            use_range,
+        )])
+    })();
+    let ast = d.local.primary_source(ctx.sema.db).syntax_ptr();
     Diagnostic::new(
         "unused-mut",
         "remove this `mut`",
-        ctx.sema.diagnostics_display_range(d.local.primary_source(ctx.sema.db).syntax_ptr()).range,
+        ctx.sema.diagnostics_display_range(ast).range,
     )
     .severity(Severity::WeakWarning)
+    .with_fixes(fixes)
+}
+
+pub(super) fn token(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> {
+    parent.children_with_tokens().filter_map(|it| it.into_token()).find(|it| it.kind() == kind)
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::check_diagnostics;
+    use crate::tests::{check_diagnostics, check_fix};
 
     #[test]
     fn unused_mut_simple() {
@@ -34,7 +88,7 @@ mod tests {
 fn f(_: i32) {}
 fn main() {
     let mut x = 2;
-      //^^^^^ weak: remove this `mut`
+      //^^^^^ 💡 weak: remove this `mut`
     f(x);
 }
 "#,
@@ -64,6 +118,144 @@ fn main() {
         );
     }
 
+    #[test]
+    fn multiple_errors_for_single_variable() {
+        check_diagnostics(
+            r#"
+fn f(_: i32) {}
+fn main() {
+    let x = 2;
+    x = 10;
+  //^^^^^^ 💡 error: cannot mutate immutable variable `x`
+    x = 5;
+  //^^^^^ 💡 error: cannot mutate immutable variable `x`
+    &mut x;
+  //^^^^^^ 💡 error: cannot mutate immutable variable `x`
+    f(x);
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn unused_mut_fix() {
+        check_fix(
+            r#"
+fn f(_: i32) {}
+fn main() {
+    let mu$0t x = 2;
+    f(x);
+}
+"#,
+            r#"
+fn f(_: i32) {}
+fn main() {
+    let x = 2;
+    f(x);
+}
+"#,
+        );
+        check_fix(
+            r#"
+fn f(_: i32) {}
+fn main() {
+    let ((mu$0t x, _) | (_, mut x)) = (2, 3);
+    f(x);
+}
+"#,
+            r#"
+fn f(_: i32) {}
+fn main() {
+    let ((x, _) | (_, x)) = (2, 3);
+    f(x);
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn need_mut_fix() {
+        check_fix(
+            r#"
+fn f(_: i32) {}
+fn main() {
+    let x = 2;
+    x$0 = 5;
+    f(x);
+}
+"#,
+            r#"
+fn f(_: i32) {}
+fn main() {
+    let mut x = 2;
+    x = 5;
+    f(x);
+}
+"#,
+        );
+        check_fix(
+            r#"
+fn f(_: i32) {}
+fn main() {
+    let ((x, _) | (_, x)) = (2, 3);
+    x =$0 4;
+    f(x);
+}
+"#,
+            r#"
+fn f(_: i32) {}
+fn main() {
+    let ((mut x, _) | (_, mut x)) = (2, 3);
+    x = 4;
+    f(x);
+}
+"#,
+        );
+
+        check_fix(
+            r#"
+struct Foo(i32);
+
+impl Foo {
+    fn foo(self) {
+        self = Fo$0o(5);
+    }
+}
+"#,
+            r#"
+struct Foo(i32);
+
+impl Foo {
+    fn foo(mut self) {
+        self = Foo(5);
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn need_mut_fix_not_applicable_on_ref() {
+        check_diagnostics(
+            r#"
+fn main() {
+    let ref x = 2;
+    x = &5;
+  //^^^^^^ error: cannot mutate immutable variable `x`
+}
+"#,
+        );
+        check_diagnostics(
+            r#"
+fn main() {
+    let ref mut x = 2;
+    x = &mut 5;
+  //^^^^^^^^^^ error: cannot mutate immutable variable `x`
+}
+"#,
+        );
+    }
+
     #[test]
     fn field_mutate() {
         check_diagnostics(
@@ -71,7 +263,7 @@ fn main() {
 fn f(_: i32) {}
 fn main() {
     let mut x = (2, 7);
-      //^^^^^ weak: remove this `mut`
+      //^^^^^ 💡 weak: remove this `mut`
     f(x.1);
 }
 "#,
@@ -92,7 +284,7 @@ fn f(_: i32) {}
 fn main() {
     let x = (2, 7);
     x.0 = 5;
-  //^^^^^^^ error: cannot mutate immutable variable `x`
+  //^^^^^^^ 💡 error: cannot mutate immutable variable `x`
     f(x.1);
 }
 "#,
@@ -105,7 +297,7 @@ fn main() {
             r#"
 fn main() {
     let mut x = &mut 2;
-      //^^^^^ weak: remove this `mut`
+      //^^^^^ 💡 weak: remove this `mut`
     *x = 5;
 }
 "#,
@@ -115,7 +307,7 @@ fn main() {
 fn main() {
     let x = 2;
     &mut x;
-  //^^^^^^ error: cannot mutate immutable variable `x`
+  //^^^^^^ 💡 error: cannot mutate immutable variable `x`
 }
 "#,
         );
@@ -124,7 +316,7 @@ fn main() {
 fn main() {
     let x_own = 2;
     let ref mut x_ref = x_own;
-      //^^^^^^^^^^^^^ error: cannot mutate immutable variable `x_own`
+      //^^^^^^^^^^^^^ 💡 error: cannot mutate immutable variable `x_own`
 }
 "#,
         );
@@ -137,7 +329,7 @@ impl Foo {
 fn main() {
     let x = Foo;
     x.method(2);
-  //^ error: cannot mutate immutable variable `x`
+  //^ 💡 error: cannot mutate immutable variable `x`
 }
 "#,
         );
@@ -150,9 +342,9 @@ fn main() {
 fn main() {
     match (2, 3) {
         (x, mut y) => {
-          //^^^^^ weak: remove this `mut`
+          //^^^^^ 💡 weak: remove this `mut`
             x = 7;
-          //^^^^^ error: cannot mutate immutable variable `x`
+          //^^^^^ 💡 error: cannot mutate immutable variable `x`
         }
     }
 }
@@ -171,7 +363,7 @@ fn main() {
 fn main() {
     return;
     let mut x = 2;
-      //^^^^^ weak: remove this `mut`
+      //^^^^^ 💡 weak: remove this `mut`
     &mut x;
 }
 "#,
@@ -181,7 +373,7 @@ fn main() {
 fn main() {
     loop {}
     let mut x = 2;
-      //^^^^^ weak: remove this `mut`
+      //^^^^^ 💡 weak: remove this `mut`
     &mut x;
 }
 "#,
@@ -202,7 +394,7 @@ fn main(b: bool) {
         g();
     }
     let mut x = 2;
-      //^^^^^ weak: remove this `mut`
+      //^^^^^ 💡 weak: remove this `mut`
     &mut x;
 }
 "#,
@@ -216,7 +408,7 @@ fn main(b: bool) {
         return;
     }
     let mut x = 2;
-      //^^^^^ weak: remove this `mut`
+      //^^^^^ 💡 weak: remove this `mut`
     &mut x;
 }
 "#,
@@ -230,7 +422,7 @@ fn main(b: bool) {
 fn f(_: i32) {}
 fn main() {
     let mut x;
-      //^^^^^ weak: remove this `mut`
+      //^^^^^ 💡 weak: remove this `mut`
     x = 5;
     f(x);
 }
@@ -241,7 +433,7 @@ fn main() {
 fn f(_: i32) {}
 fn main(b: bool) {
     let mut x;
-      //^^^^^ weak: remove this `mut`
+      //^^^^^ 💡 weak: remove this `mut`
     if b {
         x = 1;
     } else {
@@ -260,7 +452,7 @@ fn main(b: bool) {
         x = 1;
     }
     x = 3;
-  //^^^^^ error: cannot mutate immutable variable `x`
+  //^^^^^ 💡 error: cannot mutate immutable variable `x`
     f(x);
 }
 "#,
@@ -272,7 +464,7 @@ fn main() {
     let x;
     loop {
         x = 1;
-      //^^^^^ error: cannot mutate immutable variable `x`
+      //^^^^^ 💡 error: cannot mutate immutable variable `x`
         f(x);
     }
 }
@@ -284,18 +476,37 @@ fn f(_: i32) {}
 fn main() {
     loop {
         let mut x = 1;
-          //^^^^^ weak: remove this `mut`
+          //^^^^^ 💡 weak: remove this `mut`
         f(x);
         if let mut y = 2 {
-             //^^^^^ weak: remove this `mut`
+             //^^^^^ 💡 weak: remove this `mut`
             f(y);
         }
         match 3 {
             mut z => f(z),
-          //^^^^^ weak: remove this `mut`
+          //^^^^^ 💡 weak: remove this `mut`
         }
     }
 }
+"#,
+        );
+    }
+
+    #[test]
+    fn function_arguments_are_initialized() {
+        check_diagnostics(
+            r#"
+fn f(mut x: i32) {
+   //^^^^^ 💡 weak: remove this `mut`
+}
+"#,
+        );
+        check_diagnostics(
+            r#"
+fn f(x: i32) {
+   x = 5;
+ //^^^^^ 💡 error: cannot mutate immutable variable `x`
+}
 "#,
         );
     }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index f2b535bdc7e..078b66dd395 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -55,6 +55,7 @@ mod syntax_tree;
 mod typing;
 mod view_crate_graph;
 mod view_hir;
+mod view_mir;
 mod view_item_tree;
 mod shuffle_crate_graph;
 
@@ -308,6 +309,10 @@ impl Analysis {
         self.with_db(|db| view_hir::view_hir(db, position))
     }
 
+    pub fn view_mir(&self, position: FilePosition) -> Cancellable<String> {
+        self.with_db(|db| view_mir::view_mir(db, position))
+    }
+
     pub fn view_item_tree(&self, file_id: FileId) -> Cancellable<String> {
         self.with_db(|db| view_item_tree::view_item_tree(db, file_id))
     }
diff --git a/crates/ide/src/rename.rs b/crates/ide/src/rename.rs
index c0237e1edd0..e10c4638102 100644
--- a/crates/ide/src/rename.rs
+++ b/crates/ide/src/rename.rs
@@ -353,6 +353,11 @@ mod tests {
     fn check(new_name: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
         let ra_fixture_after = &trim_indent(ra_fixture_after);
         let (analysis, position) = fixture::position(ra_fixture_before);
+        if !ra_fixture_after.starts_with("error: ") {
+            if let Err(err) = analysis.prepare_rename(position).unwrap() {
+                panic!("Prepare rename to '{new_name}' was failed: {err}")
+            }
+        }
         let rename_result = analysis
             .rename(position, new_name)
             .unwrap_or_else(|err| panic!("Rename to '{new_name}' was cancelled: {err}"));
@@ -1709,6 +1714,23 @@ fn foo(bar: i32) -> Foo {
         );
     }
 
+    #[test]
+    fn test_rename_local_simple() {
+        check(
+            "i",
+            r#"
+fn foo(bar$0: i32) -> i32 {
+    bar
+}
+"#,
+            r#"
+fn foo(i: i32) -> i32 {
+    i
+}
+"#,
+        );
+    }
+
     #[test]
     fn test_rename_local_put_init_shorthand() {
         cov_mark::check!(test_rename_local_put_init_shorthand);
diff --git a/crates/ide/src/view_mir.rs b/crates/ide/src/view_mir.rs
new file mode 100644
index 00000000000..a36aba58bc0
--- /dev/null
+++ b/crates/ide/src/view_mir.rs
@@ -0,0 +1,29 @@
+use hir::{DefWithBody, Semantics};
+use ide_db::base_db::FilePosition;
+use ide_db::RootDatabase;
+use syntax::{algo::find_node_at_offset, ast, AstNode};
+
+// Feature: View Mir
+//
+// |===
+// | Editor  | Action Name
+//
+// | VS Code | **rust-analyzer: View Mir**
+// |===
+pub(crate) fn view_mir(db: &RootDatabase, position: FilePosition) -> String {
+    body_mir(db, position).unwrap_or_else(|| "Not inside a function body".to_string())
+}
+
+fn body_mir(db: &RootDatabase, position: FilePosition) -> Option<String> {
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(position.file_id);
+
+    let item = find_node_at_offset::<ast::Item>(source_file.syntax(), position.offset)?;
+    let def: DefWithBody = match item {
+        ast::Item::Fn(it) => sema.to_def(&it)?.into(),
+        ast::Item::Const(it) => sema.to_def(&it)?.into(),
+        ast::Item::Static(it) => sema.to_def(&it)?.into(),
+        _ => return None,
+    };
+    Some(def.debug_mir(db))
+}
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 4e08bd0a724..32ac9a42dec 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -134,6 +134,16 @@ pub(crate) fn handle_view_hir(
     Ok(res)
 }
 
+pub(crate) fn handle_view_mir(
+    snap: GlobalStateSnapshot,
+    params: lsp_types::TextDocumentPositionParams,
+) -> Result<String> {
+    let _p = profile::span("handle_view_mir");
+    let position = from_proto::file_position(&snap, params)?;
+    let res = snap.analysis.view_mir(position)?;
+    Ok(res)
+}
+
 pub(crate) fn handle_view_file_text(
     snap: GlobalStateSnapshot,
     params: lsp_types::TextDocumentIdentifier,
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index e33589cc536..c7b513db981 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -74,6 +74,14 @@ impl Request for ViewHir {
     const METHOD: &'static str = "rust-analyzer/viewHir";
 }
 
+pub enum ViewMir {}
+
+impl Request for ViewMir {
+    type Params = lsp_types::TextDocumentPositionParams;
+    type Result = String;
+    const METHOD: &'static str = "rust-analyzer/viewMir";
+}
+
 pub enum ViewFileText {}
 
 impl Request for ViewFileText {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index d1e38b33c7d..d2797690669 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -634,6 +634,7 @@ impl GlobalState {
             .on::<lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status)
             .on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)
             .on::<lsp_ext::ViewHir>(handlers::handle_view_hir)
+            .on::<lsp_ext::ViewMir>(handlers::handle_view_mir)
             .on::<lsp_ext::ViewFileText>(handlers::handle_view_file_text)
             .on::<lsp_ext::ViewCrateGraph>(handlers::handle_view_crate_graph)
             .on::<lsp_ext::ViewItemTree>(handlers::handle_view_item_tree)
diff --git a/crates/syntax/src/ast/traits.rs b/crates/syntax/src/ast/traits.rs
index bc7b5582318..3e43df2d0d5 100644
--- a/crates/syntax/src/ast/traits.rs
+++ b/crates/syntax/src/ast/traits.rs
@@ -134,3 +134,5 @@ impl Iterator for AttrDocCommentIter {
         })
     }
 }
+
+impl<A: HasName, B: HasName> HasName for Either<A, B> {}
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index c3623a5cc46..de142203208 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: d87477896dfe41d4
+lsp_ext.rs hash: 37f31ae648632897
 
 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:
@@ -527,6 +527,17 @@ Primarily for debugging, but very useful for all people working on rust-analyzer
 Returns a textual representation of the HIR of the function containing the cursor.
 For debugging or when working on rust-analyzer itself.
 
+## View Mir
+
+**Method:** `rust-analyzer/viewMir`
+
+**Request:** `TextDocumentPositionParams`
+
+**Response:** `string`
+
+Returns a textual representation of the MIR of the function containing the cursor.
+For debugging or when working on rust-analyzer itself.
+
 ## View File Text
 
 **Method:** `rust-analyzer/viewFileText`
diff --git a/editors/code/package.json b/editors/code/package.json
index effe4e279c7..90f7b9074c8 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -114,6 +114,11 @@
                 "title": "View Hir",
                 "category": "rust-analyzer (debug command)"
             },
+            {
+                "command": "rust-analyzer.viewMir",
+                "title": "View Mir",
+                "category": "rust-analyzer (debug command)"
+            },
             {
                 "command": "rust-analyzer.viewFileText",
                 "title": "View File Text (as seen by the server)",
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 49a8ca4edba..70b91fe7dc8 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -405,12 +405,11 @@ export function syntaxTree(ctx: CtxInit): Cmd {
     };
 }
 
-// Opens the virtual file that will show the HIR of the function containing the cursor position
-//
-// The contents of the file come from the `TextDocumentContentProvider`
-export function viewHir(ctx: CtxInit): Cmd {
+function viewHirOrMir(ctx: CtxInit, xir: "hir" | "mir"): Cmd {
+    const viewXir = xir === "hir" ? "viewHir" : "viewMir";
+    const requestType = xir === "hir" ? ra.viewHir : ra.viewMir;
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
-        readonly uri = vscode.Uri.parse("rust-analyzer-hir://viewHir/hir.rs");
+        readonly uri = vscode.Uri.parse(`rust-analyzer-${xir}://${viewXir}/${xir}.rs`);
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
         constructor() {
             vscode.workspace.onDidChangeTextDocument(
@@ -452,7 +451,7 @@ export function viewHir(ctx: CtxInit): Cmd {
                 ),
                 position: client.code2ProtocolConverter.asPosition(rustEditor.selection.active),
             };
-            return client.sendRequest(ra.viewHir, params, ct);
+            return client.sendRequest(requestType, params, ct);
         }
 
         get onDidChange(): vscode.Event<vscode.Uri> {
@@ -461,7 +460,7 @@ export function viewHir(ctx: CtxInit): Cmd {
     })();
 
     ctx.pushExtCleanup(
-        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-hir", tdcp)
+        vscode.workspace.registerTextDocumentContentProvider(`rust-analyzer-${xir}`, tdcp)
     );
 
     return async () => {
@@ -474,6 +473,20 @@ export function viewHir(ctx: CtxInit): Cmd {
     };
 }
 
+// Opens the virtual file that will show the HIR of the function containing the cursor position
+//
+// The contents of the file come from the `TextDocumentContentProvider`
+export function viewHir(ctx: CtxInit): Cmd {
+    return viewHirOrMir(ctx, "hir");
+}
+
+// Opens the virtual file that will show the MIR of the function containing the cursor position
+//
+// The contents of the file come from the `TextDocumentContentProvider`
+export function viewMir(ctx: CtxInit): Cmd {
+    return viewHirOrMir(ctx, "mir");
+}
+
 export function viewFileText(ctx: CtxInit): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
         readonly uri = vscode.Uri.parse("rust-analyzer-file-text://viewFileText/file.rs");
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index f6f5124dc41..400cd207d41 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -59,6 +59,9 @@ export const viewFileText = new lc.RequestType<lc.TextDocumentIdentifier, string
 export const viewHir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(
     "rust-analyzer/viewHir"
 );
+export const viewMir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(
+    "rust-analyzer/viewMir"
+);
 export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>(
     "rust-analyzer/viewItemTree"
 );
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 5987368e6e0..1eb01f30c1e 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -158,6 +158,7 @@ function createCommands(): Record<string, CommandFactory> {
         parentModule: { enabled: commands.parentModule },
         syntaxTree: { enabled: commands.syntaxTree },
         viewHir: { enabled: commands.viewHir },
+        viewMir: { enabled: commands.viewMir },
         viewFileText: { enabled: commands.viewFileText },
         viewItemTree: { enabled: commands.viewItemTree },
         viewCrateGraph: { enabled: commands.viewCrateGraph },
diff --git a/lib/la-arena/src/map.rs b/lib/la-arena/src/map.rs
index b9d491da3c0..7fff2b09c97 100644
--- a/lib/la-arena/src/map.rs
+++ b/lib/la-arena/src/map.rs
@@ -94,6 +94,12 @@ impl<T, V> ArenaMap<Idx<T>, V> {
             .filter_map(|(idx, o)| Some((Self::from_idx(idx), o.as_mut()?)))
     }
 
+    /// Returns an iterator over the arena indexes and values in the map.
+    // FIXME: Implement `IntoIterator` trait.
+    pub fn into_iter(self) -> impl Iterator<Item = (Idx<T>, V)> {
+        self.v.into_iter().enumerate().filter_map(|(idx, o)| Some((Self::from_idx(idx), o?)))
+    }
+
     /// Gets the given key's corresponding entry in the map for in-place manipulation.
     pub fn entry(&mut self, idx: Idx<T>) -> Entry<'_, Idx<T>, V> {
         let idx = Self::to_idx(idx);
-- 
cgit 1.4.1-3-g733a5


From 2cb60343ed3774d4645d7d14dff8a1119d3c6785 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Fri, 10 Mar 2023 10:13:30 +0100
Subject: Add fancy buttons to the vscode status message

---
 editors/code/src/commands.ts |  8 ++++++++
 editors/code/src/ctx.ts      | 34 ++++++++++++++++++++++------------
 editors/code/src/main.ts     |  1 +
 3 files changed, 31 insertions(+), 12 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 70b91fe7dc8..f4a4579a92c 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -93,6 +93,14 @@ export function triggerParameterHints(_: CtxInit): Cmd {
     };
 }
 
+export function openLogs(ctx: CtxInit): Cmd {
+    return async () => {
+        if (ctx.client.outputChannel) {
+            ctx.client.outputChannel.show();
+        }
+    };
+}
+
 export function matchingBrace(ctx: CtxInit): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index e2a30e0cc45..1708d47cee7 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -282,18 +282,18 @@ export class Ctx {
     setServerStatus(status: ServerStatusParams | { health: "stopped" }) {
         let icon = "";
         const statusBar = this.statusBar;
+        statusBar.tooltip = new vscode.MarkdownString("", true);
+        statusBar.tooltip.isTrusted = true;
         switch (status.health) {
             case "ok":
-                statusBar.tooltip = (status.message ?? "Ready") + "\nClick to stop server.";
-                statusBar.command = "rust-analyzer.stopServer";
+                statusBar.tooltip.appendText(status.message ?? "Ready");
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
                 break;
             case "warning":
-                statusBar.tooltip =
-                    (status.message ? status.message + "\n" : "") + "Click to reload.";
-
-                statusBar.command = "rust-analyzer.reloadWorkspace";
+                if (status.message) {
+                    statusBar.tooltip.appendText(status.message);
+                }
                 statusBar.color = new vscode.ThemeColor("statusBarItem.warningForeground");
                 statusBar.backgroundColor = new vscode.ThemeColor(
                     "statusBarItem.warningBackground"
@@ -301,22 +301,32 @@ export class Ctx {
                 icon = "$(warning) ";
                 break;
             case "error":
-                statusBar.tooltip =
-                    (status.message ? status.message + "\n" : "") + "Click to reload.";
-
-                statusBar.command = "rust-analyzer.reloadWorkspace";
+                if (status.message) {
+                    statusBar.tooltip.appendText(status.message);
+                }
                 statusBar.color = new vscode.ThemeColor("statusBarItem.errorForeground");
                 statusBar.backgroundColor = new vscode.ThemeColor("statusBarItem.errorBackground");
                 icon = "$(error) ";
                 break;
             case "stopped":
-                statusBar.tooltip = "Server is stopped.\nClick to start.";
-                statusBar.command = "rust-analyzer.startServer";
+                statusBar.tooltip.appendText("Server is stopped");
+                statusBar.tooltip.appendMarkdown(
+                    "\n\n[Start server](command:rust-analyzer.startServer)"
+                );
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
                 statusBar.text = `$(stop-circle) rust-analyzer`;
                 return;
         }
+        if (statusBar.tooltip.value) {
+            statusBar.tooltip.appendText("\n\n");
+        }
+        statusBar.tooltip.appendMarkdown("[Stop server](command:rust-analyzer.stopServer)");
+        statusBar.tooltip.appendMarkdown(
+            "\n\n[Reload Workspace](command:rust-analyzer.reloadWorkspace)"
+        );
+        statusBar.tooltip.appendMarkdown("\n\n[Restart server](command:rust-analyzer.startServer)");
+        statusBar.tooltip.appendMarkdown("\n\n[Open logs](command:rust-analyzer.openLogs)");
         if (!status.quiescent) icon = "$(sync~spin) ";
         statusBar.text = `${icon}rust-analyzer`;
     }
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 1eb01f30c1e..8a2412af849 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -188,5 +188,6 @@ function createCommands(): Record<string, CommandFactory> {
         runSingle: { enabled: commands.runSingle },
         showReferences: { enabled: commands.showReferences },
         triggerParameterHints: { enabled: commands.triggerParameterHints },
+        openLogs: { enabled: commands.openLogs },
     };
 }
-- 
cgit 1.4.1-3-g733a5


From cf95322541b350d6759b8f0817d68dc76f262bda Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 13 Mar 2023 12:32:53 +0100
Subject: Allow the status bar item to be clicked again

---
 editors/code/src/ctx.ts | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 1708d47cee7..02b665c7503 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -289,6 +289,7 @@ export class Ctx {
                 statusBar.tooltip.appendText(status.message ?? "Ready");
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
+                statusBar.command = "rust-analyzer.stopServer";
                 break;
             case "warning":
                 if (status.message) {
@@ -298,6 +299,7 @@ export class Ctx {
                 statusBar.backgroundColor = new vscode.ThemeColor(
                     "statusBarItem.warningBackground"
                 );
+                statusBar.command = "rust-analyzer.openLogs";
                 icon = "$(warning) ";
                 break;
             case "error":
@@ -306,6 +308,7 @@ export class Ctx {
                 }
                 statusBar.color = new vscode.ThemeColor("statusBarItem.errorForeground");
                 statusBar.backgroundColor = new vscode.ThemeColor("statusBarItem.errorBackground");
+                statusBar.command = "rust-analyzer.openLogs";
                 icon = "$(error) ";
                 break;
             case "stopped":
@@ -315,18 +318,19 @@ export class Ctx {
                 );
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
+                statusBar.command = "rust-analyzer.startServer";
                 statusBar.text = `$(stop-circle) rust-analyzer`;
                 return;
         }
         if (statusBar.tooltip.value) {
             statusBar.tooltip.appendText("\n\n");
         }
-        statusBar.tooltip.appendMarkdown("[Stop server](command:rust-analyzer.stopServer)");
         statusBar.tooltip.appendMarkdown(
             "\n\n[Reload Workspace](command:rust-analyzer.reloadWorkspace)"
         );
-        statusBar.tooltip.appendMarkdown("\n\n[Restart server](command:rust-analyzer.startServer)");
         statusBar.tooltip.appendMarkdown("\n\n[Open logs](command:rust-analyzer.openLogs)");
+        statusBar.tooltip.appendMarkdown("\n\n[Restart server](command:rust-analyzer.startServer)");
+        statusBar.tooltip.appendMarkdown("[Stop server](command:rust-analyzer.stopServer)");
         if (!status.quiescent) icon = "$(sync~spin) ";
         statusBar.text = `${icon}rust-analyzer`;
     }
-- 
cgit 1.4.1-3-g733a5


From 8af3d6367ecead0abf80e697176f697d97c25215 Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Thu, 9 Mar 2023 15:06:26 -0500
Subject: This commit add Cargo-style project discovery for Buck and Bazel
 users.

This feature requires the user to add a command that generates a
`rust-project.json` from a set of files. Project discovery can be invoked
in two ways:

1. At extension activation time, which includes the generated
   `rust-project.json` as part of the linkedProjects argument in
    InitializeParams
2. Through a new command titled "Add current file to workspace", which
   makes use of a new, rust-analyzer specific LSP request that adds
   the workspace without erasing any existing workspaces.

I think that the command-running functionality _could_ merit being
placed into its own extension (and expose it via extension contribution
points), if only provide build-system idiomatic progress reporting and
status handling, but I haven't (yet) made an extension that does this.
---
 crates/project-model/src/cfg_flag.rs     | 13 +++++
 crates/project-model/src/project_json.rs | 21 +++++---
 crates/rust-analyzer/src/config.rs       | 10 +++-
 crates/rust-analyzer/src/handlers.rs     | 17 ++++++
 crates/rust-analyzer/src/lsp_ext.rs      | 15 ++++++
 crates/rust-analyzer/src/main_loop.rs    |  1 +
 editors/code/package.json                | 18 ++++++-
 editors/code/src/commands.ts             | 19 ++++++-
 editors/code/src/config.ts               |  4 ++
 editors/code/src/ctx.ts                  | 42 +++++++++++----
 editors/code/src/lsp_ext.ts              |  6 +++
 editors/code/src/main.ts                 |  9 ++--
 editors/code/src/rust_project.ts         | 91 ++++++++++++++++++++++++++++++++
 editors/code/src/util.ts                 | 17 ++++++
 14 files changed, 258 insertions(+), 25 deletions(-)
 create mode 100644 editors/code/src/rust_project.ts

(limited to 'editors/code/src')

diff --git a/crates/project-model/src/cfg_flag.rs b/crates/project-model/src/cfg_flag.rs
index c134b78ab3a..2a4767970c0 100644
--- a/crates/project-model/src/cfg_flag.rs
+++ b/crates/project-model/src/cfg_flag.rs
@@ -4,6 +4,7 @@
 use std::{fmt, str::FromStr};
 
 use cfg::CfgOptions;
+use serde::Serialize;
 
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub enum CfgFlag {
@@ -38,6 +39,18 @@ impl<'de> serde::Deserialize<'de> for CfgFlag {
     }
 }
 
+impl Serialize for CfgFlag {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            CfgFlag::Atom(s) => serializer.serialize_str(s),
+            CfgFlag::KeyValue { .. } => serializer.serialize_str(&format!("{}", &self)),
+        }
+    }
+}
+
 impl Extend<CfgFlag> for CfgOptions {
     fn extend<T: IntoIterator<Item = CfgFlag>>(&mut self, iter: T) {
         for cfg_flag in iter {
diff --git a/crates/project-model/src/project_json.rs b/crates/project-model/src/project_json.rs
index 4b2448e47f1..0f779e5307e 100644
--- a/crates/project-model/src/project_json.rs
+++ b/crates/project-model/src/project_json.rs
@@ -54,7 +54,7 @@ use std::path::PathBuf;
 use base_db::{CrateDisplayName, CrateId, CrateName, Dependency, Edition};
 use paths::{AbsPath, AbsPathBuf};
 use rustc_hash::FxHashMap;
-use serde::{de, Deserialize};
+use serde::{de, ser, Deserialize, Serialize};
 
 use crate::cfg_flag::CfgFlag;
 
@@ -171,14 +171,14 @@ impl ProjectJson {
     }
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ProjectJsonData {
     sysroot: Option<PathBuf>,
     sysroot_src: Option<PathBuf>,
     crates: Vec<CrateData>,
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 struct CrateData {
     display_name: Option<String>,
     root_module: PathBuf,
@@ -200,7 +200,7 @@ struct CrateData {
     repository: Option<String>,
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename = "edition")]
 enum EditionData {
     #[serde(rename = "2015")]
@@ -221,16 +221,16 @@ impl From<EditionData> for Edition {
     }
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 struct DepData {
     /// Identifies a crate by position in the crates array.
     #[serde(rename = "crate")]
     krate: usize,
-    #[serde(deserialize_with = "deserialize_crate_name")]
+    #[serde(deserialize_with = "deserialize_crate_name", serialize_with = "serialize_crate_name")]
     name: CrateName,
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 struct CrateSource {
     include_dirs: Vec<PathBuf>,
     exclude_dirs: Vec<PathBuf>,
@@ -243,3 +243,10 @@ where
     let name = String::deserialize(de)?;
     CrateName::new(&name).map_err(|err| de::Error::custom(format!("invalid crate name: {err:?}")))
 }
+
+fn serialize_crate_name<S>(crate_name: &CrateName, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: ser::Serializer,
+{
+    crate_name.serialize(serializer)
+}
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 75233dbb2ab..05ad7ab4c4a 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -272,7 +272,6 @@ config_data! {
         /// The warnings will be indicated by a blue squiggly underline in code
         /// and a blue icon in the `Problems Panel`.
         diagnostics_warningsAsInfo: Vec<String> = "[]",
-
         /// These directories will be ignored by rust-analyzer. They are
         /// relative to the workspace root, and globs are not supported. You may
         /// also need to add the folders to Code's `files.watcherExclude`.
@@ -895,6 +894,15 @@ impl Config {
         }
     }
 
+    pub fn add_linked_projects(&mut self, linked_projects: Vec<ProjectJsonData>) {
+        let mut linked_projects = linked_projects
+            .into_iter()
+            .map(ManifestOrProjectJson::ProjectJson)
+            .collect::<Vec<ManifestOrProjectJson>>();
+
+        self.data.linkedProjects.append(&mut linked_projects);
+    }
+
     pub fn did_save_text_document_dynamic_registration(&self) -> bool {
         let caps = try_or_def!(self.caps.text_document.as_ref()?.synchronization.clone()?);
         caps.did_save == Some(true) && caps.dynamic_registration == Some(true)
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 32ac9a42dec..c38addd5987 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -5,6 +5,7 @@
 use std::{
     io::Write as _,
     process::{self, Stdio},
+    sync::Arc,
 };
 
 use anyhow::Context;
@@ -46,6 +47,22 @@ use crate::{
 pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> Result<()> {
     state.proc_macro_clients.clear();
     state.proc_macro_changed = false;
+
+    state.fetch_workspaces_queue.request_op("reload workspace request".to_string());
+    state.fetch_build_data_queue.request_op("reload workspace request".to_string());
+    Ok(())
+}
+
+pub(crate) fn handle_add_project(
+    state: &mut GlobalState,
+    params: lsp_ext::AddProjectParams,
+) -> Result<()> {
+    state.proc_macro_clients.clear();
+    state.proc_macro_changed = false;
+
+    let config = Arc::make_mut(&mut state.config);
+    config.add_linked_projects(params.project);
+
     state.fetch_workspaces_queue.request_op("reload workspace request".to_string());
     state.fetch_build_data_queue.request_op("reload workspace request".to_string());
     Ok(())
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index c7b513db981..e6caebe3537 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -9,6 +9,7 @@ use lsp_types::{
     notification::Notification, CodeActionKind, DocumentOnTypeFormattingParams,
     PartialResultParams, Position, Range, TextDocumentIdentifier, WorkDoneProgressParams,
 };
+use project_model::ProjectJsonData;
 use serde::{Deserialize, Serialize};
 
 use crate::line_index::PositionEncoding;
@@ -51,6 +52,20 @@ impl Request for ReloadWorkspace {
     const METHOD: &'static str = "rust-analyzer/reloadWorkspace";
 }
 
+pub enum AddProject {}
+
+impl Request for AddProject {
+    type Params = AddProjectParams;
+    type Result = ();
+    const METHOD: &'static str = "rust-analyzer/addProject";
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct AddProjectParams {
+    pub project: Vec<ProjectJsonData>,
+}
+
 pub enum SyntaxTree {}
 
 impl Request for SyntaxTree {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index dd0804b4398..1cc771552a9 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -625,6 +625,7 @@ impl GlobalState {
             .on_sync_mut::<lsp_ext::ReloadWorkspace>(handlers::handle_workspace_reload)
             .on_sync_mut::<lsp_ext::MemoryUsage>(handlers::handle_memory_usage)
             .on_sync_mut::<lsp_ext::ShuffleCrateGraph>(handlers::handle_shuffle_crate_graph)
+            .on_sync_mut::<lsp_ext::AddProject>(handlers::handle_add_project)
             .on_sync::<lsp_ext::JoinLines>(handlers::handle_join_lines)
             .on_sync::<lsp_ext::OnEnter>(handlers::handle_on_enter)
             .on_sync::<lsp_types::request::SelectionRangeRequest>(handlers::handle_selection_range)
diff --git a/editors/code/package.json b/editors/code/package.json
index a3b1a3107d0..e79ab33726d 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -199,6 +199,11 @@
                 "title": "Reload workspace",
                 "category": "rust-analyzer"
             },
+            {
+                "command": "rust-analyzer.addProject",
+                "title": "Add current file to workspace",
+                "category": "rust-analyzer"
+            },
             {
                 "command": "rust-analyzer.reload",
                 "title": "Restart server",
@@ -447,6 +452,17 @@
                         "Fill missing expressions with reasonable defaults, `new` or `default` constructors."
                     ]
                 },
+                "rust-analyzer.discoverProjectCommand": {
+                    "markdownDescription": "Sets the command that rust-analyzer uses to generate `rust-project.json` files. This command is\n only suggested if a build system like Buck or Bazel is used. The command must accept files as arguements and return \n a rust-project.json over stdout.",
+                    "default": null,
+                    "type": [
+                        "null",
+                        "array"
+                    ],
+                    "items": {
+                        "type": "string"
+                    }
+                },
                 "rust-analyzer.cachePriming.enable": {
                     "markdownDescription": "Warm up caches on project load.",
                     "default": true,
@@ -1904,4 +1920,4 @@
             }
         ]
     }
-}
+}
\ No newline at end of file
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index f4a4579a92c..beff8501dc8 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -3,7 +3,7 @@ import * as lc from "vscode-languageclient";
 import * as ra from "./lsp_ext";
 import * as path from "path";
 
-import { Ctx, Cmd, CtxInit } from "./ctx";
+import { Ctx, Cmd, CtxInit, discoverWorkspace } from "./ctx";
 import { applySnippetWorkspaceEdit, applySnippetTextEdits } from "./snippets";
 import { spawnSync } from "child_process";
 import { RunnableQuickPick, selectRunnable, createTask, createArgs } from "./run";
@@ -749,6 +749,23 @@ export function reloadWorkspace(ctx: CtxInit): Cmd {
     return async () => ctx.client.sendRequest(ra.reloadWorkspace);
 }
 
+export function addProject(ctx: CtxInit): Cmd {
+    return async () => {
+        const discoverProjectCommand = ctx.config.discoverProjectCommand;
+        if (!discoverProjectCommand) {
+            return;
+        }
+
+        let workspaces: JsonProject[] = await Promise.all(vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
+            return discoverWorkspace(vscode.workspace.textDocuments, discoverProjectCommand, { cwd: folder.uri.fsPath });
+        }));
+
+        await ctx.client.sendRequest(ra.addProject, {
+            project: workspaces
+        });
+    }
+}
+
 async function showReferencesImpl(
     client: LanguageClient | undefined,
     uri: string,
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 1faa0ad9106..f62843dffa6 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -214,6 +214,10 @@ export class Config {
         return this.get<boolean>("trace.extension");
     }
 
+    get discoverProjectCommand() {
+        return this.get<string[] | undefined>("discoverProjectCommand")
+    }
+
     get cargoRunner() {
         return this.get<string | undefined>("cargoRunner");
     }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 1708d47cee7..ba2d4e97af1 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -4,10 +4,11 @@ import * as ra from "./lsp_ext";
 
 import { Config, substituteVSCodeVariables } from "./config";
 import { createClient } from "./client";
-import { isRustDocument, isRustEditor, LazyOutputChannel, log, RustEditor } from "./util";
+import { executeDiscoverProject, isRustDocument, isRustEditor, LazyOutputChannel, log, RustEditor } from "./util";
 import { ServerStatusParams } from "./lsp_ext";
 import { PersistentState } from "./persistent_state";
 import { bootstrap } from "./bootstrap";
+import { ExecOptions } from "child_process";
 
 // We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
 // only those are in use. We use "Empty" to represent these scenarios
@@ -16,12 +17,12 @@ import { bootstrap } from "./bootstrap";
 export type Workspace =
     | { kind: "Empty" }
     | {
-          kind: "Workspace Folder";
-      }
+        kind: "Workspace Folder";
+    }
     | {
-          kind: "Detached Files";
-          files: vscode.TextDocument[];
-      };
+        kind: "Detached Files";
+        files: vscode.TextDocument[];
+    };
 
 export function fetchWorkspace(): Workspace {
     const folders = (vscode.workspace.workspaceFolders || []).filter(
@@ -35,12 +36,19 @@ export function fetchWorkspace(): Workspace {
         ? rustDocuments.length === 0
             ? { kind: "Empty" }
             : {
-                  kind: "Detached Files",
-                  files: rustDocuments,
-              }
+                kind: "Detached Files",
+                files: rustDocuments,
+            }
         : { kind: "Workspace Folder" };
 }
 
+export async function discoverWorkspace(files: readonly vscode.TextDocument[], command: string[], options: ExecOptions): Promise<JsonProject> {
+    const paths = files.map((f) => f.uri.fsPath).join(" ");
+    const joinedCommand = command.join(" ");
+    const data = await executeDiscoverProject(`${joinedCommand} -- ${paths}`, options);
+    return JSON.parse(data) as JsonProject;
+}
+
 export type CommandFactory = {
     enabled: (ctx: CtxInit) => Cmd;
     disabled?: (ctx: Ctx) => Cmd;
@@ -63,6 +71,7 @@ export class Ctx {
     private state: PersistentState;
     private commandFactories: Record<string, CommandFactory>;
     private commandDisposables: Disposable[];
+    private discoveredWorkspaces: JsonProject[] | undefined;
 
     get client() {
         return this._client;
@@ -71,7 +80,7 @@ export class Ctx {
     constructor(
         readonly extCtx: vscode.ExtensionContext,
         commandFactories: Record<string, CommandFactory>,
-        workspace: Workspace
+        workspace: Workspace,
     ) {
         extCtx.subscriptions.push(this);
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
@@ -169,7 +178,18 @@ export class Ctx {
                 };
             }
 
-            const initializationOptions = substituteVSCodeVariables(rawInitializationOptions);
+            const discoverProjectCommand = this.config.discoverProjectCommand;
+            if (discoverProjectCommand) {
+                let workspaces: JsonProject[] = await Promise.all(vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
+                    return discoverWorkspace(vscode.workspace.textDocuments, discoverProjectCommand, { cwd: folder.uri.fsPath });
+                }));
+
+                this.discoveredWorkspaces = workspaces;
+            }
+
+            let initializationOptions = substituteVSCodeVariables(rawInitializationOptions);
+            // this appears to be load-bearing, for better or worse.
+            await initializationOptions.update('linkedProjects', this.discoveredWorkspaces)
 
             this._client = await createClient(
                 this.traceOutputChannel,
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 400cd207d41..6c8428aa972 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -43,6 +43,10 @@ export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, Te
     "rust-analyzer/relatedTests"
 );
 export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");
+export const addProject = new lc.RequestType<AddProjectParams, string, void>(
+    "rust-analyzer/addProject"
+)
+
 export const runFlycheck = new lc.NotificationType<{
     textDocument: lc.TextDocumentIdentifier | null;
 }>("rust-analyzer/runFlycheck");
@@ -68,6 +72,8 @@ export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>
 
 export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };
 
+export type AddProjectParams = { project: JsonProject[] };
+
 export type ExpandMacroParams = {
     textDocument: lc.TextDocumentIdentifier;
     position: lc.Position;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 8a2412af849..323aa89ef06 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -24,11 +24,11 @@ export async function activate(
         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);
     }
 
     const ctx = new Ctx(context, createCommands(), fetchWorkspace());
@@ -146,13 +146,14 @@ function createCommands(): Record<string, CommandFactory> {
                     health: "stopped",
                 });
             },
-            disabled: (_) => async () => {},
+            disabled: (_) => async () => { },
         },
 
         analyzerStatus: { enabled: commands.analyzerStatus },
         memoryUsage: { enabled: commands.memoryUsage },
         shuffleCrateGraph: { enabled: commands.shuffleCrateGraph },
         reloadWorkspace: { enabled: commands.reloadWorkspace },
+        addProject: { enabled: commands.addProject },
         matchingBrace: { enabled: commands.matchingBrace },
         joinLines: { enabled: commands.joinLines },
         parentModule: { enabled: commands.parentModule },
diff --git a/editors/code/src/rust_project.ts b/editors/code/src/rust_project.ts
new file mode 100644
index 00000000000..adf0f89c961
--- /dev/null
+++ b/editors/code/src/rust_project.ts
@@ -0,0 +1,91 @@
+interface JsonProject {
+    /// Path to the directory with *source code* of
+    /// sysroot crates.
+    ///
+    /// It should point to the directory where std,
+    /// core, and friends can be found:
+    ///
+    /// https://github.com/rust-lang/rust/tree/master/library.
+    ///
+    /// If provided, rust-analyzer automatically adds
+    /// dependencies on sysroot crates. Conversely,
+    /// if you omit this path, you can specify sysroot
+    /// dependencies yourself and, for example, have
+    /// several different "sysroots" in one graph of
+    /// crates.
+    sysroot_src?: string;
+    /// The set of crates comprising the current
+    /// project. Must include all transitive
+    /// dependencies as well as sysroot crate (libstd,
+    /// libcore and such).
+    crates: Crate[];
+}
+
+interface Crate {
+    /// Optional crate name used for display purposes,
+    /// without affecting semantics. See the `deps`
+    /// key for semantically-significant crate names.
+    display_name?: string;
+    /// Path to the root module of the crate.
+    root_module: string;
+    /// Edition of the crate.
+    edition: "2015" | "2018" | "2021";
+    /// Dependencies
+    deps: Dep[];
+    /// Should this crate be treated as a member of
+    /// current "workspace".
+    ///
+    /// By default, inferred from the `root_module`
+    /// (members are the crates which reside inside
+    /// the directory opened in the editor).
+    ///
+    /// Set this to `false` for things like standard
+    /// library and 3rd party crates to enable
+    /// performance optimizations (rust-analyzer
+    /// assumes that non-member crates don't change).
+    is_workspace_member?: boolean;
+    /// Optionally specify the (super)set of `.rs`
+    /// files comprising this crate.
+    ///
+    /// By default, rust-analyzer assumes that only
+    /// files under `root_module.parent` can belong
+    /// to a crate. `include_dirs` are included
+    /// recursively, unless a subdirectory is in
+    /// `exclude_dirs`.
+    ///
+    /// Different crates can share the same `source`.
+    ///
+    /// If two crates share an `.rs` file in common,
+    /// they *must* have the same `source`.
+    /// rust-analyzer assumes that files from one
+    /// source can't refer to files in another source.
+    source?: {
+        include_dirs: string[],
+        exclude_dirs: string[],
+    },
+    /// The set of cfgs activated for a given crate, like
+    /// `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
+    cfg: string[];
+    /// Target triple for this Crate.
+    ///
+    /// Used when running `rustc --print cfg`
+    /// to get target-specific cfgs.
+    target?: string;
+    /// Environment variables, used for
+    /// the `env!` macro
+    env: { [key: string]: string; },
+
+    /// Whether the crate is a proc-macro crate.
+    is_proc_macro: boolean;
+    /// For proc-macro crates, path to compiled
+    /// proc-macro (.so file).
+    proc_macro_dylib_path?: string;
+}
+
+interface Dep {
+    /// Index of a crate in the `crates` array.
+    crate: number,
+    /// Name as should appear in the (implicit)
+    /// `extern crate name` declaration.
+    name: string,
+}
\ No newline at end of file
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index d93b9caeb16..d2ecdce5b4e 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -150,9 +150,11 @@ export function memoizeAsync<Ret, TThis, Param extends string>(
 
 /** Awaitable wrapper around `child_process.exec` */
 export function execute(command: string, options: ExecOptions): Promise<string> {
+    log.info(`running command: ${command}`)
     return new Promise((resolve, reject) => {
         exec(command, options, (err, stdout, stderr) => {
             if (err) {
+                log.error(err);
                 reject(err);
                 return;
             }
@@ -167,6 +169,21 @@ export function execute(command: string, options: ExecOptions): Promise<string>
     });
 }
 
+export function executeDiscoverProject(command: string, options: ExecOptions): Promise<string> {
+    log.info(`running command: ${command}`)
+    return new Promise((resolve, reject) => {
+        exec(command, options, (err, stdout, _) => {
+            if (err) {
+                log.error(err);
+                reject(err);
+                return;
+            }
+
+            resolve(stdout.trimEnd());
+        });
+    });
+}
+
 export class LazyOutputChannel implements vscode.OutputChannel {
     constructor(name: string) {
         this.name = name;
-- 
cgit 1.4.1-3-g733a5


From 46e022098feda31c98120ca58b6ce02b45cdedf9 Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Thu, 9 Mar 2023 15:27:24 -0500
Subject: fmt

---
 editors/code/package.json        |  2 +-
 editors/code/src/commands.ts     | 14 ++++++++----
 editors/code/src/config.ts       |  2 +-
 editors/code/src/ctx.ts          | 49 +++++++++++++++++++++++++++-------------
 editors/code/src/lsp_ext.ts      |  2 +-
 editors/code/src/main.ts         |  8 +++----
 editors/code/src/rust_project.ts | 14 ++++++------
 editors/code/src/util.ts         |  4 ++--
 8 files changed, 58 insertions(+), 37 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index e79ab33726d..0a3e4103f6e 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -1920,4 +1920,4 @@
             }
         ]
     }
-}
\ No newline at end of file
+}
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index beff8501dc8..a8ec75a78aa 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -756,14 +756,18 @@ export function addProject(ctx: CtxInit): Cmd {
             return;
         }
 
-        let workspaces: JsonProject[] = await Promise.all(vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
-            return discoverWorkspace(vscode.workspace.textDocuments, discoverProjectCommand, { cwd: folder.uri.fsPath });
-        }));
+        const workspaces: JsonProject[] = await Promise.all(
+            vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
+                return discoverWorkspace(vscode.workspace.textDocuments, discoverProjectCommand, {
+                    cwd: folder.uri.fsPath,
+                });
+            })
+        );
 
         await ctx.client.sendRequest(ra.addProject, {
-            project: workspaces
+            project: workspaces,
         });
-    }
+    };
 }
 
 async function showReferencesImpl(
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index f62843dffa6..1dae603714d 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -215,7 +215,7 @@ export class Config {
     }
 
     get discoverProjectCommand() {
-        return this.get<string[] | undefined>("discoverProjectCommand")
+        return this.get<string[] | undefined>("discoverProjectCommand");
     }
 
     get cargoRunner() {
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index ba2d4e97af1..5b019d6aeb5 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -4,7 +4,14 @@ import * as ra from "./lsp_ext";
 
 import { Config, substituteVSCodeVariables } from "./config";
 import { createClient } from "./client";
-import { executeDiscoverProject, isRustDocument, isRustEditor, LazyOutputChannel, log, RustEditor } from "./util";
+import {
+    executeDiscoverProject,
+    isRustDocument,
+    isRustEditor,
+    LazyOutputChannel,
+    log,
+    RustEditor,
+} from "./util";
 import { ServerStatusParams } from "./lsp_ext";
 import { PersistentState } from "./persistent_state";
 import { bootstrap } from "./bootstrap";
@@ -17,12 +24,12 @@ import { ExecOptions } from "child_process";
 export type Workspace =
     | { kind: "Empty" }
     | {
-        kind: "Workspace Folder";
-    }
+          kind: "Workspace Folder";
+      }
     | {
-        kind: "Detached Files";
-        files: vscode.TextDocument[];
-    };
+          kind: "Detached Files";
+          files: vscode.TextDocument[];
+      };
 
 export function fetchWorkspace(): Workspace {
     const folders = (vscode.workspace.workspaceFolders || []).filter(
@@ -36,13 +43,17 @@ export function fetchWorkspace(): Workspace {
         ? rustDocuments.length === 0
             ? { kind: "Empty" }
             : {
-                kind: "Detached Files",
-                files: rustDocuments,
-            }
+                  kind: "Detached Files",
+                  files: rustDocuments,
+              }
         : { kind: "Workspace Folder" };
 }
 
-export async function discoverWorkspace(files: readonly vscode.TextDocument[], command: string[], options: ExecOptions): Promise<JsonProject> {
+export async function discoverWorkspace(
+    files: readonly vscode.TextDocument[],
+    command: string[],
+    options: ExecOptions
+): Promise<JsonProject> {
     const paths = files.map((f) => f.uri.fsPath).join(" ");
     const joinedCommand = command.join(" ");
     const data = await executeDiscoverProject(`${joinedCommand} -- ${paths}`, options);
@@ -80,7 +91,7 @@ export class Ctx {
     constructor(
         readonly extCtx: vscode.ExtensionContext,
         commandFactories: Record<string, CommandFactory>,
-        workspace: Workspace,
+        workspace: Workspace
     ) {
         extCtx.subscriptions.push(this);
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
@@ -180,16 +191,22 @@ export class Ctx {
 
             const discoverProjectCommand = this.config.discoverProjectCommand;
             if (discoverProjectCommand) {
-                let workspaces: JsonProject[] = await Promise.all(vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
-                    return discoverWorkspace(vscode.workspace.textDocuments, discoverProjectCommand, { cwd: folder.uri.fsPath });
-                }));
+                const workspaces: JsonProject[] = await Promise.all(
+                    vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
+                        return discoverWorkspace(
+                            vscode.workspace.textDocuments,
+                            discoverProjectCommand,
+                            { cwd: folder.uri.fsPath }
+                        );
+                    })
+                );
 
                 this.discoveredWorkspaces = workspaces;
             }
 
-            let initializationOptions = substituteVSCodeVariables(rawInitializationOptions);
+            const initializationOptions = substituteVSCodeVariables(rawInitializationOptions);
             // this appears to be load-bearing, for better or worse.
-            await initializationOptions.update('linkedProjects', this.discoveredWorkspaces)
+            await initializationOptions.update("linkedProjects", this.discoveredWorkspaces);
 
             this._client = await createClient(
                 this.traceOutputChannel,
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 6c8428aa972..942573c0f16 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -45,7 +45,7 @@ export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, Te
 export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");
 export const addProject = new lc.RequestType<AddProjectParams, string, void>(
     "rust-analyzer/addProject"
-)
+);
 
 export const runFlycheck = new lc.NotificationType<{
     textDocument: lc.TextDocumentIdentifier | null;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 323aa89ef06..d5de00561b1 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -24,11 +24,11 @@ export async function activate(
         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);
     }
 
     const ctx = new Ctx(context, createCommands(), fetchWorkspace());
@@ -146,7 +146,7 @@ function createCommands(): Record<string, CommandFactory> {
                     health: "stopped",
                 });
             },
-            disabled: (_) => async () => { },
+            disabled: (_) => async () => {},
         },
 
         analyzerStatus: { enabled: commands.analyzerStatus },
diff --git a/editors/code/src/rust_project.ts b/editors/code/src/rust_project.ts
index adf0f89c961..187a1a96c10 100644
--- a/editors/code/src/rust_project.ts
+++ b/editors/code/src/rust_project.ts
@@ -60,9 +60,9 @@ interface Crate {
     /// rust-analyzer assumes that files from one
     /// source can't refer to files in another source.
     source?: {
-        include_dirs: string[],
-        exclude_dirs: string[],
-    },
+        include_dirs: string[];
+        exclude_dirs: string[];
+    };
     /// The set of cfgs activated for a given crate, like
     /// `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
     cfg: string[];
@@ -73,7 +73,7 @@ interface Crate {
     target?: string;
     /// Environment variables, used for
     /// the `env!` macro
-    env: { [key: string]: string; },
+    env: { [key: string]: string };
 
     /// Whether the crate is a proc-macro crate.
     is_proc_macro: boolean;
@@ -84,8 +84,8 @@ interface Crate {
 
 interface Dep {
     /// Index of a crate in the `crates` array.
-    crate: number,
+    crate: number;
     /// Name as should appear in the (implicit)
     /// `extern crate name` declaration.
-    name: string,
-}
\ No newline at end of file
+    name: string;
+}
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index d2ecdce5b4e..922fbcbcf35 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -150,7 +150,7 @@ export function memoizeAsync<Ret, TThis, Param extends string>(
 
 /** Awaitable wrapper around `child_process.exec` */
 export function execute(command: string, options: ExecOptions): Promise<string> {
-    log.info(`running command: ${command}`)
+    log.info(`running command: ${command}`);
     return new Promise((resolve, reject) => {
         exec(command, options, (err, stdout, stderr) => {
             if (err) {
@@ -170,7 +170,7 @@ export function execute(command: string, options: ExecOptions): Promise<string>
 }
 
 export function executeDiscoverProject(command: string, options: ExecOptions): Promise<string> {
-    log.info(`running command: ${command}`)
+    log.info(`running command: ${command}`);
     return new Promise((resolve, reject) => {
         exec(command, options, (err, stdout, _) => {
             if (err) {
-- 
cgit 1.4.1-3-g733a5


From 1f5c5350898dc18961a810e73d9ef5f80eaf3ae5 Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Thu, 9 Mar 2023 15:47:12 -0500
Subject: remove errant `--` in `executeDiscoverProject`

---
 editors/code/src/ctx.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 5b019d6aeb5..407d976bab9 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -56,7 +56,7 @@ export async function discoverWorkspace(
 ): Promise<JsonProject> {
     const paths = files.map((f) => f.uri.fsPath).join(" ");
     const joinedCommand = command.join(" ");
-    const data = await executeDiscoverProject(`${joinedCommand} -- ${paths}`, options);
+    const data = await executeDiscoverProject(`${joinedCommand} ${paths}`, options);
     return JSON.parse(data) as JsonProject;
 }
 
-- 
cgit 1.4.1-3-g733a5


From 8d9bff0c74518d514d59a1638e4717f14caa1d71 Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Fri, 10 Mar 2023 19:35:05 -0500
Subject: Add a workspace config-based approach to reloading discovered
 projects.

---
 editors/code/src/client.ts   |  8 +++++---
 editors/code/src/commands.ts | 12 +++++++++---
 editors/code/src/config.ts   | 17 +++++++++++++----
 editors/code/src/ctx.ts      | 40 +++++++++++++++++++++++++++-------------
 4 files changed, 54 insertions(+), 23 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 62980ca0464..9103ef2f8fd 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -3,10 +3,10 @@ import * as lc from "vscode-languageclient/node";
 import * as vscode from "vscode";
 import * as ra from "../src/lsp_ext";
 import * as Is from "vscode-languageclient/lib/common/utils/is";
-import { assert } from "./util";
+import { assert, log } from "./util";
 import * as diagnostics from "./diagnostics";
 import { WorkspaceEdit } from "vscode";
-import { Config, substituteVSCodeVariables } from "./config";
+import { Config, prepareVSCodeConfig } from "./config";
 import { randomUUID } from "crypto";
 
 export interface Env {
@@ -95,7 +95,9 @@ export async function createClient(
                     const resp = await next(params, token);
                     if (resp && Array.isArray(resp)) {
                         return resp.map((val) => {
-                            return substituteVSCodeVariables(val);
+                            return prepareVSCodeConfig(val, (key, cfg) => {
+                                cfg[key] = config.discoveredWorkspaces;
+                            });
                         });
                     } else {
                         return resp;
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index a8ec75a78aa..8a953577e99 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -758,14 +758,20 @@ export function addProject(ctx: CtxInit): Cmd {
 
         const workspaces: JsonProject[] = await Promise.all(
             vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
-                return discoverWorkspace(vscode.workspace.textDocuments, discoverProjectCommand, {
+                const rustDocuments = vscode.workspace.textDocuments.filter(isRustDocument);
+                return discoverWorkspace(rustDocuments, discoverProjectCommand, {
                     cwd: folder.uri.fsPath,
                 });
             })
         );
 
-        await ctx.client.sendRequest(ra.addProject, {
-            project: workspaces,
+        ctx.addToDiscoveredWorkspaces(workspaces);
+
+        // this is a workaround to avoid needing writing the `rust-project.json` into
+        // a workspace-level VS Code-specific settings folder. We'd like to keep the
+        // `rust-project.json` entirely in-memory.
+        await ctx.client?.sendNotification(lc.DidChangeConfigurationNotification.type, {
+            settings: "",
         });
     };
 }
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 1dae603714d..75403725479 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -34,6 +34,7 @@ export class Config {
 
     constructor(ctx: vscode.ExtensionContext) {
         this.globalStorageUri = ctx.globalStorageUri;
+        this.discoveredWorkspaces = [];
         vscode.workspace.onDidChangeConfiguration(
             this.onDidChangeConfiguration,
             this,
@@ -55,6 +56,8 @@ export class Config {
         log.info("Using configuration", Object.fromEntries(cfg));
     }
 
+    public discoveredWorkspaces: JsonProject[];
+
     private async onDidChangeConfiguration(event: vscode.ConfigurationChangeEvent) {
         this.refreshLogging();
 
@@ -191,7 +194,7 @@ export class Config {
      * So this getter handles this quirk by not requiring the caller to use postfix `!`
      */
     private get<T>(path: string): T | undefined {
-        return substituteVSCodeVariables(this.cfg.get<T>(path));
+        return prepareVSCodeConfig(this.cfg.get<T>(path));
     }
 
     get serverPath() {
@@ -284,18 +287,24 @@ export class Config {
     }
 }
 
-export function substituteVSCodeVariables<T>(resp: T): T {
+export function prepareVSCodeConfig<T>(
+    resp: T,
+    cb?: (key: Extract<keyof T, string>, res: { [key: string]: any }) => void
+): T {
     if (Is.string(resp)) {
         return substituteVSCodeVariableInString(resp) as T;
     } else if (resp && Is.array<any>(resp)) {
         return resp.map((val) => {
-            return substituteVSCodeVariables(val);
+            return prepareVSCodeConfig(val);
         }) as T;
     } else if (resp && typeof resp === "object") {
         const res: { [key: string]: any } = {};
         for (const key in resp) {
             const val = resp[key];
-            res[key] = substituteVSCodeVariables(val);
+            res[key] = prepareVSCodeConfig(val);
+            if (cb) {
+                cb(key, res);
+            }
         }
         return res as T;
     }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 407d976bab9..ca30d239c95 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -2,7 +2,7 @@ import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 
-import { Config, substituteVSCodeVariables } from "./config";
+import { Config, prepareVSCodeConfig } from "./config";
 import { createClient } from "./client";
 import {
     executeDiscoverProject,
@@ -54,7 +54,7 @@ export async function discoverWorkspace(
     command: string[],
     options: ExecOptions
 ): Promise<JsonProject> {
-    const paths = files.map((f) => f.uri.fsPath).join(" ");
+    const paths = files.map((f) => `"${f.uri.fsPath}"`).join(" ");
     const joinedCommand = command.join(" ");
     const data = await executeDiscoverProject(`${joinedCommand} ${paths}`, options);
     return JSON.parse(data) as JsonProject;
@@ -71,7 +71,7 @@ export type CtxInit = Ctx & {
 
 export class Ctx {
     readonly statusBar: vscode.StatusBarItem;
-    readonly config: Config;
+    config: Config;
     readonly workspace: Workspace;
 
     private _client: lc.LanguageClient | undefined;
@@ -82,7 +82,6 @@ export class Ctx {
     private state: PersistentState;
     private commandFactories: Record<string, CommandFactory>;
     private commandDisposables: Disposable[];
-    private discoveredWorkspaces: JsonProject[] | undefined;
 
     get client() {
         return this._client;
@@ -193,20 +192,24 @@ export class Ctx {
             if (discoverProjectCommand) {
                 const workspaces: JsonProject[] = await Promise.all(
                     vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
-                        return discoverWorkspace(
-                            vscode.workspace.textDocuments,
-                            discoverProjectCommand,
-                            { cwd: folder.uri.fsPath }
-                        );
+                        const rustDocuments = vscode.workspace.textDocuments.filter(isRustDocument);
+                        return discoverWorkspace(rustDocuments, discoverProjectCommand, {
+                            cwd: folder.uri.fsPath,
+                        });
                     })
                 );
 
-                this.discoveredWorkspaces = workspaces;
+                this.addToDiscoveredWorkspaces(workspaces);
             }
 
-            const initializationOptions = substituteVSCodeVariables(rawInitializationOptions);
-            // this appears to be load-bearing, for better or worse.
-            await initializationOptions.update("linkedProjects", this.discoveredWorkspaces);
+            const initializationOptions = prepareVSCodeConfig(
+                rawInitializationOptions,
+                (key, obj) => {
+                    if (key === "linkedProjects") {
+                        obj["linkedProjects"] = this.config.discoveredWorkspaces;
+                    }
+                }
+            );
 
             this._client = await createClient(
                 this.traceOutputChannel,
@@ -288,6 +291,17 @@ export class Ctx {
         return this._serverPath;
     }
 
+    addToDiscoveredWorkspaces(workspaces: JsonProject[]) {
+        for (const workspace of workspaces) {
+            const index = this.config.discoveredWorkspaces.indexOf(workspace);
+            if (~index) {
+                this.config.discoveredWorkspaces[index] = workspace;
+            } else {
+                this.config.discoveredWorkspaces.push(workspace);
+            }
+        }
+    }
+
     private updateCommands(forceDisable?: "disable") {
         this.commandDisposables.forEach((disposable) => disposable.dispose());
         this.commandDisposables = [];
-- 
cgit 1.4.1-3-g733a5


From 56273b3cf5f480997c18d4edbe2e809e14cfd5c4 Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Mon, 13 Mar 2023 13:17:17 -0400
Subject: Remove `rust-analyzer/addProject` in favor of notifying r-a that
 configuration has changed

---
 crates/project-model/src/cfg_flag.rs     | 13 -------------
 crates/project-model/src/project_json.rs | 21 +++++++--------------
 crates/rust-analyzer/src/handlers.rs     | 16 ----------------
 crates/rust-analyzer/src/lsp_ext.rs      | 15 ---------------
 crates/rust-analyzer/src/main_loop.rs    |  1 -
 editors/code/src/client.ts               |  2 +-
 editors/code/src/lsp_ext.ts              |  5 -----
 7 files changed, 8 insertions(+), 65 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/project-model/src/cfg_flag.rs b/crates/project-model/src/cfg_flag.rs
index 2a4767970c0..c134b78ab3a 100644
--- a/crates/project-model/src/cfg_flag.rs
+++ b/crates/project-model/src/cfg_flag.rs
@@ -4,7 +4,6 @@
 use std::{fmt, str::FromStr};
 
 use cfg::CfgOptions;
-use serde::Serialize;
 
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub enum CfgFlag {
@@ -39,18 +38,6 @@ impl<'de> serde::Deserialize<'de> for CfgFlag {
     }
 }
 
-impl Serialize for CfgFlag {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match self {
-            CfgFlag::Atom(s) => serializer.serialize_str(s),
-            CfgFlag::KeyValue { .. } => serializer.serialize_str(&format!("{}", &self)),
-        }
-    }
-}
-
 impl Extend<CfgFlag> for CfgOptions {
     fn extend<T: IntoIterator<Item = CfgFlag>>(&mut self, iter: T) {
         for cfg_flag in iter {
diff --git a/crates/project-model/src/project_json.rs b/crates/project-model/src/project_json.rs
index 0f779e5307e..4b2448e47f1 100644
--- a/crates/project-model/src/project_json.rs
+++ b/crates/project-model/src/project_json.rs
@@ -54,7 +54,7 @@ use std::path::PathBuf;
 use base_db::{CrateDisplayName, CrateId, CrateName, Dependency, Edition};
 use paths::{AbsPath, AbsPathBuf};
 use rustc_hash::FxHashMap;
-use serde::{de, ser, Deserialize, Serialize};
+use serde::{de, Deserialize};
 
 use crate::cfg_flag::CfgFlag;
 
@@ -171,14 +171,14 @@ impl ProjectJson {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone)]
 pub struct ProjectJsonData {
     sysroot: Option<PathBuf>,
     sysroot_src: Option<PathBuf>,
     crates: Vec<CrateData>,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone)]
 struct CrateData {
     display_name: Option<String>,
     root_module: PathBuf,
@@ -200,7 +200,7 @@ struct CrateData {
     repository: Option<String>,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone)]
 #[serde(rename = "edition")]
 enum EditionData {
     #[serde(rename = "2015")]
@@ -221,16 +221,16 @@ impl From<EditionData> for Edition {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone)]
 struct DepData {
     /// Identifies a crate by position in the crates array.
     #[serde(rename = "crate")]
     krate: usize,
-    #[serde(deserialize_with = "deserialize_crate_name", serialize_with = "serialize_crate_name")]
+    #[serde(deserialize_with = "deserialize_crate_name")]
     name: CrateName,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone)]
 struct CrateSource {
     include_dirs: Vec<PathBuf>,
     exclude_dirs: Vec<PathBuf>,
@@ -243,10 +243,3 @@ where
     let name = String::deserialize(de)?;
     CrateName::new(&name).map_err(|err| de::Error::custom(format!("invalid crate name: {err:?}")))
 }
-
-fn serialize_crate_name<S>(crate_name: &CrateName, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: ser::Serializer,
-{
-    crate_name.serialize(serializer)
-}
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 4ac76557df1..d7fc8891324 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -5,7 +5,6 @@
 use std::{
     io::Write as _,
     process::{self, Stdio},
-    sync::Arc,
 };
 
 use anyhow::Context;
@@ -53,21 +52,6 @@ pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> Result<
     Ok(())
 }
 
-pub(crate) fn handle_add_project(
-    state: &mut GlobalState,
-    params: lsp_ext::AddProjectParams,
-) -> Result<()> {
-    state.proc_macro_clients.clear();
-    state.proc_macro_changed = false;
-
-    let config = Arc::make_mut(&mut state.config);
-    config.add_linked_projects(params.project);
-
-    state.fetch_workspaces_queue.request_op("linked projects changed".to_string());
-    state.fetch_build_data_queue.request_op("linked projects changed".to_string());
-    Ok(())
-}
-
 pub(crate) fn handle_cancel_flycheck(state: &mut GlobalState, _: ()) -> Result<()> {
     let _p = profile::span("handle_stop_flycheck");
     state.flycheck.iter().for_each(|flycheck| flycheck.cancel());
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index e6caebe3537..c7b513db981 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -9,7 +9,6 @@ use lsp_types::{
     notification::Notification, CodeActionKind, DocumentOnTypeFormattingParams,
     PartialResultParams, Position, Range, TextDocumentIdentifier, WorkDoneProgressParams,
 };
-use project_model::ProjectJsonData;
 use serde::{Deserialize, Serialize};
 
 use crate::line_index::PositionEncoding;
@@ -52,20 +51,6 @@ impl Request for ReloadWorkspace {
     const METHOD: &'static str = "rust-analyzer/reloadWorkspace";
 }
 
-pub enum AddProject {}
-
-impl Request for AddProject {
-    type Params = AddProjectParams;
-    type Result = ();
-    const METHOD: &'static str = "rust-analyzer/addProject";
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct AddProjectParams {
-    pub project: Vec<ProjectJsonData>,
-}
-
 pub enum SyntaxTree {}
 
 impl Request for SyntaxTree {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 1cc771552a9..dd0804b4398 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -625,7 +625,6 @@ impl GlobalState {
             .on_sync_mut::<lsp_ext::ReloadWorkspace>(handlers::handle_workspace_reload)
             .on_sync_mut::<lsp_ext::MemoryUsage>(handlers::handle_memory_usage)
             .on_sync_mut::<lsp_ext::ShuffleCrateGraph>(handlers::handle_shuffle_crate_graph)
-            .on_sync_mut::<lsp_ext::AddProject>(handlers::handle_add_project)
             .on_sync::<lsp_ext::JoinLines>(handlers::handle_join_lines)
             .on_sync::<lsp_ext::OnEnter>(handlers::handle_on_enter)
             .on_sync::<lsp_types::request::SelectionRangeRequest>(handlers::handle_selection_range)
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 9103ef2f8fd..03f5d430519 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -3,7 +3,7 @@ import * as lc from "vscode-languageclient/node";
 import * as vscode from "vscode";
 import * as ra from "../src/lsp_ext";
 import * as Is from "vscode-languageclient/lib/common/utils/is";
-import { assert, log } from "./util";
+import { assert } from "./util";
 import * as diagnostics from "./diagnostics";
 import { WorkspaceEdit } from "vscode";
 import { Config, prepareVSCodeConfig } from "./config";
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 942573c0f16..872d7199b83 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -43,9 +43,6 @@ export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, Te
     "rust-analyzer/relatedTests"
 );
 export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");
-export const addProject = new lc.RequestType<AddProjectParams, string, void>(
-    "rust-analyzer/addProject"
-);
 
 export const runFlycheck = new lc.NotificationType<{
     textDocument: lc.TextDocumentIdentifier | null;
@@ -72,8 +69,6 @@ export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>
 
 export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };
 
-export type AddProjectParams = { project: JsonProject[] };
-
 export type ExpandMacroParams = {
     textDocument: lc.TextDocumentIdentifier;
     position: lc.Position;
-- 
cgit 1.4.1-3-g733a5


From bd545a1c106484aa4960737c62450927e1bd8ac7 Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Tue, 14 Mar 2023 12:49:35 -0400
Subject: Address review comments

---
 editors/code/src/client.ts | 4 +++-
 editors/code/src/config.ts | 8 ++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 03f5d430519..9a576570beb 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -96,7 +96,9 @@ export async function createClient(
                     if (resp && Array.isArray(resp)) {
                         return resp.map((val) => {
                             return prepareVSCodeConfig(val, (key, cfg) => {
-                                cfg[key] = config.discoveredWorkspaces;
+                                if (key === "linkedProjects") {
+                                    cfg[key] = config.discoveredWorkspaces;
+                                }
                             });
                         });
                     } else {
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 75403725479..da7c74c28ba 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -287,6 +287,14 @@ export class Config {
     }
 }
 
+// the optional `cb?` parameter is meant to be used to add additional
+// key/value pairs to the VS Code configuration. This needed for, e.g.,
+// including a `rust-project.json` into the `linkedProjects` key as part
+// of the configuration/InitializationParams _without_ causing VS Code
+// configuration to be written out to workspace-level settings. This is
+// undesirable behavior because rust-project.json files can be tens of
+// thousands of lines of JSON, most of which is not meant for humans
+// to interact with.
 export function prepareVSCodeConfig<T>(
     resp: T,
     cb?: (key: Extract<keyof T, string>, res: { [key: string]: any }) => void
-- 
cgit 1.4.1-3-g733a5


From 6e7bc07cdf225aea811f793c2f712f25846b8d20 Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Tue, 14 Mar 2023 13:36:21 -0400
Subject: fix: don't override `linkedProjects` if no workspace was discovered.

---
 editors/code/src/client.ts | 7 ++++++-
 editors/code/src/ctx.ts    | 4 +++-
 2 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 9a576570beb..565cb9c6432 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -96,7 +96,12 @@ export async function createClient(
                     if (resp && Array.isArray(resp)) {
                         return resp.map((val) => {
                             return prepareVSCodeConfig(val, (key, cfg) => {
-                                if (key === "linkedProjects") {
+                                // we only want to set discovered workspaces on the right key
+                                // and if a workspace has been discovered.
+                                if (
+                                    key === "linkedProjects" &&
+                                    config.discoveredWorkspaces.length > 0
+                                ) {
                                     cfg[key] = config.discoveredWorkspaces;
                                 }
                             });
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index ca30d239c95..ffcfb810a24 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -205,7 +205,9 @@ export class Ctx {
             const initializationOptions = prepareVSCodeConfig(
                 rawInitializationOptions,
                 (key, obj) => {
-                    if (key === "linkedProjects") {
+                    // we only want to set discovered workspaces on the right key
+                    // and if a workspace has been discovered.
+                    if (key === "linkedProjects" && this.config.discoveredWorkspaces.length > 0) {
                         obj["linkedProjects"] = this.config.discoveredWorkspaces;
                     }
                 }
-- 
cgit 1.4.1-3-g733a5


From 66636939a63237fb7a6d1198dd9f92514807621e Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 16 Mar 2023 16:26:19 +0100
Subject: feat: Pop a notification prompting the user to add a Cargo.toml of
 unlinked file to the linkedProjects

---
 crates/ide-diagnostics/src/lib.rs        |  1 +
 crates/rust-analyzer/src/global_state.rs |  4 +-
 crates/rust-analyzer/src/reload.rs       |  3 +-
 editors/code/package.json                |  5 +++
 editors/code/src/client.ts               | 74 +++++++++++++++++++++++++++-----
 editors/code/src/ctx.ts                  |  5 ++-
 6 files changed, 78 insertions(+), 14 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/ide-diagnostics/src/lib.rs b/crates/ide-diagnostics/src/lib.rs
index 71f136b8c90..0dc5343f942 100644
--- a/crates/ide-diagnostics/src/lib.rs
+++ b/crates/ide-diagnostics/src/lib.rs
@@ -74,6 +74,7 @@ use ide_db::{
 };
 use syntax::{algo::find_node_at_range, ast::AstNode, SyntaxNodePtr, TextRange};
 
+// FIXME: Make this an enum
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub struct DiagnosticCode(pub &'static str);
 
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index aca6c923570..649f856db4f 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -331,7 +331,7 @@ impl GlobalState {
     }
 
     pub(crate) fn send_notification<N: lsp_types::notification::Notification>(
-        &mut self,
+        &self,
         params: N::Params,
     ) {
         let not = lsp_server::Notification::new(N::METHOD.to_string(), params);
@@ -372,7 +372,7 @@ impl GlobalState {
         self.req_queue.incoming.is_completed(&request.id)
     }
 
-    fn send(&mut self, message: lsp_server::Message) {
+    fn send(&self, message: lsp_server::Message) {
         self.sender.send(message).unwrap()
     }
 }
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index 1a6e1af2eb7..247d5b04380 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -112,7 +112,8 @@ impl GlobalState {
             && self.config.notifications().cargo_toml_not_found
         {
             status.health = lsp_ext::Health::Warning;
-            message.push_str("Failed to discover workspace.\n\n");
+            message.push_str("Failed to discover workspace.\n");
+            message.push_str("Consider adding the `Cargo.toml` of the workspace to the [`linkedProjects`](https://rust-analyzer.github.io/manual.html#rust-analyzer.linkedProjects) setting.\n\n");
         }
 
         for ws in self.workspaces.iter() {
diff --git a/editors/code/package.json b/editors/code/package.json
index c5eb08748bf..d0c77db7b87 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -444,6 +444,11 @@
                         "type": "string"
                     }
                 },
+                "rust-analyzer.showUnlinkedFileNotification": {
+                    "markdownDescription": "Whether to show a notification for unlinked files asking the user to add the corresponding Cargo.toml to the linked projects setting.",
+                    "default": true,
+                    "type": "boolean"
+                },
                 "$generated-start": {},
                 "rust-analyzer.assist.emitMustUse": {
                     "markdownDescription": "Whether to insert #[must_use] when generating `as_` methods\nfor enum variants.",
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 565cb9c6432..2a1c757dfef 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -8,6 +8,7 @@ import * as diagnostics from "./diagnostics";
 import { WorkspaceEdit } from "vscode";
 import { Config, prepareVSCodeConfig } from "./config";
 import { randomUUID } from "crypto";
+import { sep as pathSeparator } from "path";
 
 export interface Env {
     [name: string]: string;
@@ -69,7 +70,8 @@ export async function createClient(
     outputChannel: vscode.OutputChannel,
     initializationOptions: vscode.WorkspaceConfiguration,
     serverOptions: lc.ServerOptions,
-    config: Config
+    config: Config,
+    unlinkedFiles: vscode.Uri[]
 ): Promise<lc.LanguageClient> {
     const clientOptions: lc.LanguageClientOptions = {
         documentSelector: [{ scheme: "file", language: "rust" }],
@@ -119,6 +121,65 @@ export async function createClient(
                 const preview = config.previewRustcOutput;
                 const errorCode = config.useRustcErrorCode;
                 diagnosticList.forEach((diag, idx) => {
+                    let value =
+                        typeof diag.code === "string" || typeof diag.code === "number"
+                            ? diag.code
+                            : diag.code?.value;
+                    if (value === "unlinked-file" && !unlinkedFiles.includes(uri)) {
+                        let config = vscode.workspace.getConfiguration("rust-analyzer");
+                        if (config.get("showUnlinkedFileNotification")) {
+                            unlinkedFiles.push(uri);
+                            let folder = vscode.workspace.getWorkspaceFolder(uri)?.uri.fsPath;
+                            if (folder) {
+                                let parent_backslash = uri.fsPath.lastIndexOf(
+                                    pathSeparator + "src"
+                                );
+                                let parent = uri.fsPath.substring(0, parent_backslash);
+
+                                if (parent.startsWith(folder)) {
+                                    let path = vscode.Uri.file(
+                                        parent + pathSeparator + "Cargo.toml"
+                                    );
+                                    void vscode.workspace.fs.stat(path).then(() => {
+                                        vscode.window
+                                            .showInformationMessage(
+                                                `This rust file does not belong to a loaded cargo project. It looks like it might belong to the workspace at ${path}, do you want to add it to the linked Projects?`,
+                                                "Yes",
+                                                "No",
+                                                "Don't show this again"
+                                            )
+                                            .then((choice) => {
+                                                switch (choice) {
+                                                    case "Yes":
+                                                        break;
+                                                    case "No":
+                                                        config.update(
+                                                            "linkedProjects",
+                                                            config
+                                                                .get<any[]>("linkedProjects")
+                                                                ?.concat(
+                                                                    path.fsPath.substring(
+                                                                        folder!.length
+                                                                    )
+                                                                ),
+                                                            false
+                                                        );
+                                                        break;
+                                                    case "Don't show this again":
+                                                        config.update(
+                                                            "showUnlinkedFileNotification",
+                                                            false,
+                                                            false
+                                                        );
+                                                        break;
+                                                }
+                                            });
+                                    });
+                                }
+                            }
+                        }
+                    }
+
                     // Abuse the fact that VSCode leaks the LSP diagnostics data field through the
                     // Diagnostic class, if they ever break this we are out of luck and have to go
                     // back to the worst diagnostics experience ever:)
@@ -138,14 +199,6 @@ export async function createClient(
                                 .substring(0, index)
                                 .replace(/^ -->[^\n]+\n/m, "");
                         }
-                        let value;
-                        if (errorCode) {
-                            if (typeof diag.code === "string" || typeof diag.code === "number") {
-                                value = diag.code;
-                            } else {
-                                value = diag.code?.value;
-                            }
-                        }
                         diag.code = {
                             target: vscode.Uri.from({
                                 scheme: diagnostics.URI_SCHEME,
@@ -153,7 +206,8 @@ export async function createClient(
                                 fragment: uri.toString(),
                                 query: idx.toString(),
                             }),
-                            value: value ?? "Click for full compiler diagnostic",
+                            value:
+                                errorCode && value ? value : "Click for full compiler diagnostic",
                         };
                     }
                 });
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index c2dca733df8..5515921ed14 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -82,6 +82,7 @@ export class Ctx {
     private state: PersistentState;
     private commandFactories: Record<string, CommandFactory>;
     private commandDisposables: Disposable[];
+    private unlinkedFiles: vscode.Uri[];
 
     get client() {
         return this._client;
@@ -99,6 +100,7 @@ export class Ctx {
         this.clientSubscriptions = [];
         this.commandDisposables = [];
         this.commandFactories = commandFactories;
+        this.unlinkedFiles = [];
 
         this.state = new PersistentState(extCtx.globalState);
         this.config = new Config(extCtx);
@@ -218,7 +220,8 @@ export class Ctx {
                 this.outputChannel,
                 initializationOptions,
                 serverOptions,
-                this.config
+                this.config,
+                this.unlinkedFiles
             );
             this.pushClientCleanup(
                 this._client.onNotification(ra.serverStatus, (params) =>
-- 
cgit 1.4.1-3-g733a5


From 9745a25d57fbd9a73aec1306554ac87936a63e7d Mon Sep 17 00:00:00 2001
From: x2cf <x2cf@outlook.com>
Date: Tue, 21 Mar 2023 14:56:07 +0800
Subject: Fix VS Code status message formatting error

---
 editors/code/src/ctx.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index c2dca733df8..85579453a63 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -383,7 +383,7 @@ export class Ctx {
         );
         statusBar.tooltip.appendMarkdown("\n\n[Open logs](command:rust-analyzer.openLogs)");
         statusBar.tooltip.appendMarkdown("\n\n[Restart server](command:rust-analyzer.startServer)");
-        statusBar.tooltip.appendMarkdown("[Stop server](command:rust-analyzer.stopServer)");
+        statusBar.tooltip.appendMarkdown("\n\n[Stop server](command:rust-analyzer.stopServer)");
         if (!status.quiescent) icon = "$(sync~spin) ";
         statusBar.text = `${icon}rust-analyzer`;
     }
-- 
cgit 1.4.1-3-g733a5


From 3622fb645632fcf81af82919259be4b0012a3939 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 20 Mar 2023 21:24:53 +0100
Subject: Fix lints

---
 editors/code/src/client.ts | 75 ++++++++++++++++++++++------------------------
 editors/code/src/ctx.ts    |  4 +--
 2 files changed, 37 insertions(+), 42 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 2a1c757dfef..4ca6601a6aa 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -121,59 +121,54 @@ export async function createClient(
                 const preview = config.previewRustcOutput;
                 const errorCode = config.useRustcErrorCode;
                 diagnosticList.forEach((diag, idx) => {
-                    let value =
+                    const value =
                         typeof diag.code === "string" || typeof diag.code === "number"
                             ? diag.code
                             : diag.code?.value;
                     if (value === "unlinked-file" && !unlinkedFiles.includes(uri)) {
-                        let config = vscode.workspace.getConfiguration("rust-analyzer");
+                        const config = vscode.workspace.getConfiguration("rust-analyzer");
                         if (config.get("showUnlinkedFileNotification")) {
                             unlinkedFiles.push(uri);
-                            let folder = vscode.workspace.getWorkspaceFolder(uri)?.uri.fsPath;
+                            const folder = vscode.workspace.getWorkspaceFolder(uri)?.uri.fsPath;
                             if (folder) {
-                                let parent_backslash = uri.fsPath.lastIndexOf(
+                                const parentBackslash = uri.fsPath.lastIndexOf(
                                     pathSeparator + "src"
                                 );
-                                let parent = uri.fsPath.substring(0, parent_backslash);
+                                const parent = uri.fsPath.substring(0, parentBackslash);
 
                                 if (parent.startsWith(folder)) {
-                                    let path = vscode.Uri.file(
+                                    const path = vscode.Uri.file(
                                         parent + pathSeparator + "Cargo.toml"
                                     );
-                                    void vscode.workspace.fs.stat(path).then(() => {
-                                        vscode.window
-                                            .showInformationMessage(
-                                                `This rust file does not belong to a loaded cargo project. It looks like it might belong to the workspace at ${path}, do you want to add it to the linked Projects?`,
-                                                "Yes",
-                                                "No",
-                                                "Don't show this again"
-                                            )
-                                            .then((choice) => {
-                                                switch (choice) {
-                                                    case "Yes":
-                                                        break;
-                                                    case "No":
-                                                        config.update(
-                                                            "linkedProjects",
-                                                            config
-                                                                .get<any[]>("linkedProjects")
-                                                                ?.concat(
-                                                                    path.fsPath.substring(
-                                                                        folder!.length
-                                                                    )
-                                                                ),
-                                                            false
-                                                        );
-                                                        break;
-                                                    case "Don't show this again":
-                                                        config.update(
-                                                            "showUnlinkedFileNotification",
-                                                            false,
-                                                            false
-                                                        );
-                                                        break;
-                                                }
-                                            });
+                                    void vscode.workspace.fs.stat(path).then(async () => {
+                                        const choice = await vscode.window.showInformationMessage(
+                                            `This rust file does not belong to a loaded cargo project. It looks like it might belong to the workspace at ${path}, do you want to add it to the linked Projects?`,
+                                            "Yes",
+                                            "No",
+                                            "Don't show this again"
+                                        );
+                                        switch (choice) {
+                                            case "Yes":
+                                                break;
+                                            case "No":
+                                                await config.update(
+                                                    "linkedProjects",
+                                                    config
+                                                        .get<any[]>("linkedProjects")
+                                                        ?.concat(
+                                                            path.fsPath.substring(folder.length)
+                                                        ),
+                                                    false
+                                                );
+                                                break;
+                                            case "Don't show this again":
+                                                await config.update(
+                                                    "showUnlinkedFileNotification",
+                                                    false,
+                                                    false
+                                                );
+                                                break;
+                                        }
                                     });
                                 }
                             }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 5515921ed14..8a0f4ea4773 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -95,7 +95,6 @@ export class Ctx {
     ) {
         extCtx.subscriptions.push(this);
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
-        this.statusBar.show();
         this.workspace = workspace;
         this.clientSubscriptions = [];
         this.commandDisposables = [];
@@ -338,6 +337,7 @@ export class Ctx {
     setServerStatus(status: ServerStatusParams | { health: "stopped" }) {
         let icon = "";
         const statusBar = this.statusBar;
+        statusBar.show();
         statusBar.tooltip = new vscode.MarkdownString("", true);
         statusBar.tooltip.isTrusted = true;
         switch (status.health) {
@@ -386,7 +386,7 @@ export class Ctx {
         );
         statusBar.tooltip.appendMarkdown("\n\n[Open logs](command:rust-analyzer.openLogs)");
         statusBar.tooltip.appendMarkdown("\n\n[Restart server](command:rust-analyzer.startServer)");
-        statusBar.tooltip.appendMarkdown("[Stop server](command:rust-analyzer.stopServer)");
+        statusBar.tooltip.appendMarkdown("\n\n[Stop server](command:rust-analyzer.stopServer)");
         if (!status.quiescent) icon = "$(sync~spin) ";
         statusBar.text = `${icon}rust-analyzer`;
     }
-- 
cgit 1.4.1-3-g733a5


From e9fb2ffe4572471588b6bd602521a1421baf4dc3 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sat, 25 Mar 2023 16:47:41 +0100
Subject: Add lsp command for rebuilding proc macros

---
 crates/rust-analyzer/src/handlers.rs  | 8 ++++++++
 crates/rust-analyzer/src/lsp_ext.rs   | 8 ++++++++
 crates/rust-analyzer/src/main_loop.rs | 1 +
 editors/code/src/commands.ts          | 4 ++++
 editors/code/src/ctx.ts               | 5 ++++-
 editors/code/src/lsp_ext.ts           | 1 +
 editors/code/src/main.ts              | 1 +
 7 files changed, 27 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 2fca2ab851d..a56c245dca5 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -52,6 +52,14 @@ pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> Result<
     Ok(())
 }
 
+pub(crate) fn handle_proc_macros_reload(state: &mut GlobalState, _: ()) -> Result<()> {
+    state.proc_macro_clients.clear();
+    state.proc_macro_changed = false;
+
+    state.fetch_build_data_queue.request_op("reload proc macros request".to_string());
+    Ok(())
+}
+
 pub(crate) fn handle_cancel_flycheck(state: &mut GlobalState, _: ()) -> Result<()> {
     let _p = profile::span("handle_stop_flycheck");
     state.flycheck.iter().for_each(|flycheck| flycheck.cancel());
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index c7b513db981..2f8829ec738 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -51,6 +51,14 @@ impl Request for ReloadWorkspace {
     const METHOD: &'static str = "rust-analyzer/reloadWorkspace";
 }
 
+pub enum ReloadProcMacros {}
+
+impl Request for ReloadProcMacros {
+    type Params = ();
+    type Result = ();
+    const METHOD: &'static str = "rust-analyzer/reloadProcMacros";
+}
+
 pub enum SyntaxTree {}
 
 impl Request for SyntaxTree {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 67a54cde68c..ae7457e3473 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -633,6 +633,7 @@ impl GlobalState {
 
         dispatcher
             .on_sync_mut::<lsp_ext::ReloadWorkspace>(handlers::handle_workspace_reload)
+            .on_sync_mut::<lsp_ext::ReloadProcMacros>(handlers::handle_proc_macros_reload)
             .on_sync_mut::<lsp_ext::MemoryUsage>(handlers::handle_memory_usage)
             .on_sync_mut::<lsp_ext::ShuffleCrateGraph>(handlers::handle_shuffle_crate_graph)
             .on_sync::<lsp_ext::JoinLines>(handlers::handle_join_lines)
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 8a953577e99..8ce3466ed44 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -749,6 +749,10 @@ export function reloadWorkspace(ctx: CtxInit): Cmd {
     return async () => ctx.client.sendRequest(ra.reloadWorkspace);
 }
 
+export function reloadProcMacros(ctx: CtxInit): Cmd {
+    return async () => ctx.client.sendRequest(ra.reloadProcMacros);
+}
+
 export function addProject(ctx: CtxInit): Cmd {
     return async () => {
         const discoverProjectCommand = ctx.config.discoverProjectCommand;
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 85579453a63..8da8b0d63a1 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -378,10 +378,13 @@ export class Ctx {
         if (statusBar.tooltip.value) {
             statusBar.tooltip.appendText("\n\n");
         }
+        statusBar.tooltip.appendMarkdown("\n\n[Open logs](command:rust-analyzer.openLogs)");
         statusBar.tooltip.appendMarkdown(
             "\n\n[Reload Workspace](command:rust-analyzer.reloadWorkspace)"
         );
-        statusBar.tooltip.appendMarkdown("\n\n[Open logs](command:rust-analyzer.openLogs)");
+        statusBar.tooltip.appendMarkdown(
+            "\n\n[Rebuild Proc Macros](command:rust-analyzer.reloadProcMacros)"
+        );
         statusBar.tooltip.appendMarkdown("\n\n[Restart server](command:rust-analyzer.startServer)");
         statusBar.tooltip.appendMarkdown("\n\n[Stop server](command:rust-analyzer.stopServer)");
         if (!status.quiescent) icon = "$(sync~spin) ";
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 872d7199b83..a03777d1c0a 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -43,6 +43,7 @@ export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, Te
     "rust-analyzer/relatedTests"
 );
 export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");
+export const reloadProcMacros = new lc.RequestType0<null, void>("rust-analyzer/reloadProcMacros");
 
 export const runFlycheck = new lc.NotificationType<{
     textDocument: lc.TextDocumentIdentifier | null;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index d5de00561b1..7079f235cab 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -153,6 +153,7 @@ function createCommands(): Record<string, CommandFactory> {
         memoryUsage: { enabled: commands.memoryUsage },
         shuffleCrateGraph: { enabled: commands.shuffleCrateGraph },
         reloadWorkspace: { enabled: commands.reloadWorkspace },
+        reloadProcMacros: { enabled: commands.reloadProcMacros },
         addProject: { enabled: commands.addProject },
         matchingBrace: { enabled: commands.matchingBrace },
         joinLines: { enabled: commands.joinLines },
-- 
cgit 1.4.1-3-g733a5


From ee02213e65b1fd9c5e331ffe4a1ebd1e2ebab9c8 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 26 Mar 2023 08:39:28 +0200
Subject: Handle proc macro fetching via OpQueue

---
 crates/base-db/src/input.rs                        |  4 +-
 .../src/handlers/unresolved_proc_macro.rs          | 24 ++++----
 crates/project-model/src/workspace.rs              | 16 +++---
 crates/rust-analyzer/src/cli/load_cargo.rs         |  5 +-
 crates/rust-analyzer/src/config.rs                 |  4 ++
 crates/rust-analyzer/src/global_state.rs           | 20 ++++---
 crates/rust-analyzer/src/handlers.rs               |  7 +--
 crates/rust-analyzer/src/lsp_ext.rs                |  6 +-
 crates/rust-analyzer/src/main_loop.rs              | 29 ++++++----
 crates/rust-analyzer/src/op_queue.rs               | 14 ++---
 crates/rust-analyzer/src/reload.rs                 | 64 +++++++++++++---------
 docs/dev/lsp-extensions.md                         |  6 +-
 editors/code/package.json                          |  4 +-
 editors/code/src/commands.ts                       |  4 +-
 editors/code/src/ctx.ts                            |  2 +-
 editors/code/src/lsp_ext.ts                        |  2 +-
 editors/code/src/main.ts                           |  2 +-
 17 files changed, 121 insertions(+), 92 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/base-db/src/input.rs b/crates/base-db/src/input.rs
index 9580b76faa2..c43941d6ac1 100644
--- a/crates/base-db/src/input.rs
+++ b/crates/base-db/src/input.rs
@@ -15,7 +15,9 @@ use syntax::SmolStr;
 use tt::token_id::Subtree;
 use vfs::{file_set::FileSet, AbsPathBuf, AnchoredPath, FileId, VfsPath};
 
-pub type ProcMacroPaths = FxHashMap<CrateId, Result<(Option<String>, AbsPathBuf), String>>;
+// Map from crate id to the name of the crate and path of the proc-macro. If the value is `None`,
+// then the crate for the proc-macro hasn't been build yet as the build data is missing.
+pub type ProcMacroPaths = FxHashMap<CrateId, Option<(Option<String>, AbsPathBuf)>>;
 pub type ProcMacros = FxHashMap<CrateId, ProcMacroLoadResult>;
 
 /// Files are grouped into source roots. A source root is a directory on the
diff --git a/crates/ide-diagnostics/src/handlers/unresolved_proc_macro.rs b/crates/ide-diagnostics/src/handlers/unresolved_proc_macro.rs
index 9a984ba6bf0..ae5cf135839 100644
--- a/crates/ide-diagnostics/src/handlers/unresolved_proc_macro.rs
+++ b/crates/ide-diagnostics/src/handlers/unresolved_proc_macro.rs
@@ -25,25 +25,21 @@ pub(crate) fn unresolved_proc_macro(
         _ => proc_macros_enabled,
     };
 
-    let message = match &d.macro_name {
+    let not_expanded_message = match &d.macro_name {
         Some(name) => format!("proc macro `{name}` not expanded"),
         None => "proc macro not expanded".to_string(),
     };
     let severity = if config_enabled { Severity::Error } else { Severity::WeakWarning };
     let def_map = ctx.sema.db.crate_def_map(d.krate);
-    let message = format!(
-        "{message}: {}",
-        if config_enabled {
-            def_map.proc_macro_loading_error().unwrap_or("proc macro not found in the built dylib")
-        } else {
-            match d.kind {
-                hir::MacroKind::Attr if proc_macros_enabled => {
-                    "attribute macro expansion is disabled"
-                }
-                _ => "proc-macro expansion is disabled",
-            }
-        },
-    );
+    let message = if config_enabled {
+        def_map.proc_macro_loading_error().unwrap_or("proc macro not found in the built dylib")
+    } else {
+        match d.kind {
+            hir::MacroKind::Attr if proc_macros_enabled => "attribute macro expansion is disabled",
+            _ => "proc-macro expansion is disabled",
+        }
+    };
+    let message = format!("{not_expanded_message}: {message}");
 
     Diagnostic::new("unresolved-proc-macro", message, display_range).severity(severity)
 }
diff --git a/crates/project-model/src/workspace.rs b/crates/project-model/src/workspace.rs
index 1fd7c681938..fa966f70aa4 100644
--- a/crates/project-model/src/workspace.rs
+++ b/crates/project-model/src/workspace.rs
@@ -707,7 +707,7 @@ fn project_json_to_crate_graph(
             if let Some(path) = krate.proc_macro_dylib_path.clone() {
                 proc_macros.insert(
                     crate_id,
-                    Ok((
+                    Some((
                         krate.display_name.as_ref().map(|it| it.canonical_name().to_owned()),
                         path,
                     )),
@@ -1185,12 +1185,14 @@ fn add_target_crate_root(
         CrateOrigin::CratesIo { repo: pkg.repository.clone(), name: Some(pkg.name.clone()) },
         target_layout,
     );
-    let proc_macro = match build_data.as_ref().map(|it| &it.proc_macro_dylib_path) {
-        Some(it) => it.clone().map(Ok),
-        None => Some(Err("crate has not (yet) been built".into())),
-    };
-    if let Some(proc_macro) = proc_macro {
-        proc_macros.insert(crate_id, proc_macro.map(|path| (Some(cargo_name.to_owned()), path)));
+    if is_proc_macro {
+        let proc_macro = match build_data.as_ref().map(|it| it.proc_macro_dylib_path.as_ref()) {
+            Some(it) => it.cloned().map(|path| Some((Some(cargo_name.to_owned()), path))),
+            None => Some(None),
+        };
+        if let Some(proc_macro) = proc_macro {
+            proc_macros.insert(crate_id, proc_macro);
+        }
     }
 
     crate_id
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index f5bc3c12c14..268f59e7e4b 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -101,7 +101,10 @@ pub fn load_workspace(
             .map(|(crate_id, path)| {
                 (
                     crate_id,
-                    path.and_then(|(_, path)| load_proc_macro(proc_macro_server, &path, &[])),
+                    path.map_or_else(
+                        || Err("proc macro crate is missing dylib".to_owned()),
+                        |(_, path)| load_proc_macro(proc_macro_server, &path, &[]),
+                    ),
                 )
             })
             .collect()
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index c35cce103fa..e917f107f3b 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -1106,6 +1106,10 @@ impl Config {
         &self.data.procMacro_ignored
     }
 
+    pub fn expand_proc_macros(&self) -> bool {
+        self.data.procMacro_enable
+    }
+
     pub fn expand_proc_attr_macros(&self) -> bool {
         self.data.procMacro_enable && self.data.procMacro_attributes_enable
     }
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index d02714ad1ea..e0c143310d8 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -8,7 +8,7 @@ use std::{sync::Arc, time::Instant};
 use crossbeam_channel::{unbounded, Receiver, Sender};
 use flycheck::FlycheckHandle;
 use ide::{Analysis, AnalysisHost, Cancellable, Change, FileId};
-use ide_db::base_db::{CrateId, FileLoader, SourceDatabase};
+use ide_db::base_db::{CrateId, FileLoader, ProcMacroPaths, SourceDatabase};
 use lsp_types::{SemanticTokens, Url};
 use parking_lot::{Mutex, RwLock};
 use proc_macro_api::ProcMacroServer;
@@ -101,11 +101,12 @@ pub(crate) struct GlobalState {
     /// the user just adds comments or whitespace to Cargo.toml, we do not want
     /// to invalidate any salsa caches.
     pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
-    pub(crate) fetch_workspaces_queue: OpQueue<Option<Vec<anyhow::Result<ProjectWorkspace>>>>,
+    pub(crate) fetch_workspaces_queue: OpQueue<(), Option<Vec<anyhow::Result<ProjectWorkspace>>>>,
     pub(crate) fetch_build_data_queue:
-        OpQueue<(Arc<Vec<ProjectWorkspace>>, Vec<anyhow::Result<WorkspaceBuildScripts>>)>,
+        OpQueue<(), (Arc<Vec<ProjectWorkspace>>, Vec<anyhow::Result<WorkspaceBuildScripts>>)>,
+    pub(crate) fetch_proc_macros_queue: OpQueue<Vec<ProcMacroPaths>, bool>,
 
-    pub(crate) prime_caches_queue: OpQueue<()>,
+    pub(crate) prime_caches_queue: OpQueue,
 }
 
 /// An immutable snapshot of the world's state at a point in time.
@@ -117,6 +118,7 @@ pub(crate) struct GlobalStateSnapshot {
     pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,
     vfs: Arc<RwLock<(vfs::Vfs, NoHashHashMap<FileId, LineEndings>)>>,
     pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
+    // used to signal semantic highlighting to fall back to syntax based highlighting until proc-macros have been loaded
     pub(crate) proc_macros_loaded: bool,
     pub(crate) flycheck: Arc<[FlycheckHandle]>,
 }
@@ -170,9 +172,10 @@ impl GlobalState {
 
             workspaces: Arc::new(Vec::new()),
             fetch_workspaces_queue: OpQueue::default(),
-            prime_caches_queue: OpQueue::default(),
-
             fetch_build_data_queue: OpQueue::default(),
+            fetch_proc_macros_queue: OpQueue::default(),
+
+            prime_caches_queue: OpQueue::default(),
         };
         // Apply any required database inputs from the config.
         this.update_configuration(config);
@@ -286,7 +289,7 @@ impl GlobalState {
             // crate see https://github.com/rust-lang/rust-analyzer/issues/13029
             if let Some(path) = workspace_structure_change {
                 self.fetch_workspaces_queue
-                    .request_op(format!("workspace vfs file change: {}", path.display()));
+                    .request_op(format!("workspace vfs file change: {}", path.display()), ());
             }
             self.proc_macro_changed =
                 changed_files.iter().filter(|file| !file.is_created_or_deleted()).any(|file| {
@@ -309,7 +312,8 @@ impl GlobalState {
             check_fixes: Arc::clone(&self.diagnostics.check_fixes),
             mem_docs: self.mem_docs.clone(),
             semantic_tokens_cache: Arc::clone(&self.semantic_tokens_cache),
-            proc_macros_loaded: !self.fetch_build_data_queue.last_op_result().0.is_empty(),
+            proc_macros_loaded: !self.config.expand_proc_macros()
+                || *self.fetch_proc_macros_queue.last_op_result(),
             flycheck: self.flycheck.clone(),
         }
     }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 8866515bb94..2dae2c82b93 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -48,16 +48,15 @@ pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> Result<
     state.proc_macro_clients = Arc::new([]);
     state.proc_macro_changed = false;
 
-    state.fetch_workspaces_queue.request_op("reload workspace request".to_string());
-    state.fetch_build_data_queue.request_op("reload workspace request".to_string());
+    state.fetch_workspaces_queue.request_op("reload workspace request".to_string(), ());
     Ok(())
 }
 
-pub(crate) fn handle_proc_macros_reload(state: &mut GlobalState, _: ()) -> Result<()> {
+pub(crate) fn handle_proc_macros_rebuild(state: &mut GlobalState, _: ()) -> Result<()> {
     state.proc_macro_clients = Arc::new([]);
     state.proc_macro_changed = false;
 
-    state.fetch_build_data_queue.request_op("reload proc macros request".to_string());
+    state.fetch_build_data_queue.request_op("rebuild proc macros request".to_string(), ());
     Ok(())
 }
 
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 2f8829ec738..2adefcc5e83 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -51,12 +51,12 @@ impl Request for ReloadWorkspace {
     const METHOD: &'static str = "rust-analyzer/reloadWorkspace";
 }
 
-pub enum ReloadProcMacros {}
+pub enum RebuildProcMacros {}
 
-impl Request for ReloadProcMacros {
+impl Request for RebuildProcMacros {
     type Params = ();
     type Result = ();
-    const METHOD: &'static str = "rust-analyzer/reloadProcMacros";
+    const METHOD: &'static str = "rust-analyzer/rebuildProcMacros";
 }
 
 pub enum SyntaxTree {}
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 8db526e0b76..f9930fb2599 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -149,8 +149,8 @@ impl GlobalState {
             );
         }
 
-        self.fetch_workspaces_queue.request_op("startup".to_string());
-        if let Some(cause) = self.fetch_workspaces_queue.should_start_op() {
+        self.fetch_workspaces_queue.request_op("startup".to_string(), ());
+        if let Some((cause, ())) = self.fetch_workspaces_queue.should_start_op() {
             self.fetch_workspaces(cause);
         }
 
@@ -248,7 +248,7 @@ impl GlobalState {
                             self.prime_caches_queue.op_completed(());
                             if cancelled {
                                 self.prime_caches_queue
-                                    .request_op("restart after cancellation".to_string());
+                                    .request_op("restart after cancellation".to_string(), ());
                             }
                         }
                     };
@@ -280,7 +280,8 @@ impl GlobalState {
         if self.is_quiescent() {
             let became_quiescent = !(was_quiescent
                 || self.fetch_workspaces_queue.op_requested()
-                || self.fetch_build_data_queue.op_requested());
+                || self.fetch_build_data_queue.op_requested()
+                || self.fetch_proc_macros_queue.op_requested());
 
             if became_quiescent {
                 if self.config.check_on_save() {
@@ -288,7 +289,7 @@ impl GlobalState {
                     self.flycheck.iter().for_each(FlycheckHandle::restart);
                 }
                 if self.config.prefill_caches() {
-                    self.prime_caches_queue.request_op("became quiescent".to_string());
+                    self.prime_caches_queue.request_op("became quiescent".to_string(), ());
                 }
             }
 
@@ -358,18 +359,20 @@ impl GlobalState {
         }
 
         if self.config.cargo_autoreload() {
-            if let Some(cause) = self.fetch_workspaces_queue.should_start_op() {
+            if let Some((cause, ())) = self.fetch_workspaces_queue.should_start_op() {
                 self.fetch_workspaces(cause);
             }
         }
 
         if !self.fetch_workspaces_queue.op_in_progress() {
-            if let Some(cause) = self.fetch_build_data_queue.should_start_op() {
+            if let Some((cause, ())) = self.fetch_build_data_queue.should_start_op() {
                 self.fetch_build_data(cause);
+            } else if let Some((cause, paths)) = self.fetch_proc_macros_queue.should_start_op() {
+                self.fetch_proc_macros(cause, paths);
             }
         }
 
-        if let Some(cause) = self.prime_caches_queue.should_start_op() {
+        if let Some((cause, ())) = self.prime_caches_queue.should_start_op() {
             tracing::debug!(%cause, "will prime caches");
             let num_worker_threads = self.config.prime_caches_num_threads();
 
@@ -463,7 +466,8 @@ impl GlobalState {
                         let workspaces_updated = !Arc::ptr_eq(&old, &self.workspaces);
 
                         if self.config.run_build_scripts() && workspaces_updated {
-                            self.fetch_build_data_queue.request_op(format!("workspace updated"));
+                            self.fetch_build_data_queue
+                                .request_op(format!("workspace updated"), ());
                         }
 
                         (Progress::End, None)
@@ -497,6 +501,7 @@ impl GlobalState {
                     ProcMacroProgress::Begin => (Some(Progress::Begin), None),
                     ProcMacroProgress::Report(msg) => (Some(Progress::Report), Some(msg)),
                     ProcMacroProgress::End(proc_macro_load_result) => {
+                        self.fetch_proc_macros_queue.op_completed(true);
                         self.set_proc_macros(proc_macro_load_result);
 
                         (Some(Progress::End), None)
@@ -649,7 +654,7 @@ impl GlobalState {
 
         dispatcher
             .on_sync_mut::<lsp_ext::ReloadWorkspace>(handlers::handle_workspace_reload)
-            .on_sync_mut::<lsp_ext::ReloadProcMacros>(handlers::handle_proc_macros_reload)
+            .on_sync_mut::<lsp_ext::RebuildProcMacros>(handlers::handle_proc_macros_rebuild)
             .on_sync_mut::<lsp_ext::MemoryUsage>(handlers::handle_memory_usage)
             .on_sync_mut::<lsp_ext::ShuffleCrateGraph>(handlers::handle_shuffle_crate_graph)
             .on_sync::<lsp_ext::JoinLines>(handlers::handle_join_lines)
@@ -904,7 +909,7 @@ impl GlobalState {
                     if let Some(abs_path) = vfs_path.as_path() {
                         if reload::should_refresh_for_change(abs_path, ChangeKind::Modify) {
                             this.fetch_workspaces_queue
-                                .request_op(format!("DidSaveTextDocument {}", abs_path.display()));
+                                .request_op(format!("DidSaveTextDocument {}", abs_path.display()), ());
                         }
                     }
 
@@ -980,7 +985,7 @@ impl GlobalState {
                 config.workspace_roots.extend(added);
                     if !config.has_linked_projects() && config.detached_files().is_empty() {
                         config.rediscover_workspaces();
-                        this.fetch_workspaces_queue.request_op("client workspaces changed".to_string())
+                        this.fetch_workspaces_queue.request_op("client workspaces changed".to_string(), ())
                     }
 
                 Ok(())
diff --git a/crates/rust-analyzer/src/op_queue.rs b/crates/rust-analyzer/src/op_queue.rs
index 97aca016187..932730fc234 100644
--- a/crates/rust-analyzer/src/op_queue.rs
+++ b/crates/rust-analyzer/src/op_queue.rs
@@ -3,23 +3,23 @@
 
 pub(crate) type Cause = String;
 
-pub(crate) struct OpQueue<Output> {
-    op_requested: Option<Cause>,
+pub(crate) struct OpQueue<Args = (), Output = ()> {
+    op_requested: Option<(Cause, Args)>,
     op_in_progress: bool,
     last_op_result: Output,
 }
 
-impl<Output: Default> Default for OpQueue<Output> {
+impl<Args, Output: Default> Default for OpQueue<Args, Output> {
     fn default() -> Self {
         Self { op_requested: None, op_in_progress: false, last_op_result: Default::default() }
     }
 }
 
-impl<Output> OpQueue<Output> {
-    pub(crate) fn request_op(&mut self, reason: Cause) {
-        self.op_requested = Some(reason);
+impl<Args, Output> OpQueue<Args, Output> {
+    pub(crate) fn request_op(&mut self, reason: Cause, args: Args) {
+        self.op_requested = Some((reason, args));
     }
-    pub(crate) fn should_start_op(&mut self) -> Option<Cause> {
+    pub(crate) fn should_start_op(&mut self) -> Option<(Cause, Args)> {
         if self.op_in_progress {
             return None;
         }
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index 9c6edb46f41..987eb8aad6d 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -66,6 +66,7 @@ impl GlobalState {
         !(self.last_reported_status.is_none()
             || self.fetch_workspaces_queue.op_in_progress()
             || self.fetch_build_data_queue.op_in_progress()
+            || self.fetch_proc_macros_queue.op_in_progress()
             || self.vfs_progress_config_version < self.vfs_config_version
             || self.vfs_progress_n_done < self.vfs_progress_n_total)
     }
@@ -77,7 +78,7 @@ impl GlobalState {
             self.analysis_host.update_lru_capacity(self.config.lru_capacity());
         }
         if self.config.linked_projects() != old_config.linked_projects() {
-            self.fetch_workspaces_queue.request_op("linked projects changed".to_string())
+            self.fetch_workspaces_queue.request_op("linked projects changed".to_string(), ())
         } else if self.config.flycheck() != old_config.flycheck() {
             self.reload_flycheck();
         }
@@ -101,7 +102,7 @@ impl GlobalState {
 
         if self.proc_macro_changed {
             status.health = lsp_ext::Health::Warning;
-            message.push_str("Reload required due to source changes of a procedural macro.\n\n");
+            message.push_str("Proc-macros have changed and need to be rebuild.\n\n");
         }
         if let Err(_) = self.fetch_build_data_error() {
             status.health = lsp_ext::Health::Warning;
@@ -223,8 +224,8 @@ impl GlobalState {
         });
     }
 
-    pub(crate) fn load_proc_macros(&mut self, paths: Vec<ProcMacroPaths>) {
-        tracing::info!("will load proc macros");
+    pub(crate) fn fetch_proc_macros(&mut self, cause: Cause, paths: Vec<ProcMacroPaths>) {
+        tracing::info!(%cause, "will load proc macros");
         let dummy_replacements = self.config.dummy_replacements().clone();
         let proc_macro_clients = self.proc_macro_clients.clone();
 
@@ -240,28 +241,30 @@ impl GlobalState {
             };
 
             let mut res = FxHashMap::default();
-            for (client, paths) in proc_macro_clients
+            let chain = proc_macro_clients
                 .iter()
                 .map(|res| res.as_ref().map_err(|e| &**e))
-                .chain(iter::repeat_with(|| Err("Proc macros are disabled")))
-                .zip(paths)
-            {
+                .chain(iter::repeat_with(|| Err("Proc macros servers are not running")));
+            for (client, paths) in chain.zip(paths) {
                 res.extend(paths.into_iter().map(move |(crate_id, res)| {
                     (
                         crate_id,
-                        res.and_then(|(crate_name, path)| {
-                            progress(path.display().to_string());
-                            load_proc_macro(
-                                client,
-                                &path,
-                                crate_name
-                                    .as_deref()
-                                    .and_then(|crate_name| {
-                                        dummy_replacements.get(crate_name).map(|v| &**v)
-                                    })
-                                    .unwrap_or_default(),
-                            )
-                        }),
+                        res.map_or_else(
+                            || Err("proc macro crate is missing dylib".to_owned()),
+                            |(crate_name, path)| {
+                                progress(path.display().to_string());
+                                load_proc_macro(
+                                    client,
+                                    &path,
+                                    crate_name
+                                        .as_deref()
+                                        .and_then(|crate_name| {
+                                            dummy_replacements.get(crate_name).map(|v| &**v)
+                                        })
+                                        .unwrap_or_default(),
+                                )
+                            },
+                        ),
                     )
                 }));
             }
@@ -443,14 +446,25 @@ impl GlobalState {
             (crate_graph, proc_macros)
         };
         let mut change = Change::new();
+
+        if same_workspaces {
+            if self.config.expand_proc_macros() {
+                self.fetch_proc_macros_queue.request_op(cause, proc_macro_paths);
+            }
+        } else {
+            // Set up errors for proc-macros upfront that we haven't run build scripts yet
+            let mut proc_macros = FxHashMap::default();
+            for paths in proc_macro_paths {
+                proc_macros.extend(paths.into_iter().map(move |(crate_id, _)| {
+                    (crate_id, Err("crate has not yet been build".to_owned()))
+                }));
+            }
+            change.set_proc_macros(proc_macros);
+        }
         change.set_crate_graph(crate_graph);
         self.analysis_host.apply_change(change);
         self.process_changes();
 
-        if same_workspaces && !self.fetch_workspaces_queue.op_requested() {
-            self.load_proc_macros(proc_macro_paths);
-        }
-
         self.reload_flycheck();
 
         tracing::info!("did switch workspaces");
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index c157bab590e..bb5c6589489 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: 92fe1037312754df
+lsp_ext.rs hash: 7269e4cfab906e10
 
 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:
@@ -422,9 +422,9 @@ Returns internal status message, mostly for debugging purposes.
 
 Reloads project information (that is, re-executes `cargo metadata`).
 
-## Reload proc-macros
+## Rebuild proc-macros
 
-**Method:** `rust-analyzer/reloadProcMacros`
+**Method:** `rust-analyzer/rebuildProcMacros`
 
 **Request:** `null`
 
diff --git a/editors/code/package.json b/editors/code/package.json
index 42cbc0e0d1f..4e57bf0e29b 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -200,8 +200,8 @@
                 "category": "rust-analyzer"
             },
             {
-                "command": "rust-analyzer.reloadProcMacros",
-                "title": "Reload proc macros and build scripts",
+                "command": "rust-analyzer.rebuildProcMacros",
+                "title": "Rebuild proc macros and build scripts",
                 "category": "rust-analyzer"
             },
             {
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 8ce3466ed44..486127d005a 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -749,8 +749,8 @@ export function reloadWorkspace(ctx: CtxInit): Cmd {
     return async () => ctx.client.sendRequest(ra.reloadWorkspace);
 }
 
-export function reloadProcMacros(ctx: CtxInit): Cmd {
-    return async () => ctx.client.sendRequest(ra.reloadProcMacros);
+export function rebuildProcMacros(ctx: CtxInit): Cmd {
+    return async () => ctx.client.sendRequest(ra.rebuildProcMacros);
 }
 
 export function addProject(ctx: CtxInit): Cmd {
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 8da8b0d63a1..89264ebe469 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -383,7 +383,7 @@ export class Ctx {
             "\n\n[Reload Workspace](command:rust-analyzer.reloadWorkspace)"
         );
         statusBar.tooltip.appendMarkdown(
-            "\n\n[Rebuild Proc Macros](command:rust-analyzer.reloadProcMacros)"
+            "\n\n[Rebuild Proc Macros](command:rust-analyzer.rebuildProcMacros)"
         );
         statusBar.tooltip.appendMarkdown("\n\n[Restart server](command:rust-analyzer.startServer)");
         statusBar.tooltip.appendMarkdown("\n\n[Stop server](command:rust-analyzer.stopServer)");
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index a03777d1c0a..857f0ed3f60 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -43,7 +43,7 @@ export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, Te
     "rust-analyzer/relatedTests"
 );
 export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");
-export const reloadProcMacros = new lc.RequestType0<null, void>("rust-analyzer/reloadProcMacros");
+export const rebuildProcMacros = new lc.RequestType0<null, void>("rust-analyzer/reloadProcMacros");
 
 export const runFlycheck = new lc.NotificationType<{
     textDocument: lc.TextDocumentIdentifier | null;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 7079f235cab..de40f99e003 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -153,7 +153,7 @@ function createCommands(): Record<string, CommandFactory> {
         memoryUsage: { enabled: commands.memoryUsage },
         shuffleCrateGraph: { enabled: commands.shuffleCrateGraph },
         reloadWorkspace: { enabled: commands.reloadWorkspace },
-        reloadProcMacros: { enabled: commands.reloadProcMacros },
+        rebuildProcMacros: { enabled: commands.rebuildProcMacros },
         addProject: { enabled: commands.addProject },
         matchingBrace: { enabled: commands.matchingBrace },
         joinLines: { enabled: commands.joinLines },
-- 
cgit 1.4.1-3-g733a5


From ef422406ef7e6960d215b596a24934436214a28e Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Sun, 26 Mar 2023 15:12:25 -0400
Subject: finish renaming `rust-analyzer/reloadProcMacros` to
 `rust-analyzer/rebuildProcMacros`

---
 editors/code/src/lsp_ext.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 857f0ed3f60..952dbb3e88a 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -43,7 +43,7 @@ export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, Te
     "rust-analyzer/relatedTests"
 );
 export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");
-export const rebuildProcMacros = new lc.RequestType0<null, void>("rust-analyzer/reloadProcMacros");
+export const rebuildProcMacros = new lc.RequestType0<null, void>("rust-analyzer/rebuildProcMacros");
 
 export const runFlycheck = new lc.NotificationType<{
     textDocument: lc.TextDocumentIdentifier | null;
-- 
cgit 1.4.1-3-g733a5


From fb9a1dd87ed3c44bb261958fbe2111f19e9185c9 Mon Sep 17 00:00:00 2001
From: Rungsikorn Rungsikavarnich
 <rungsikorn.rungsikavarnich@woven-planet.global>
Date: Thu, 30 Mar 2023 15:22:20 +0900
Subject: Missing runnable env on debug target

Fix bug in Rust Analyzer where runnable debugging did not pass
environment variable from configuration to child process of Cargo
on binary build stage
---
 editors/code/src/debug.ts     | 9 ++++++---
 editors/code/src/toolchain.ts | 7 ++++++-
 2 files changed, 12 insertions(+), 4 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
index 268b70b4fbb..cffee1de6af 100644
--- a/editors/code/src/debug.ts
+++ b/editors/code/src/debug.ts
@@ -118,8 +118,8 @@ async function getDebugConfiguration(
         return path.normalize(p).replace(wsFolder, "${workspaceFolder" + workspaceQualifier + "}");
     }
 
-    const executable = await getDebugExecutable(runnable);
     const env = prepareEnv(runnable, ctx.config.runnableEnv);
+    const executable = await getDebugExecutable(runnable, env);
     let sourceFileMap = debugOptions.sourceFileMap;
     if (sourceFileMap === "auto") {
         // let's try to use the default toolchain
@@ -156,8 +156,11 @@ async function getDebugConfiguration(
     return debugConfig;
 }
 
-async function getDebugExecutable(runnable: ra.Runnable): Promise<string> {
-    const cargo = new Cargo(runnable.args.workspaceRoot || ".", debugOutput);
+async function getDebugExecutable(
+    runnable: ra.Runnable,
+    env: Record<string, string>
+): Promise<string> {
+    const cargo = new Cargo(runnable.args.workspaceRoot || ".", debugOutput, env);
     const executable = await cargo.executableFromArgs(runnable.args.cargoArgs);
 
     // if we are here, there were no compilation errors.
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index eb70b88871e..917a1d6b099 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -18,7 +18,11 @@ export interface ArtifactSpec {
 }
 
 export class Cargo {
-    constructor(readonly rootFolder: string, readonly output: vscode.OutputChannel) {}
+    constructor(
+        readonly rootFolder: string,
+        readonly output: vscode.OutputChannel,
+        readonly env: Record<string, string>
+    ) {}
 
     // Made public for testing purposes
     static artifactSpec(args: readonly string[]): ArtifactSpec {
@@ -102,6 +106,7 @@ export class Cargo {
             const cargo = cp.spawn(path, cargoArgs, {
                 stdio: ["ignore", "pipe", "pipe"],
                 cwd: this.rootFolder,
+                env: this.env,
             });
 
             cargo.on("error", (err) => reject(new Error(`could not launch cargo: ${err}`)));
-- 
cgit 1.4.1-3-g733a5


From 613e008593f1caa0b799c1ca5048bd50d28190fd Mon Sep 17 00:00:00 2001
From: Ryo Yoshida <low.ryoshida@gmail.com>
Date: Sun, 2 Apr 2023 19:45:39 +0900
Subject: Don't append "!" to non-bang macro name

---
 crates/ide/src/expand_macro.rs | 42 ++++++++++++++++++++++--------------------
 editors/code/src/commands.ts   |  2 +-
 2 files changed, 23 insertions(+), 21 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/ide/src/expand_macro.rs b/crates/ide/src/expand_macro.rs
index 418043d6798..4382af43438 100644
--- a/crates/ide/src/expand_macro.rs
+++ b/crates/ide/src/expand_macro.rs
@@ -83,8 +83,10 @@ pub(crate) fn expand_macro(db: &RootDatabase, position: FilePosition) -> Option<
             }
         }
         if let Some(mac) = ast::MacroCall::cast(node) {
+            let mut name = mac.path()?.segment()?.name_ref()?.to_string();
+            name.push('!');
             break (
-                mac.path()?.segment()?.name_ref()?.to_string(),
+                name,
                 expand_macro_recur(&sema, &mac)?,
                 mac.syntax().parent().map(|it| it.kind()).unwrap_or(SyntaxKind::MACRO_ITEMS),
             );
@@ -235,7 +237,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                bar
+                bar!
                 5i64 as _"#]],
         );
     }
@@ -252,7 +254,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                bar
+                bar!
                 for _ in 0..42{}"#]],
         );
     }
@@ -273,7 +275,7 @@ macro_rules! baz {
 f$0oo!();
 "#,
             expect![[r#"
-                foo
+                foo!
                 fn b(){}
             "#]],
         );
@@ -294,7 +296,7 @@ macro_rules! foo {
 f$0oo!();
         "#,
             expect![[r#"
-                foo
+                foo!
                 fn some_thing() -> u32 {
                   let a = 0;
                   a+10
@@ -328,16 +330,16 @@ fn main() {
 }
 "#,
             expect![[r#"
-       match_ast
-       {
-         if let Some(it) = ast::TraitDef::cast(container.clone()){}
-         else if let Some(it) = ast::ImplDef::cast(container.clone()){}
-         else {
-           {
-             continue
-           }
-         }
-       }"#]],
+                match_ast!
+                {
+                  if let Some(it) = ast::TraitDef::cast(container.clone()){}
+                  else if let Some(it) = ast::ImplDef::cast(container.clone()){}
+                  else {
+                    {
+                      continue
+                    }
+                  }
+                }"#]],
         );
     }
 
@@ -358,7 +360,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                match_ast
+                match_ast!
                 {}"#]],
         );
     }
@@ -383,7 +385,7 @@ fn main() {
 }
             "#,
             expect![[r#"
-                foo
+                foo!
                 {
                   macro_rules! bar {
                     () => {
@@ -411,7 +413,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                foo
+                foo!
             "#]],
         );
     }
@@ -433,7 +435,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                foo
+                foo!
                 0"#]],
         );
     }
@@ -451,7 +453,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                foo
+                foo!
                 fn f<T>(_: &dyn ::std::marker::Copy){}"#]],
         );
     }
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 486127d005a..7a8490e4767 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -699,7 +699,7 @@ export function viewFullCrateGraph(ctx: CtxInit): Cmd {
 // The contents of the file come from the `TextDocumentContentProvider`
 export function expandMacro(ctx: CtxInit): Cmd {
     function codeFormat(expanded: ra.ExpandedMacro): string {
-        let result = `// Recursive expansion of ${expanded.name}! macro\n`;
+        let result = `// Recursive expansion of ${expanded.name} macro\n`;
         result += "// " + "=".repeat(result.length - 3);
         result += "\n\n";
         result += expanded.expansion;
-- 
cgit 1.4.1-3-g733a5


From 4243eeeb2b0a4f1c8a84e850f567e6445a8ed939 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 4 Apr 2023 07:55:09 +0200
Subject: fix: Fix vscode project linking popup buttons being swapped

---
 editors/code/src/client.ts | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 4ca6601a6aa..1db02e21058 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -148,15 +148,16 @@ export async function createClient(
                                             "Don't show this again"
                                         );
                                         switch (choice) {
-                                            case "Yes":
-                                                break;
                                             case "No":
+                                                break;
+                                            case "Yes":
                                                 await config.update(
                                                     "linkedProjects",
                                                     config
                                                         .get<any[]>("linkedProjects")
                                                         ?.concat(
-                                                            path.fsPath.substring(folder.length)
+                                                            "." +
+                                                                path.fsPath.substring(folder.length)
                                                         ),
                                                     false
                                                 );
-- 
cgit 1.4.1-3-g733a5


From 7989a9439181873c30a21df8e28d58fbe69e26a5 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 4 Apr 2023 08:20:35 +0200
Subject: fix: Fix relative path creation using the wrong path accessor

---
 editors/code/src/client.ts | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 1db02e21058..e76710cb247 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -142,23 +142,27 @@ export async function createClient(
                                     );
                                     void vscode.workspace.fs.stat(path).then(async () => {
                                         const choice = await vscode.window.showInformationMessage(
-                                            `This rust file does not belong to a loaded cargo project. It looks like it might belong to the workspace at ${path}, do you want to add it to the linked Projects?`,
+                                            `This rust file does not belong to a loaded cargo project. It looks like it might belong to the workspace at ${path.path}, do you want to add it to the linked Projects?`,
                                             "Yes",
                                             "No",
                                             "Don't show this again"
                                         );
                                         switch (choice) {
+                                            case undefined:
+                                                break;
                                             case "No":
                                                 break;
                                             case "Yes":
+                                                const pathToInsert =
+                                                    "." +
+                                                    parent.substring(folder.length) +
+                                                    pathSeparator +
+                                                    "Cargo.toml";
                                                 await config.update(
                                                     "linkedProjects",
                                                     config
                                                         .get<any[]>("linkedProjects")
-                                                        ?.concat(
-                                                            "." +
-                                                                path.fsPath.substring(folder.length)
-                                                        ),
+                                                        ?.concat(pathToInsert),
                                                     false
                                                 );
                                                 break;
-- 
cgit 1.4.1-3-g733a5


From 98a673c4a89726324e0ef7238181bb85e49ea3e5 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 9 Apr 2023 10:02:30 +0200
Subject: fix: Fix project linking popup appearing for modules that can be
 linked to a crate

---
 .../ide-diagnostics/src/handlers/unlinked_file.rs  | 24 +++++++++++++++++-----
 editors/code/src/client.ts                         |  6 +++++-
 2 files changed, 24 insertions(+), 6 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/ide-diagnostics/src/handlers/unlinked_file.rs b/crates/ide-diagnostics/src/handlers/unlinked_file.rs
index 145e18c5c48..b9c5384ea1e 100644
--- a/crates/ide-diagnostics/src/handlers/unlinked_file.rs
+++ b/crates/ide-diagnostics/src/handlers/unlinked_file.rs
@@ -10,7 +10,7 @@ use ide_db::{
 };
 use syntax::{
     ast::{self, edit::IndentLevel, HasModuleItem, HasName},
-    AstNode, TextRange, TextSize,
+    AstNode, TextRange,
 };
 use text_edit::TextEdit;
 
@@ -27,14 +27,28 @@ pub(crate) fn unlinked_file(
 ) {
     // Limit diagnostic to the first few characters in the file. This matches how VS Code
     // renders it with the full span, but on other editors, and is less invasive.
+    let fixes = fixes(ctx, file_id);
+    // FIXME: This is a hack for the vscode extension to notice whether there is an autofix or not before having to resolve diagnostics.
+    // This is to prevent project linking popups from appearing when there is an autofix. https://github.com/rust-lang/rust-analyzer/issues/14523
+    let message = if fixes.is_none() {
+        "file not included in crate hierarchy"
+    } else {
+        "file not included in module tree"
+    };
+
     let range = ctx.sema.db.parse(file_id).syntax_node().text_range();
-    // FIXME: This is wrong if one of the first three characters is not ascii: `//Ы`.
-    let range = range.intersect(TextRange::up_to(TextSize::of("..."))).unwrap_or(range);
+    let range = FileLoader::file_text(ctx.sema.db, file_id)
+        .char_indices()
+        .take(3)
+        .last()
+        .map(|(i, _)| i)
+        .map(|i| TextRange::up_to(i.try_into().unwrap()))
+        .unwrap_or(range);
 
     acc.push(
-        Diagnostic::new("unlinked-file", "file not included in module tree", range)
+        Diagnostic::new("unlinked-file", message, range)
             .severity(Severity::WeakWarning)
-            .with_fixes(fixes(ctx, file_id)),
+            .with_fixes(fixes),
     );
 }
 
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index e76710cb247..b27d9f54943 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -125,7 +125,11 @@ export async function createClient(
                         typeof diag.code === "string" || typeof diag.code === "number"
                             ? diag.code
                             : diag.code?.value;
-                    if (value === "unlinked-file" && !unlinkedFiles.includes(uri)) {
+                    if (
+                        value === "unlinked-file" &&
+                        !unlinkedFiles.includes(uri) &&
+                        diag.message !== "file not included in module tree"
+                    ) {
                         const config = vscode.workspace.getConfiguration("rust-analyzer");
                         if (config.get("showUnlinkedFileNotification")) {
                             unlinkedFiles.push(uri);
-- 
cgit 1.4.1-3-g733a5


From b99c129b74a0ba1eb2307fa6151be81b544a3794 Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Sat, 8 Apr 2023 11:22:22 -0400
Subject: fix: when running the "discoverProjectCommand", use the Rust file's
 parent directory instead of the workspace folder.

---
 editors/code/src/commands.ts | 13 +++++++------
 editors/code/src/ctx.ts      | 14 ++++++++------
 2 files changed, 15 insertions(+), 12 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 7a8490e4767..4438d475ad9 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -761,12 +761,13 @@ export function addProject(ctx: CtxInit): Cmd {
         }
 
         const workspaces: JsonProject[] = await Promise.all(
-            vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
-                const rustDocuments = vscode.workspace.textDocuments.filter(isRustDocument);
-                return discoverWorkspace(rustDocuments, discoverProjectCommand, {
-                    cwd: folder.uri.fsPath,
-                });
-            })
+            vscode.workspace.textDocuments
+                .filter(isRustDocument)
+                .map(async (file): Promise<JsonProject> => {
+                    return discoverWorkspace([file], discoverProjectCommand, {
+                        cwd: path.dirname(file.uri.fsPath),
+                    });
+                })
         );
 
         ctx.addToDiscoveredWorkspaces(workspaces);
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index dd74b31cc71..0ffa42c2a5a 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -1,6 +1,7 @@
 import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
+import * as path from "path";
 
 import { Config, prepareVSCodeConfig } from "./config";
 import { createClient } from "./client";
@@ -192,12 +193,13 @@ export class Ctx {
             const discoverProjectCommand = this.config.discoverProjectCommand;
             if (discoverProjectCommand) {
                 const workspaces: JsonProject[] = await Promise.all(
-                    vscode.workspace.workspaceFolders!.map(async (folder): Promise<JsonProject> => {
-                        const rustDocuments = vscode.workspace.textDocuments.filter(isRustDocument);
-                        return discoverWorkspace(rustDocuments, discoverProjectCommand, {
-                            cwd: folder.uri.fsPath,
-                        });
-                    })
+                    vscode.workspace.textDocuments
+                        .filter(isRustDocument)
+                        .map(async (file): Promise<JsonProject> => {
+                            return discoverWorkspace([file], discoverProjectCommand, {
+                                cwd: path.dirname(file.uri.fsPath),
+                            });
+                        })
                 );
 
                 this.addToDiscoveredWorkspaces(workspaces);
-- 
cgit 1.4.1-3-g733a5


From 7a6d5c680cdb9cee3c292ed2ac4f0ea3893694e1 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 13 Apr 2023 17:38:12 +0200
Subject: fix: Fix view crate graph being broken due to webworker usage

---
 editors/code/package.json    | 3 ++-
 editors/code/src/commands.ts | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index 087fd1296b3..3c0486ad680 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -44,7 +44,8 @@
         "anser": "^2.1.1",
         "d3": "^7.6.1",
         "d3-graphviz": "^5.0.2",
-        "vscode-languageclient": "^8.0.2"
+        "vscode-languageclient": "^8.0.2",
+        "@hpcc-js/wasm": "2.5.0"
     },
     "devDependencies": {
         "@types/node": "~16.11.7",
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 4438d475ad9..507a6260e17 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -663,12 +663,12 @@ function crateGraph(ctx: CtxInit, full: boolean): Cmd {
             </head>
             <body>
                 <script type="text/javascript" src="${uri}/d3/dist/d3.min.js"></script>
-                <script type="text/javascript" src="${uri}/@hpcc-js/wasm/dist/index.min.js"></script>
+                <script type="text/javascript" src="${uri}/@hpcc-js/wasm/dist/graphviz.umd.js"></script>
                 <script type="text/javascript" src="${uri}/d3-graphviz/build/d3-graphviz.min.js"></script>
                 <div id="graph"></div>
                 <script>
                     let graph = d3.select("#graph")
-                                  .graphviz()
+                                  .graphviz({ useWorker: false, useSharedWorker: false })
                                   .fit(true)
                                   .zoomScaleExtent([0.1, Infinity])
                                   .renderDot(\`${dot}\`);
-- 
cgit 1.4.1-3-g733a5


From 34177d85526695074b031201e199833a95c471d3 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 13 Apr 2023 22:01:57 +0200
Subject: minor: Allow copying the graphviz source from the view crategraph
 webview

---
 editors/code/src/commands.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 507a6260e17..5209fecc069 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -667,17 +667,22 @@ function crateGraph(ctx: CtxInit, full: boolean): Cmd {
                 <script type="text/javascript" src="${uri}/d3-graphviz/build/d3-graphviz.min.js"></script>
                 <div id="graph"></div>
                 <script>
+                    let dot = \`${dot}\`;
                     let graph = d3.select("#graph")
                                   .graphviz({ useWorker: false, useSharedWorker: false })
                                   .fit(true)
                                   .zoomScaleExtent([0.1, Infinity])
-                                  .renderDot(\`${dot}\`);
+                                  .renderDot(dot);
 
                     d3.select(window).on("click", (event) => {
                         if (event.ctrlKey) {
                             graph.resetZoom(d3.transition().duration(100));
                         }
                     });
+                    d3.select(window).on("copy", (event) => {
+                        event.clipboardData.setData("text/plain", dot);
+                        event.preventDefault();
+                    });
                 </script>
             </body>
             `;
-- 
cgit 1.4.1-3-g733a5


From bc7d84c3ce586f0976976d06305115085b63e53d Mon Sep 17 00:00:00 2001
From: Josh Soref <2119212+jsoref@users.noreply.github.com>
Date: Thu, 13 Apr 2023 18:35:00 -0400
Subject: Spelling

* a rule
* access
* after
* amount
* annotations
* assignment
* assist
* associated
* attribute
* borrowed
* built-in type
* clarification
* command
* const
* constructor
* corresponding
* counterparts
* curlies
* dependencies
* deterministic
* diagnostic
* duplicates
* edge
* edited
* efficient
* elsewhere
* execution
* expression
* extensions
* extracted
* fill
* github
* helper
* heuristic
* incomplete
* indent end
* inlay
* invocation
* lifetime
* looking
* maybe
* move
* mutability
* mutable
* necessarily
* necessary
* negative
* nonexistent
* occurred
* offsets
* offsetted
* overridden
* parameters
* params
* params_and_where_preds_in_scope
* paredit
* parent
* parentheses
* prepended if
* punctuation
* receive
* receiver
* referring
* repeated
* representing
* semantically
* separately
* shouldnot
* siblings
* similar
* something's
* statement
* struct
* structure
* surprise
* the
* this
* transparent
* unimplemented
* unnamed
* unnecessary
* unneeded
* unreachable
* unterminated
* utilities
* variant
* variants
* visibility
* work around (v)
* workaround

Signed-off-by: Josh Soref <2119212+jsoref@users.noreply.github.com>
---
 .github/actions/github-release/README.md           |  2 +-
 .github/workflows/autopublish.yaml                 |  2 +-
 .github/workflows/publish-libs.yaml                |  2 +-
 .vscode/launch.json                                |  2 +-
 bench_data/glorious_old_parser                     |  2 +-
 crates/hir-def/src/find_path.rs                    |  2 +-
 crates/hir-def/src/hir.rs                          |  2 +-
 crates/hir-def/src/macro_expansion_tests/mbe.rs    |  2 +-
 crates/hir-def/src/nameres/proc_macro.rs           |  2 +-
 crates/hir-def/src/nameres/tests/mod_resolution.rs |  2 +-
 crates/hir-expand/src/lib.rs                       |  2 +-
 crates/hir-ty/src/diagnostics/expr.rs              |  2 +-
 .../src/diagnostics/match_check/deconstruct_pat.rs |  2 +-
 .../hir-ty/src/diagnostics/match_check/pat_util.rs |  2 +-
 .../src/diagnostics/match_check/usefulness.rs      |  2 +-
 crates/hir-ty/src/infer.rs                         |  4 +--
 crates/hir-ty/src/infer/closure.rs                 |  4 +--
 crates/hir-ty/src/infer/expr.rs                    |  4 +--
 crates/hir-ty/src/lib.rs                           |  2 +-
 crates/hir-ty/src/mir.rs                           |  2 +-
 crates/hir-ty/src/mir/borrowck.rs                  |  2 +-
 crates/hir-ty/src/mir/eval.rs                      | 12 ++++-----
 crates/hir-ty/src/mir/lower.rs                     |  4 +--
 crates/hir-ty/src/mir/lower/pattern_matching.rs    |  2 +-
 crates/hir-ty/src/tests/regression.rs              |  2 +-
 crates/hir-ty/src/tests/traits.rs                  |  2 +-
 crates/hir/src/lib.rs                              |  6 ++---
 .../src/handlers/add_missing_impl_members.rs       |  2 +-
 crates/ide-assists/src/handlers/auto_import.rs     |  4 +--
 .../src/handlers/convert_to_guarded_return.rs      |  2 +-
 .../ide-assists/src/handlers/extract_function.rs   |  6 ++---
 crates/ide-assists/src/handlers/extract_module.rs  |  9 ++++---
 .../handlers/extract_struct_from_enum_variant.rs   |  2 +-
 .../handlers/generate_documentation_template.rs    |  4 +--
 .../ide-assists/src/handlers/generate_function.rs  | 10 ++++----
 crates/ide-assists/src/handlers/generate_getter.rs |  2 +-
 crates/ide-assists/src/handlers/generate_new.rs    |  6 ++---
 crates/ide-assists/src/handlers/inline_macro.rs    |  2 +-
 .../src/handlers/introduce_named_lifetime.rs       |  4 +--
 .../ide-assists/src/handlers/pull_assignment_up.rs |  4 +--
 .../src/handlers/qualify_method_call.rs            |  4 +--
 .../ide-assists/src/handlers/remove_parentheses.rs |  2 +-
 .../src/handlers/remove_unused_param.rs            |  2 +-
 .../src/handlers/replace_string_with_char.rs       |  4 +--
 crates/ide-completion/src/context/analysis.rs      |  4 +--
 crates/ide-completion/src/lib.rs                   |  2 +-
 crates/ide-completion/src/render/macro_.rs         |  6 ++---
 crates/ide-completion/src/tests.rs                 |  2 +-
 crates/ide-completion/src/tests/expression.rs      |  2 +-
 crates/ide-completion/src/tests/proc_macros.rs     |  4 +--
 crates/ide-db/src/assists.rs                       |  2 +-
 crates/ide-db/src/generated/lints.rs               |  4 +--
 crates/ide-db/src/source_change.rs                 |  2 +-
 crates/ide-db/src/syntax_helpers/format_string.rs  |  2 +-
 .../src/syntax_helpers/format_string_exprs.rs      |  2 +-
 crates/ide-db/src/use_trivial_constructor.rs       |  4 +--
 .../ide-diagnostics/src/handlers/incorrect_case.rs |  2 +-
 .../src/handlers/mutability_errors.rs              |  4 +--
 .../src/handlers/unresolved_field.rs               |  2 +-
 crates/ide/src/file_structure.rs                   |  2 +-
 crates/ide/src/fixture.rs                          |  2 +-
 crates/ide/src/hover/tests.rs                      |  6 ++---
 crates/ide/src/inlay_hints/adjustment.rs           | 10 ++++----
 crates/mbe/src/benchmark.rs                        |  4 +--
 crates/mbe/src/expander/matcher.rs                 |  2 +-
 crates/parser/src/grammar/types.rs                 |  2 +-
 .../parser/err/0027_incomplere_where_for.rast      | 29 ----------------------
 .../parser/err/0027_incomplere_where_for.rs        |  3 ---
 .../parser/err/0027_incomplete_where_for.rast      | 29 ++++++++++++++++++++++
 .../parser/err/0027_incomplete_where_for.rs        |  3 +++
 .../parser/err/0047_repated_extern_modifier.rast   | 15 -----------
 .../parser/err/0047_repated_extern_modifier.rs     |  1 -
 .../parser/err/0047_repeated_extern_modifier.rast  | 15 +++++++++++
 .../parser/err/0047_repeated_extern_modifier.rs    |  1 +
 .../test_data/parser/ok/0045_block_attrs.rast      |  2 +-
 .../parser/test_data/parser/ok/0045_block_attrs.rs |  2 +-
 crates/rust-analyzer/Cargo.toml                    |  2 +-
 crates/rust-analyzer/src/config.rs                 | 12 ++++-----
 crates/rust-analyzer/src/global_state.rs           |  2 +-
 crates/rust-analyzer/src/main_loop.rs              |  2 +-
 crates/syntax/src/parsing/reparsing.rs             |  6 ++---
 crates/syntax/src/validation.rs                    |  4 +--
 .../syntax/test_data/parser/fuzz-failures/0000.rs  |  4 +--
 docs/dev/lsp-extensions.md                         |  2 +-
 docs/user/generated_config.adoc                    |  6 ++---
 editors/code/package.json                          | 10 ++++----
 editors/code/src/run.ts                            |  2 +-
 87 files changed, 185 insertions(+), 184 deletions(-)
 delete mode 100644 crates/parser/test_data/parser/err/0027_incomplere_where_for.rast
 delete mode 100644 crates/parser/test_data/parser/err/0027_incomplere_where_for.rs
 create mode 100644 crates/parser/test_data/parser/err/0027_incomplete_where_for.rast
 create mode 100644 crates/parser/test_data/parser/err/0027_incomplete_where_for.rs
 delete mode 100644 crates/parser/test_data/parser/err/0047_repated_extern_modifier.rast
 delete mode 100644 crates/parser/test_data/parser/err/0047_repated_extern_modifier.rs
 create mode 100644 crates/parser/test_data/parser/err/0047_repeated_extern_modifier.rast
 create mode 100644 crates/parser/test_data/parser/err/0047_repeated_extern_modifier.rs

(limited to 'editors/code/src')

diff --git a/.github/actions/github-release/README.md b/.github/actions/github-release/README.md
index 7b50d002001..c73a5040271 100644
--- a/.github/actions/github-release/README.md
+++ b/.github/actions/github-release/README.md
@@ -10,7 +10,7 @@ perform github releases but they all tend to have their set of drawbacks.
 Additionally nothing handles deleting releases which we need for our rolling
 `dev` release.
 
-To handle all this this action rolls-its-own implementation using the
+To handle all this action rolls-its-own implementation using the
 actions/toolkit repository and packages published there. These run in a Docker
 container and take various inputs to orchestrate the release from the build.
 
diff --git a/.github/workflows/autopublish.yaml b/.github/workflows/autopublish.yaml
index 279f86b458d..7090c94d93c 100644
--- a/.github/workflows/autopublish.yaml
+++ b/.github/workflows/autopublish.yaml
@@ -32,7 +32,7 @@ jobs:
         shell: bash
         run: |
           git config --global user.email "runner@gha.local"
-          git config --global user.name "Github Action"
+          git config --global user.name "GitHub Action"
           rm Cargo.lock
           # Fix names for crates that were published before switch to kebab-case.
           cargo workspaces rename --from base-db base_db
diff --git a/.github/workflows/publish-libs.yaml b/.github/workflows/publish-libs.yaml
index 1b843fff1a4..c043573cacf 100644
--- a/.github/workflows/publish-libs.yaml
+++ b/.github/workflows/publish-libs.yaml
@@ -29,7 +29,7 @@ jobs:
         shell: bash
         run: |
           git config --global user.email "runner@gha.local"
-          git config --global user.name "Github Action"
+          git config --global user.name "GitHub Action"
           # Remove r-a crates from the workspaces so we don't auto-publish them as well
           sed -i 's/ "crates\/\*"//' ./Cargo.toml
           cargo workspaces publish --yes --exact --from-git --no-git-commit --allow-dirty
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 1e21214ffc4..c353737a35a 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -72,7 +72,7 @@
     },
     {
       // Used for testing the extension with a local build of the LSP server (in `target/release`)
-      // with all other extendions loaded.
+      // with all other extensions loaded.
       "name": "Run With Extensions",
       "type": "extensionHost",
       "request": "launch",
diff --git a/bench_data/glorious_old_parser b/bench_data/glorious_old_parser
index 764893daa12..f593f2b2955 100644
--- a/bench_data/glorious_old_parser
+++ b/bench_data/glorious_old_parser
@@ -3808,7 +3808,7 @@ impl<'a> Parser<'a> {
         if self.eat_keyword(keywords::Else) || !cond.returns() {
             let sp = self.sess.source_map().next_point(lo);
             let mut err = self.diagnostic()
-                .struct_span_err(sp, "missing condition for `if` statemement");
+                .struct_span_err(sp, "missing condition for `if` statement");
             err.span_label(sp, "expected if condition here");
             return Err(err)
         }
diff --git a/crates/hir-def/src/find_path.rs b/crates/hir-def/src/find_path.rs
index 3f439232083..30d6d019309 100644
--- a/crates/hir-def/src/find_path.rs
+++ b/crates/hir-def/src/find_path.rs
@@ -42,7 +42,7 @@ const MAX_PATH_LEN: usize = 15;
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum PrefixKind {
     /// Causes paths to always start with either `self`, `super`, `crate` or a crate-name.
-    /// This is the same as plain, just that paths will start with `self` iprepended f the path
+    /// This is the same as plain, just that paths will start with `self` prepended if the path
     /// starts with an identifier that is not a crate.
     BySelf,
     /// Causes paths to ignore imports in the local module.
diff --git a/crates/hir-def/src/hir.rs b/crates/hir-def/src/hir.rs
index 8709ad0e99b..1f4577629cc 100644
--- a/crates/hir-def/src/hir.rs
+++ b/crates/hir-def/src/hir.rs
@@ -502,7 +502,7 @@ impl Binding {
     pub fn is_upvar(&self, relative_to: ExprId) -> bool {
         match self.owner {
             Some(x) => {
-                // We assign expression ids in a way that outer closures will recieve
+                // We assign expression ids in a way that outer closures will receive
                 // a lower id
                 x.into_raw() < relative_to.into_raw()
             }
diff --git a/crates/hir-def/src/macro_expansion_tests/mbe.rs b/crates/hir-def/src/macro_expansion_tests/mbe.rs
index 7a3e8c3b05c..216c6a45746 100644
--- a/crates/hir-def/src/macro_expansion_tests/mbe.rs
+++ b/crates/hir-def/src/macro_expansion_tests/mbe.rs
@@ -98,7 +98,7 @@ fn#19 main#20(#21)#21 {#22
     );
 }
 #[test]
-fn float_field_acces_macro_input() {
+fn float_field_access_macro_input() {
     check(
         r#"
 macro_rules! foo {
diff --git a/crates/hir-def/src/nameres/proc_macro.rs b/crates/hir-def/src/nameres/proc_macro.rs
index caad4a1f381..751b7beaac1 100644
--- a/crates/hir-def/src/nameres/proc_macro.rs
+++ b/crates/hir-def/src/nameres/proc_macro.rs
@@ -52,7 +52,7 @@ impl Attrs {
 }
 
 // This fn is intended for `#[proc_macro_derive(..)]` and `#[rustc_builtin_macro(..)]`, which have
-// the same strucuture.
+// the same structure.
 #[rustfmt::skip]
 pub(crate) fn parse_macro_name_and_helper_attrs(tt: &[TokenTree]) -> Option<(Name, Box<[Name]>)> {
     match tt {
diff --git a/crates/hir-def/src/nameres/tests/mod_resolution.rs b/crates/hir-def/src/nameres/tests/mod_resolution.rs
index a0193128847..81bc0ff91e3 100644
--- a/crates/hir-def/src/nameres/tests/mod_resolution.rs
+++ b/crates/hir-def/src/nameres/tests/mod_resolution.rs
@@ -887,7 +887,7 @@ mod module;
 //- /module.rs
 #![cfg(NEVER)]
 
-struct AlsoShoulntAppear;
+struct AlsoShouldNotAppear;
         "#,
         expect![[r#"
             crate
diff --git a/crates/hir-expand/src/lib.rs b/crates/hir-expand/src/lib.rs
index d26fdbf7d61..74797622fec 100644
--- a/crates/hir-expand/src/lib.rs
+++ b/crates/hir-expand/src/lib.rs
@@ -694,7 +694,7 @@ impl ExpansionInfo {
                 (&attr_args.1, self.attr_input_or_mac_def.clone()?.syntax().cloned())
             }
             MacroCallKind::Attr { attr_args, .. } => {
-                // try unshifting the the token id, if unshifting fails, the token resides in the non-item attribute input
+                // try unshifting the token id, if unshifting fails, the token resides in the non-item attribute input
                 // note that the `TokenExpander::map_id_up` earlier only unshifts for declarative macros, so we don't double unshift with this
                 match self.macro_arg_shift.unshift(token_id) {
                     Some(unshifted) => {
diff --git a/crates/hir-ty/src/diagnostics/expr.rs b/crates/hir-ty/src/diagnostics/expr.rs
index d39e077b716..f346910da09 100644
--- a/crates/hir-ty/src/diagnostics/expr.rs
+++ b/crates/hir-ty/src/diagnostics/expr.rs
@@ -207,7 +207,7 @@ impl ExprValidator {
 
         let report = compute_match_usefulness(&cx, &m_arms, scrut_ty);
 
-        // FIXME Report unreacheble arms
+        // FIXME Report unreachable arms
         // https://github.com/rust-lang/rust/blob/f31622a50/compiler/rustc_mir_build/src/thir/pattern/check_match.rs#L200
 
         let witnesses = report.non_exhaustiveness_witnesses;
diff --git a/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs b/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs
index b103fdc709d..7460f43387f 100644
--- a/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs
+++ b/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs
@@ -82,7 +82,7 @@ fn expand_or_pat(pat: &Pat) -> Vec<&Pat> {
     pats
 }
 
-/// [Constructor] uses this in umimplemented variants.
+/// [Constructor] uses this in unimplemented variants.
 /// It allows porting match expressions from upstream algorithm without losing semantics.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub(super) enum Void {}
diff --git a/crates/hir-ty/src/diagnostics/match_check/pat_util.rs b/crates/hir-ty/src/diagnostics/match_check/pat_util.rs
index b89b4f2bfb7..217454499ef 100644
--- a/crates/hir-ty/src/diagnostics/match_check/pat_util.rs
+++ b/crates/hir-ty/src/diagnostics/match_check/pat_util.rs
@@ -1,4 +1,4 @@
-//! Pattern untilities.
+//! Pattern utilities.
 //!
 //! Originates from `rustc_hir::pat_util`
 
diff --git a/crates/hir-ty/src/diagnostics/match_check/usefulness.rs b/crates/hir-ty/src/diagnostics/match_check/usefulness.rs
index c4d709a975b..d737b24ad32 100644
--- a/crates/hir-ty/src/diagnostics/match_check/usefulness.rs
+++ b/crates/hir-ty/src/diagnostics/match_check/usefulness.rs
@@ -755,7 +755,7 @@ pub(crate) enum Reachability {
     /// The arm is reachable. This additionally carries a set of or-pattern branches that have been
     /// found to be unreachable despite the overall arm being reachable. Used only in the presence
     /// of or-patterns, otherwise it stays empty.
-    // FIXME: store ureachable subpattern IDs
+    // FIXME: store unreachable subpattern IDs
     Reachable,
     /// The arm is unreachable.
     Unreachable,
diff --git a/crates/hir-ty/src/infer.rs b/crates/hir-ty/src/infer.rs
index d90ca77b55c..158cc289a01 100644
--- a/crates/hir-ty/src/infer.rs
+++ b/crates/hir-ty/src/infer.rs
@@ -483,7 +483,7 @@ pub(crate) struct InferenceContext<'a> {
     current_closure: Option<ClosureId>,
     /// Stores the list of closure ids that need to be analyzed before this closure. See the
     /// comment on `InferenceContext::sort_closures`
-    closure_dependecies: FxHashMap<ClosureId, Vec<ClosureId>>,
+    closure_dependencies: FxHashMap<ClosureId, Vec<ClosureId>>,
     deferred_closures: FxHashMap<ClosureId, Vec<(Ty, Ty, Vec<Ty>, ExprId)>>,
 }
 
@@ -555,7 +555,7 @@ impl<'a> InferenceContext<'a> {
             current_captures: vec![],
             current_closure: None,
             deferred_closures: FxHashMap::default(),
-            closure_dependecies: FxHashMap::default(),
+            closure_dependencies: FxHashMap::default(),
         }
     }
 
diff --git a/crates/hir-ty/src/infer/closure.rs b/crates/hir-ty/src/infer/closure.rs
index 28cb301f3e4..afacb8ef1c9 100644
--- a/crates/hir-ty/src/infer/closure.rs
+++ b/crates/hir-ty/src/infer/closure.rs
@@ -756,7 +756,7 @@ impl InferenceContext<'_> {
         let mut deferred_closures = mem::take(&mut self.deferred_closures);
         let mut dependents_count: FxHashMap<ClosureId, usize> =
             deferred_closures.keys().map(|x| (*x, 0)).collect();
-        for (_, deps) in &self.closure_dependecies {
+        for (_, deps) in &self.closure_dependencies {
             for dep in deps {
                 *dependents_count.entry(*dep).or_default() += 1;
             }
@@ -768,7 +768,7 @@ impl InferenceContext<'_> {
             if let Some(d) = deferred_closures.remove(&x) {
                 result.push((x, d));
             }
-            for dep in self.closure_dependecies.get(&x).into_iter().flat_map(|x| x.iter()) {
+            for dep in self.closure_dependencies.get(&x).into_iter().flat_map(|x| x.iter()) {
                 let cnt = dependents_count.get_mut(dep).unwrap();
                 *cnt -= 1;
                 if *cnt == 0 {
diff --git a/crates/hir-ty/src/infer/expr.rs b/crates/hir-ty/src/infer/expr.rs
index 64f37c761e9..2c37d25f54b 100644
--- a/crates/hir-ty/src/infer/expr.rs
+++ b/crates/hir-ty/src/infer/expr.rs
@@ -287,7 +287,7 @@ impl<'a> InferenceContext<'a> {
                         .intern(Interner);
                         self.deferred_closures.entry(closure_id).or_default();
                         if let Some(c) = self.current_closure {
-                            self.closure_dependecies.entry(c).or_default().push(closure_id);
+                            self.closure_dependencies.entry(c).or_default().push(closure_id);
                         }
                         (Some(closure_id), closure_ty, None)
                     }
@@ -349,7 +349,7 @@ impl<'a> InferenceContext<'a> {
                             self.table.resolve_completely(callee_ty.clone()).kind(Interner)
                         {
                             if let Some(par) = self.current_closure {
-                                self.closure_dependecies.entry(par).or_default().push(*c);
+                                self.closure_dependencies.entry(par).or_default().push(*c);
                             }
                             self.deferred_closures.entry(*c).or_default().push((
                                 derefed_callee.clone(),
diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs
index 50fe5a724d0..03536be8847 100644
--- a/crates/hir-ty/src/lib.rs
+++ b/crates/hir-ty/src/lib.rs
@@ -148,7 +148,7 @@ pub type Guidance = chalk_solve::Guidance<Interner>;
 pub type WhereClause = chalk_ir::WhereClause<Interner>;
 
 /// A constant can have reference to other things. Memory map job is holding
-/// the neccessary bits of memory of the const eval session to keep the constant
+/// the necessary bits of memory of the const eval session to keep the constant
 /// meaningful.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct MemoryMap(pub HashMap<usize, Vec<u8>>);
diff --git a/crates/hir-ty/src/mir.rs b/crates/hir-ty/src/mir.rs
index 2fa1bf2b7e6..d830ae263ba 100644
--- a/crates/hir-ty/src/mir.rs
+++ b/crates/hir-ty/src/mir.rs
@@ -55,7 +55,7 @@ pub struct Local {
 /// This is what is implemented in miri today. Are these the semantics we want for MIR? Is this
 /// something we can even decide without knowing more about Rust's memory model?
 ///
-/// **Needs clarifiation:** Is loading a place that has its variant index set well-formed? Miri
+/// **Needs clarification:** Is loading a place that has its variant index set well-formed? Miri
 /// currently implements it, but it seems like this may be something to check against in the
 /// validator.
 #[derive(Debug, PartialEq, Eq, Clone)]
diff --git a/crates/hir-ty/src/mir/borrowck.rs b/crates/hir-ty/src/mir/borrowck.rs
index 5b2bca955f5..016090d509b 100644
--- a/crates/hir-ty/src/mir/borrowck.rs
+++ b/crates/hir-ty/src/mir/borrowck.rs
@@ -110,7 +110,7 @@ fn place_case(lvalue: &Place) -> ProjectionCase {
 
 /// Returns a map from basic blocks to the set of locals that might be ever initialized before
 /// the start of the block. Only `StorageDead` can remove something from this map, and we ignore
-/// `Uninit` and `drop` and similars after initialization.
+/// `Uninit` and `drop` and similar after initialization.
 fn ever_initialized_map(body: &MirBody) -> ArenaMap<BasicBlockId, ArenaMap<LocalId, bool>> {
     let mut result: ArenaMap<BasicBlockId, ArenaMap<LocalId, bool>> =
         body.basic_blocks.iter().map(|x| (x.0, ArenaMap::default())).collect();
diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs
index 8c911b7f7b7..7b01cc39dd1 100644
--- a/crates/hir-ty/src/mir/eval.rs
+++ b/crates/hir-ty/src/mir/eval.rs
@@ -123,7 +123,7 @@ impl Interval {
     }
 
     fn write_from_interval(&self, memory: &mut Evaluator<'_>, interval: Interval) -> Result<()> {
-        // FIXME: this could be more efficent
+        // FIXME: this could be more efficient
         let bytes = &interval.get(memory)?.to_vec();
         memory.write_memory(self.addr, bytes)
     }
@@ -692,7 +692,7 @@ impl Evaluator<'_> {
                         Owned(r[0..lc.len()].into())
                     }
                     BinOp::Shl | BinOp::Shr => {
-                        let shift_amout = if r128 < 0 {
+                        let shift_amount = if r128 < 0 {
                             return Err(MirEvalError::Panic(format!("Overflow in {op:?}")));
                         } else if r128 > 128 {
                             return Err(MirEvalError::Panic(format!("Overflow in {op:?}")));
@@ -700,8 +700,8 @@ impl Evaluator<'_> {
                             r128 as u8
                         };
                         let r = match op {
-                            BinOp::Shl => l128 << shift_amout,
-                            BinOp::Shr => l128 >> shift_amout,
+                            BinOp::Shl => l128 << shift_amount,
+                            BinOp::Shr => l128 >> shift_amount,
                             _ => unreachable!(),
                         };
                         Owned(r.to_le_bytes()[0..lc.len()].into())
@@ -966,7 +966,7 @@ impl Evaluator<'_> {
 
     fn make_by_layout(
         &mut self,
-        size: usize, // Not neccessarily equal to variant_layout.size
+        size: usize, // Not necessarily equal to variant_layout.size
         variant_layout: &Layout,
         tag: Option<(usize, usize, i128)>,
         values: impl Iterator<Item = Interval>,
@@ -1481,7 +1481,7 @@ impl Evaluator<'_> {
                 is_dyn_method(self.db, self.trait_env.clone(), def, generic_args.clone())
             {
                 // In the layout of current possible receiver, which at the moment of writing this code is one of
-                // `&T`, `&mut T`, `Box<T>`, `Rc<T>`, `Arc<T>`, and `Pin<P>` where `P` is one of possible recievers,
+                // `&T`, `&mut T`, `Box<T>`, `Rc<T>`, `Arc<T>`, and `Pin<P>` where `P` is one of possible receivers,
                 // the vtable is exactly in the `[ptr_size..2*ptr_size]` bytes. So we can use it without branching on
                 // the type.
                 let ty = self
diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
index 78a2d90f7fb..da5d1aff0a0 100644
--- a/crates/hir-ty/src/mir/lower.rs
+++ b/crates/hir-ty/src/mir/lower.rs
@@ -1206,7 +1206,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         );
         let prev_label = if let Some(label) = label {
             // We should generate the end now, to make sure that it wouldn't change later. It is
-            // bad as we may emit end (unneccessary unreachable block) for unterminating loop, but
+            // bad as we may emit end (unnecessary unreachable block) for unterminating loop, but
             // it should not affect correctness.
             self.current_loop_end()?;
             self.labeled_loop_blocks
@@ -1278,7 +1278,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
     /// the appropriated places.
     fn push_storage_live(&mut self, b: BindingId, current: BasicBlockId) -> Result<()> {
         // Current implementation is wrong. It adds no `StorageDead` at the end of scope, and before each break
-        // and continue. It just add a `StorageDead` before the `StorageLive`, which is not wrong, but unneeeded in
+        // and continue. It just add a `StorageDead` before the `StorageLive`, which is not wrong, but unneeded in
         // the proper implementation. Due this limitation, implementing a borrow checker on top of this mir will falsely
         // allow this:
         //
diff --git a/crates/hir-ty/src/mir/lower/pattern_matching.rs b/crates/hir-ty/src/mir/lower/pattern_matching.rs
index 12a77715e9c..a5b48b6b936 100644
--- a/crates/hir-ty/src/mir/lower/pattern_matching.rs
+++ b/crates/hir-ty/src/mir/lower/pattern_matching.rs
@@ -23,7 +23,7 @@ impl MirLowerCtx<'_> {
     /// mismatched path block is `None`.
     ///
     /// By default, it will create a new block for mismatched path. If you already have one, you can provide it with
-    /// `current_else` argument to save an unneccessary jump. If `current_else` isn't `None`, the result mismatched path
+    /// `current_else` argument to save an unnecessary jump. If `current_else` isn't `None`, the result mismatched path
     /// wouldn't be `None` as well. Note that this function will add jumps to the beginning of the `current_else` block,
     /// so it should be an empty block.
     pub(super) fn pattern_match(
diff --git a/crates/hir-ty/src/tests/regression.rs b/crates/hir-ty/src/tests/regression.rs
index 28b87689ecd..4af143829f3 100644
--- a/crates/hir-ty/src/tests/regression.rs
+++ b/crates/hir-ty/src/tests/regression.rs
@@ -1060,7 +1060,7 @@ fn infix_parse<T, S>(_state: S, _level_code: &Fn(S)) -> T {
     loop {}
 }
 
-fn parse_arule() {
+fn parse_a_rule() {
     infix_parse((), &(|_recurse| ()))
 }
         "#,
diff --git a/crates/hir-ty/src/tests/traits.rs b/crates/hir-ty/src/tests/traits.rs
index fdfae44c2d1..857891a2148 100644
--- a/crates/hir-ty/src/tests/traits.rs
+++ b/crates/hir-ty/src/tests/traits.rs
@@ -4250,7 +4250,7 @@ impl Trait for () {
 }
 
 #[test]
-fn associted_type_in_struct_expr_path_enum() {
+fn associated_type_in_struct_expr_path_enum() {
     // FIXME: All annotation should be resolvable.
     // For lines marked as unstable, see rust-lang/rust#86935.
     // FIXME: Remove the comments once stablized.
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index db923cb0fe2..0d1bf9be5a7 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -801,7 +801,7 @@ fn precise_macro_call_location(
     ast: &MacroCallKind,
     db: &dyn HirDatabase,
 ) -> (InFile<SyntaxNodePtr>, Option<TextRange>, Option<String>, MacroKind) {
-    // FIXME: maaybe we actually want slightly different ranges for the different macro diagnostics
+    // FIXME: maybe we actually want slightly different ranges for the different macro diagnostics
     // - e.g. the full attribute for macro errors, but only the name for name resolution
     match ast {
         MacroCallKind::FnLike { ast_id, .. } => {
@@ -1522,7 +1522,7 @@ impl DefWithBody {
             match source_map.expr_syntax(expr) {
                 Ok(expr) => acc.push(MissingUnsafe { expr }.into()),
                 Err(SyntheticSyntax) => {
-                    // FIXME: Here and eslwhere in this file, the `expr` was
+                    // FIXME: Here and elsewhere in this file, the `expr` was
                     // desugared, report or assert that this doesn't happen.
                 }
             }
@@ -3654,7 +3654,7 @@ impl Type {
         self.as_adt()
             .and_then(|a| a.lifetime(db).and_then(|lt| Some((&lt.name).to_smol_str())))
             .into_iter()
-            // add the type and const paramaters
+            // add the type and const parameters
             .chain(self.type_and_const_arguments(db))
     }
 
diff --git a/crates/ide-assists/src/handlers/add_missing_impl_members.rs b/crates/ide-assists/src/handlers/add_missing_impl_members.rs
index 4e11b31deb0..9e4e6c1daf7 100644
--- a/crates/ide-assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ide-assists/src/handlers/add_missing_impl_members.rs
@@ -252,7 +252,7 @@ impl Foo for S {
     }
 
     #[test]
-    fn test_copied_overriden_members() {
+    fn test_copied_overridden_members() {
         check_assist(
             add_missing_impl_members,
             r#"
diff --git a/crates/ide-assists/src/handlers/auto_import.rs b/crates/ide-assists/src/handlers/auto_import.rs
index 698ad78cce6..17ffb861fdd 100644
--- a/crates/ide-assists/src/handlers/auto_import.rs
+++ b/crates/ide-assists/src/handlers/auto_import.rs
@@ -203,7 +203,7 @@ fn relevance_score(
         // get the distance between the imported path and the current module
         // (prefer items that are more local)
         Some((item_module, current_module)) => {
-            score -= module_distance_hueristic(db, current_module, &item_module) as i32;
+            score -= module_distance_heuristic(db, current_module, &item_module) as i32;
         }
 
         // could not find relevant modules, so just use the length of the path as an estimate
@@ -214,7 +214,7 @@ fn relevance_score(
 }
 
 /// A heuristic that gives a higher score to modules that are more separated.
-fn module_distance_hueristic(db: &dyn HirDatabase, current: &Module, item: &Module) -> usize {
+fn module_distance_heuristic(db: &dyn HirDatabase, current: &Module, item: &Module) -> usize {
     // get the path starting from the item to the respective crate roots
     let mut current_path = current.path_to_root(db);
     let mut item_path = item.path_to_root(db);
diff --git a/crates/ide-assists/src/handlers/convert_to_guarded_return.rs b/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
index b97be34c5f7..dcb96ab8af4 100644
--- a/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
+++ b/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
@@ -504,7 +504,7 @@ fn main() {
     }
 
     #[test]
-    fn ignore_statements_aftert_if() {
+    fn ignore_statements_after_if() {
         check_assist_not_applicable(
             convert_to_guarded_return,
             r#"
diff --git a/crates/ide-assists/src/handlers/extract_function.rs b/crates/ide-assists/src/handlers/extract_function.rs
index 728018506d1..58605f7ed57 100644
--- a/crates/ide-assists/src/handlers/extract_function.rs
+++ b/crates/ide-assists/src/handlers/extract_function.rs
@@ -374,7 +374,7 @@ struct OutlivedLocal {
 
 /// Container of local variable usages
 ///
-/// Semanticall same as `UsageSearchResult`, but provides more convenient interface
+/// Semantically same as `UsageSearchResult`, but provides more convenient interface
 struct LocalUsages(ide_db::search::UsageSearchResult);
 
 impl LocalUsages {
@@ -1291,8 +1291,8 @@ fn find_non_trait_impl(trait_impl: &SyntaxNode) -> Option<ast::Impl> {
     let as_impl = ast::Impl::cast(trait_impl.clone())?;
     let impl_type = Some(impl_type_name(&as_impl)?);
 
-    let sibblings = trait_impl.parent()?.children();
-    sibblings
+    let siblings = trait_impl.parent()?.children();
+    siblings
         .filter_map(ast::Impl::cast)
         .find(|s| impl_type_name(s) == impl_type && !is_trait_impl(s))
 }
diff --git a/crates/ide-assists/src/handlers/extract_module.rs b/crates/ide-assists/src/handlers/extract_module.rs
index 0fa7bd558bb..795691d73ed 100644
--- a/crates/ide-assists/src/handlers/extract_module.rs
+++ b/crates/ide-assists/src/handlers/extract_module.rs
@@ -357,7 +357,7 @@ impl Module {
 
     fn change_visibility(&mut self, record_fields: Vec<SyntaxNode>) {
         let (mut replacements, record_field_parents, impls) =
-            get_replacements_for_visibilty_change(&mut self.body_items, false);
+            get_replacements_for_visibility_change(&mut self.body_items, false);
 
         let mut impl_items: Vec<ast::Item> = impls
             .into_iter()
@@ -366,7 +366,7 @@ impl Module {
             .collect();
 
         let (mut impl_item_replacements, _, _) =
-            get_replacements_for_visibilty_change(&mut impl_items, true);
+            get_replacements_for_visibility_change(&mut impl_items, true);
 
         replacements.append(&mut impl_item_replacements);
 
@@ -824,7 +824,7 @@ fn does_source_exists_outside_sel_in_same_mod(
     source_exists_outside_sel_in_same_mod
 }
 
-fn get_replacements_for_visibilty_change(
+fn get_replacements_for_visibility_change(
     items: &mut [ast::Item],
     is_clone_for_updated: bool,
 ) -> (
@@ -1236,7 +1236,8 @@ mod modname {
     }
 
     #[test]
-    fn test_extract_module_for_correspoding_adt_of_impl_present_in_same_mod_but_not_in_selection() {
+    fn test_extract_module_for_corresponding_adt_of_impl_present_in_same_mod_but_not_in_selection()
+    {
         check_assist(
             extract_module,
             r"
diff --git a/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
index 49debafe1a0..f75df287867 100644
--- a/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -1006,7 +1006,7 @@ enum X<'a, 'b, 'x> {
     }
 
     #[test]
-    fn test_extract_struct_with_liftime_type_const() {
+    fn test_extract_struct_with_lifetime_type_const() {
         check_assist(
             extract_struct_from_enum_variant,
             r#"
diff --git a/crates/ide-assists/src/handlers/generate_documentation_template.rs b/crates/ide-assists/src/handlers/generate_documentation_template.rs
index b8415c72a2a..e87132218ea 100644
--- a/crates/ide-assists/src/handlers/generate_documentation_template.rs
+++ b/crates/ide-assists/src/handlers/generate_documentation_template.rs
@@ -324,7 +324,7 @@ fn self_name(ast_func: &ast::Fn) -> Option<String> {
     self_partial_type(ast_func).map(|name| to_lower_snake_case(&name))
 }
 
-/// Heper function to get the name of the type of `self`
+/// Helper function to get the name of the type of `self`
 fn self_type(ast_func: &ast::Fn) -> Option<ast::Type> {
     ast_func.syntax().ancestors().find_map(ast::Impl::cast).and_then(|i| i.self_ty())
 }
@@ -350,7 +350,7 @@ fn self_type_without_lifetimes(ast_func: &ast::Fn) -> Option<String> {
     Some(name)
 }
 
-/// Heper function to get the name of the type of `self` without generic arguments
+/// Helper function to get the name of the type of `self` without generic arguments
 fn self_partial_type(ast_func: &ast::Fn) -> Option<String> {
     let mut self_type = self_type(ast_func)?.to_string();
     if let Some(idx) = self_type.find(|c| ['<', ' '].contains(&c)) {
diff --git a/crates/ide-assists/src/handlers/generate_function.rs b/crates/ide-assists/src/handlers/generate_function.rs
index a5556878be6..739b466b311 100644
--- a/crates/ide-assists/src/handlers/generate_function.rs
+++ b/crates/ide-assists/src/handlers/generate_function.rs
@@ -893,14 +893,14 @@ fn filter_bounds_in_scope(
     let target_impl = target.parent().ancestors().find_map(ast::Impl::cast)?;
     let target_impl = ctx.sema.to_def(&target_impl)?;
     // It's sufficient to test only the first element of `generic_params` because of the order of
-    // insertion (see `relevant_parmas_and_where_clauses()`).
+    // insertion (see `params_and_where_preds_in_scope()`).
     let def = generic_params.first()?.self_ty_param.parent();
     if def != hir::GenericDef::Impl(target_impl) {
         return None;
     }
 
     // Now we know every element that belongs to an impl would be in scope at `target`, we can
-    // filter them out just by lookint at their parent.
+    // filter them out just by looking at their parent.
     generic_params.retain(|it| !matches!(it.self_ty_param.parent(), hir::GenericDef::Impl(_)));
     where_preds.retain(|it| {
         it.node.syntax().parent().and_then(|it| it.parent()).and_then(ast::Impl::cast).is_none()
@@ -1087,7 +1087,7 @@ fn calculate_necessary_visibility(
     }
 }
 
-// This is never intended to be used as a generic graph strucuture. If there's ever another need of
+// This is never intended to be used as a generic graph structure. If there's ever another need of
 // graph algorithm, consider adding a library for that (and replace the following).
 /// Minimally implemented directed graph structure represented by adjacency list.
 struct Graph {
@@ -2380,7 +2380,7 @@ mod s {
     }
 
     #[test]
-    fn create_method_with_cursor_anywhere_on_call_expresion() {
+    fn create_method_with_cursor_anywhere_on_call_expression() {
         check_assist(
             generate_function,
             r"
@@ -2487,7 +2487,7 @@ fn foo() {s::S::bar();}
     }
 
     #[test]
-    fn create_static_method_with_cursor_anywhere_on_call_expresion() {
+    fn create_static_method_with_cursor_anywhere_on_call_expression() {
         check_assist(
             generate_function,
             r"
diff --git a/crates/ide-assists/src/handlers/generate_getter.rs b/crates/ide-assists/src/handlers/generate_getter.rs
index 4595cfe29c8..dd6bbd84afc 100644
--- a/crates/ide-assists/src/handlers/generate_getter.rs
+++ b/crates/ide-assists/src/handlers/generate_getter.rs
@@ -174,7 +174,7 @@ pub(crate) fn generate_getter_impl(
                 // this buf inserts a newline at the end of a getter
                 // automatically, if one wants to add one more newline
                 // for separating it from other assoc items, that needs
-                // to be handled spearately
+                // to be handled separately
                 let mut getter_buf =
                     generate_getter_from_info(ctx, &getter_info, record_field_info);
 
diff --git a/crates/ide-assists/src/handlers/generate_new.rs b/crates/ide-assists/src/handlers/generate_new.rs
index e30a3e942c4..824255e4f8e 100644
--- a/crates/ide-assists/src/handlers/generate_new.rs
+++ b/crates/ide-assists/src/handlers/generate_new.rs
@@ -98,9 +98,9 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
             .fields()
             .enumerate()
             .filter_map(|(i, f)| {
-                let contructor = trivial_constructors[i].clone();
-                if contructor.is_some() {
-                    contructor
+                let constructor = trivial_constructors[i].clone();
+                if constructor.is_some() {
+                    constructor
                 } else {
                     Some(f.name()?.to_string())
                 }
diff --git a/crates/ide-assists/src/handlers/inline_macro.rs b/crates/ide-assists/src/handlers/inline_macro.rs
index 626f2060b23..5aa8e56f562 100644
--- a/crates/ide-assists/src/handlers/inline_macro.rs
+++ b/crates/ide-assists/src/handlers/inline_macro.rs
@@ -148,7 +148,7 @@ macro_rules! num {
     #[test]
     fn inline_macro_simple_not_applicable_broken_macro() {
         // FIXME: This is a bug. The macro should not expand, but it's
-        // the same behaviour as the "Expand Macro Recursively" commmand
+        // the same behaviour as the "Expand Macro Recursively" command
         // so it's presumably OK for the time being.
         check_assist(
             inline_macro,
diff --git a/crates/ide-assists/src/handlers/introduce_named_lifetime.rs b/crates/ide-assists/src/handlers/introduce_named_lifetime.rs
index a54dc4f96de..c5aa9755bc0 100644
--- a/crates/ide-assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/ide-assists/src/handlers/introduce_named_lifetime.rs
@@ -66,7 +66,7 @@ fn generate_fn_def_assist(
         // if we have a self reference, use that
         Some(NeedsLifetime::SelfParam(self_param))
     } else {
-        // otherwise, if there's a single reference parameter without a named liftime, use that
+        // otherwise, if there's a single reference parameter without a named lifetime, use that
         let fn_params_without_lifetime: Vec<_> = param_list
             .params()
             .filter_map(|param| match param.ty() {
@@ -79,7 +79,7 @@ fn generate_fn_def_assist(
         match fn_params_without_lifetime.len() {
             1 => Some(fn_params_without_lifetime.into_iter().next()?),
             0 => None,
-            // multiple unnnamed is invalid. assist is not applicable
+            // multiple unnamed is invalid. assist is not applicable
             _ => return None,
         }
     };
diff --git a/crates/ide-assists/src/handlers/pull_assignment_up.rs b/crates/ide-assists/src/handlers/pull_assignment_up.rs
index 4cfe6c99b23..a5c7fea403d 100644
--- a/crates/ide-assists/src/handlers/pull_assignment_up.rs
+++ b/crates/ide-assists/src/handlers/pull_assignment_up.rs
@@ -386,7 +386,7 @@ fn foo() {
     }
 
     #[test]
-    fn pull_assignment_up_if_missing_assigment_not_applicable() {
+    fn pull_assignment_up_if_missing_assignment_not_applicable() {
         check_assist_not_applicable(
             pull_assignment_up,
             r#"
@@ -401,7 +401,7 @@ fn foo() {
     }
 
     #[test]
-    fn pull_assignment_up_match_missing_assigment_not_applicable() {
+    fn pull_assignment_up_match_missing_assignment_not_applicable() {
         check_assist_not_applicable(
             pull_assignment_up,
             r#"
diff --git a/crates/ide-assists/src/handlers/qualify_method_call.rs b/crates/ide-assists/src/handlers/qualify_method_call.rs
index e7014597a1d..4bf974a5655 100644
--- a/crates/ide-assists/src/handlers/qualify_method_call.rs
+++ b/crates/ide-assists/src/handlers/qualify_method_call.rs
@@ -507,7 +507,7 @@ fn main() {
     }
 
     #[test]
-    fn struct_method_over_stuct_instance() {
+    fn struct_method_over_struct_instance() {
         check_assist_not_applicable(
             qualify_method_call,
             r#"
@@ -525,7 +525,7 @@ fn main() {
     }
 
     #[test]
-    fn trait_method_over_stuct_instance() {
+    fn trait_method_over_struct_instance() {
         check_assist_not_applicable(
             qualify_method_call,
             r#"
diff --git a/crates/ide-assists/src/handlers/remove_parentheses.rs b/crates/ide-assists/src/handlers/remove_parentheses.rs
index e9c7c6bae9c..ffc32f80499 100644
--- a/crates/ide-assists/src/handlers/remove_parentheses.rs
+++ b/crates/ide-assists/src/handlers/remove_parentheses.rs
@@ -124,7 +124,7 @@ mod tests {
     }
 
     #[test]
-    fn remove_parens_doesnt_apply_weird_syntax_and_adge_cases() {
+    fn remove_parens_doesnt_apply_weird_syntax_and_edge_cases() {
         // removing `()` would break code because {} would be counted as the loop/if body
         check_assist_not_applicable(remove_parentheses, r#"fn f() { for _ in $0(0..{3}) {} }"#);
         check_assist_not_applicable(remove_parentheses, r#"fn f() { for _ in $0(S {}) {} }"#);
diff --git a/crates/ide-assists/src/handlers/remove_unused_param.rs b/crates/ide-assists/src/handlers/remove_unused_param.rs
index bd2e8fbe389..0772b168d49 100644
--- a/crates/ide-assists/src/handlers/remove_unused_param.rs
+++ b/crates/ide-assists/src/handlers/remove_unused_param.rs
@@ -232,7 +232,7 @@ fn b() { foo( ) }
     }
 
     #[test]
-    fn remove_unused_surrounded_by_parms() {
+    fn remove_unused_surrounded_by_params() {
         check_assist(
             remove_unused_param,
             r#"
diff --git a/crates/ide-assists/src/handlers/replace_string_with_char.rs b/crates/ide-assists/src/handlers/replace_string_with_char.rs
index decb5fb62a7..6310981ccce 100644
--- a/crates/ide-assists/src/handlers/replace_string_with_char.rs
+++ b/crates/ide-assists/src/handlers/replace_string_with_char.rs
@@ -31,14 +31,14 @@ pub(crate) fn replace_string_with_char(acc: &mut Assists, ctx: &AssistContext<'_
     if value.chars().take(2).count() != 1 {
         return None;
     }
-    let quote_offets = token.quote_offsets()?;
+    let quote_offsets = token.quote_offsets()?;
 
     acc.add(
         AssistId("replace_string_with_char", AssistKind::RefactorRewrite),
         "Replace string with char",
         target,
         |edit| {
-            let (left, right) = quote_offets.quotes;
+            let (left, right) = quote_offsets.quotes;
             edit.replace(left, '\'');
             edit.replace(right, '\'');
             if value == "'" {
diff --git a/crates/ide-completion/src/context/analysis.rs b/crates/ide-completion/src/context/analysis.rs
index a94c404586b..94787abf73b 100644
--- a/crates/ide-completion/src/context/analysis.rs
+++ b/crates/ide-completion/src/context/analysis.rs
@@ -609,14 +609,14 @@ fn classify_name_ref(
                     _ => false,
                 };
 
-                let reciever_is_part_of_indivisible_expression = match &receiver {
+                let receiver_is_part_of_indivisible_expression = match &receiver {
                     Some(ast::Expr::IfExpr(_)) => {
                         let next_token_kind = next_non_trivia_token(name_ref.syntax().clone()).map(|t| t.kind());
                         next_token_kind == Some(SyntaxKind::ELSE_KW)
                     },
                     _ => false
                 };
-                if reciever_is_part_of_indivisible_expression {
+                if receiver_is_part_of_indivisible_expression {
                     return None;
                 }
 
diff --git a/crates/ide-completion/src/lib.rs b/crates/ide-completion/src/lib.rs
index a06b7e95778..a88798563de 100644
--- a/crates/ide-completion/src/lib.rs
+++ b/crates/ide-completion/src/lib.rs
@@ -133,7 +133,7 @@ pub use crate::{
 ///
 /// Another case where this would be instrumental is macro expansion. We want to
 /// insert a fake ident and re-expand code. There's `expand_speculative` as a
-/// work-around for this.
+/// workaround for this.
 ///
 /// A different use-case is completion of injection (examples and links in doc
 /// comments). When computing completion for a path in a doc-comment, you want
diff --git a/crates/ide-completion/src/render/macro_.rs b/crates/ide-completion/src/render/macro_.rs
index 44e88607633..ce7af1d3400 100644
--- a/crates/ide-completion/src/render/macro_.rs
+++ b/crates/ide-completion/src/render/macro_.rs
@@ -74,7 +74,7 @@ fn render(
             item.insert_text(banged_name(&escaped_name)).lookup_by(banged_name(&name));
         }
         _ => {
-            cov_mark::hit!(dont_insert_macro_call_parens_unncessary);
+            cov_mark::hit!(dont_insert_macro_call_parens_unnecessary);
             item.insert_text(escaped_name);
         }
     };
@@ -140,8 +140,8 @@ mod tests {
     use crate::tests::check_edit;
 
     #[test]
-    fn dont_insert_macro_call_parens_unncessary() {
-        cov_mark::check!(dont_insert_macro_call_parens_unncessary);
+    fn dont_insert_macro_call_parens_unnecessary() {
+        cov_mark::check!(dont_insert_macro_call_parens_unnecessary);
         check_edit(
             "frobnicate",
             r#"
diff --git a/crates/ide-completion/src/tests.rs b/crates/ide-completion/src/tests.rs
index 79c1f98f3bd..ef4c939fe64 100644
--- a/crates/ide-completion/src/tests.rs
+++ b/crates/ide-completion/src/tests.rs
@@ -105,7 +105,7 @@ fn completion_list_with_config(
     include_keywords: bool,
     trigger_character: Option<char>,
 ) -> String {
-    // filter out all but one builtintype completion for smaller test outputs
+    // filter out all but one built-in type completion for smaller test outputs
     let items = get_all_items(config, ra_fixture, trigger_character);
     let items = items
         .into_iter()
diff --git a/crates/ide-completion/src/tests/expression.rs b/crates/ide-completion/src/tests/expression.rs
index 36465be23d8..be5b7f8a340 100644
--- a/crates/ide-completion/src/tests/expression.rs
+++ b/crates/ide-completion/src/tests/expression.rs
@@ -667,7 +667,7 @@ fn main() {
 }
 
 #[test]
-fn varaiant_with_struct() {
+fn variant_with_struct() {
     check_empty(
         r#"
 pub struct YoloVariant {
diff --git a/crates/ide-completion/src/tests/proc_macros.rs b/crates/ide-completion/src/tests/proc_macros.rs
index 92ea4d15b85..2d6234e310c 100644
--- a/crates/ide-completion/src/tests/proc_macros.rs
+++ b/crates/ide-completion/src/tests/proc_macros.rs
@@ -81,7 +81,7 @@ impl Foo {
 }
 
 #[proc_macros::input_replace(
-    fn suprise() {
+    fn surprise() {
         Foo.$0
     }
 )]
@@ -114,7 +114,7 @@ impl Foo {
 }
 
 #[proc_macros::input_replace(
-    fn suprise() {
+    fn surprise() {
         Foo.f$0
     }
 )]
diff --git a/crates/ide-db/src/assists.rs b/crates/ide-db/src/assists.rs
index 8c6c1c44aa7..7a7328f312d 100644
--- a/crates/ide-db/src/assists.rs
+++ b/crates/ide-db/src/assists.rs
@@ -98,7 +98,7 @@ impl FromStr for AssistKind {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AssistId(pub &'static str, pub AssistKind);
 
-/// A way to control how many asssist to resolve during the assist resolution.
+/// A way to control how many assist to resolve during the assist resolution.
 /// When an assist is resolved, its edits are calculated that might be costly to always do by default.
 #[derive(Debug)]
 pub enum AssistResolveStrategy {
diff --git a/crates/ide-db/src/generated/lints.rs b/crates/ide-db/src/generated/lints.rs
index f0c3690962a..e488300b41c 100644
--- a/crates/ide-db/src/generated/lints.rs
+++ b/crates/ide-db/src/generated/lints.rs
@@ -4230,7 +4230,7 @@ pub union GenericUnion<T: Copy> { // Unions with non-`Copy` fields are unstable.
 pub const THIS_IS_OKAY: GenericUnion<()> = GenericUnion { field: () };
 ```
 
-Like transarent `struct`s, a transparent `union` of type `U` has the same
+Like transparent `struct`s, a transparent `union` of type `U` has the same
 layout, size, and ABI as its single non-ZST field. If it is generic over a type
 `T`, and all its fields are ZSTs except for exactly one field of type `T`, then
 it has the same layout and ABI as `T` (even if `T` is a ZST when monomorphized).
@@ -6548,7 +6548,7 @@ subtracting elements in an Add impl."##,
     },
     Lint {
         label: "clippy::suspicious_assignment_formatting",
-        description: r##"Checks for use of the non-existent `=*`, `=!` and `=-`
+        description: r##"Checks for use of the nonexistent `=*`, `=!` and `=-`
 operators."##,
     },
     Lint {
diff --git a/crates/ide-db/src/source_change.rs b/crates/ide-db/src/source_change.rs
index 04e62a8e916..5a3e352b2ec 100644
--- a/crates/ide-db/src/source_change.rs
+++ b/crates/ide-db/src/source_change.rs
@@ -181,7 +181,7 @@ impl SourceChangeBuilder {
     /// mutability, and different nodes in the same tree see the same mutations.
     ///
     /// The typical pattern for an assist is to find specific nodes in the read
-    /// phase, and then get their mutable couterparts using `make_mut` in the
+    /// phase, and then get their mutable counterparts using `make_mut` in the
     /// mutable state.
     pub fn make_syntax_mut(&mut self, node: SyntaxNode) -> SyntaxNode {
         self.mutated_tree.get_or_insert_with(|| TreeMutator::new(&node)).make_syntax_mut(&node)
diff --git a/crates/ide-db/src/syntax_helpers/format_string.rs b/crates/ide-db/src/syntax_helpers/format_string.rs
index 2d6927cee99..acf0a67de4a 100644
--- a/crates/ide-db/src/syntax_helpers/format_string.rs
+++ b/crates/ide-db/src/syntax_helpers/format_string.rs
@@ -92,7 +92,7 @@ pub fn lex_format_specifiers(
                 let (_, second) = cloned.next().unwrap_or_default();
                 match second {
                     '<' | '^' | '>' => {
-                        // alignment specifier, first char specifies fillment
+                        // alignment specifier, first char specifies fill
                         skip_char_and_emit(&mut chars, FormatSpecifier::Fill, &mut callback);
                         skip_char_and_emit(&mut chars, FormatSpecifier::Align, &mut callback);
                     }
diff --git a/crates/ide-db/src/syntax_helpers/format_string_exprs.rs b/crates/ide-db/src/syntax_helpers/format_string_exprs.rs
index fcef71fb74e..fc230818193 100644
--- a/crates/ide-db/src/syntax_helpers/format_string_exprs.rs
+++ b/crates/ide-db/src/syntax_helpers/format_string_exprs.rs
@@ -1,7 +1,7 @@
 //! Tools to work with expressions present in format string literals for the `format_args!` family of macros.
 //! Primarily meant for assists and completions.
 
-/// Enum for represenging extraced format string args.
+/// Enum for representing extracted format string args.
 /// Can either be extracted expressions (which includes identifiers),
 /// or placeholders `{}`.
 #[derive(Debug, PartialEq, Eq)]
diff --git a/crates/ide-db/src/use_trivial_constructor.rs b/crates/ide-db/src/use_trivial_constructor.rs
index 39431bed382..f96ea29ae2f 100644
--- a/crates/ide-db/src/use_trivial_constructor.rs
+++ b/crates/ide-db/src/use_trivial_constructor.rs
@@ -1,9 +1,9 @@
-//! Functionality for generating trivial contructors
+//! Functionality for generating trivial constructors
 
 use hir::StructKind;
 use syntax::ast;
 
-/// given a type return the trivial contructor (if one exists)
+/// given a type return the trivial constructor (if one exists)
 pub fn use_trivial_constructor(
     db: &crate::RootDatabase,
     path: ast::Path,
diff --git a/crates/ide-diagnostics/src/handlers/incorrect_case.rs b/crates/ide-diagnostics/src/handlers/incorrect_case.rs
index db88bf7b931..25ab0ca6f98 100644
--- a/crates/ide-diagnostics/src/handlers/incorrect_case.rs
+++ b/crates/ide-diagnostics/src/handlers/incorrect_case.rs
@@ -295,7 +295,7 @@ impl someStruct {
     }
 
     #[test]
-    fn no_diagnostic_for_enum_varinats() {
+    fn no_diagnostic_for_enum_variants() {
         check_diagnostics(
             r#"
 enum Option { Some, None }
diff --git a/crates/ide-diagnostics/src/handlers/mutability_errors.rs b/crates/ide-diagnostics/src/handlers/mutability_errors.rs
index 8c4ca23e06e..41ac83c0076 100644
--- a/crates/ide-diagnostics/src/handlers/mutability_errors.rs
+++ b/crates/ide-diagnostics/src/handlers/mutability_errors.rs
@@ -368,7 +368,7 @@ fn main() {
     #[test]
     fn mutation_in_dead_code() {
         // This one is interesting. Dead code is not represented at all in the MIR, so
-        // there would be no mutablility error for locals in dead code. Rustc tries to
+        // there would be no mutability error for locals in dead code. Rustc tries to
         // not emit `unused_mut` in this case, but since it works without `mut`, and
         // special casing it is not trivial, we emit it.
         check_diagnostics(
@@ -773,7 +773,7 @@ fn fn_once(mut x: impl FnOnce(u8) -> u8) -> u8 {
 
     #[test]
     fn closure() {
-        // FIXME: Diagnositc spans are too large
+        // FIXME: Diagnostic spans are too large
         check_diagnostics(
             r#"
         //- minicore: copy, fn
diff --git a/crates/ide-diagnostics/src/handlers/unresolved_field.rs b/crates/ide-diagnostics/src/handlers/unresolved_field.rs
index cefa74e523e..c232381c1e9 100644
--- a/crates/ide-diagnostics/src/handlers/unresolved_field.rs
+++ b/crates/ide-diagnostics/src/handlers/unresolved_field.rs
@@ -45,7 +45,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::UnresolvedField) -> Option<Vec<A
     }
 }
 
-// FIXME: We should fill out the call here, mvoe the cursor and trigger signature help
+// FIXME: We should fill out the call here, move the cursor and trigger signature help
 fn method_fix(
     ctx: &DiagnosticsContext<'_>,
     expr_ptr: &InFile<AstPtr<ast::Expr>>,
diff --git a/crates/ide/src/file_structure.rs b/crates/ide/src/file_structure.rs
index a32ac35496a..b278924721c 100644
--- a/crates/ide/src/file_structure.rs
+++ b/crates/ide/src/file_structure.rs
@@ -219,7 +219,7 @@ mod tests {
     }
 
     #[test]
-    fn test_nagative_trait_bound() {
+    fn test_negative_trait_bound() {
         let txt = r#"impl !Unpin for Test {}"#;
         check(
             txt,
diff --git a/crates/ide/src/fixture.rs b/crates/ide/src/fixture.rs
index 79665b9eed5..2e5903c0602 100644
--- a/crates/ide/src/fixture.rs
+++ b/crates/ide/src/fixture.rs
@@ -66,7 +66,7 @@ pub(crate) fn annotations(ra_fixture: &str) -> (Analysis, FilePosition, Vec<(Fil
     (host.analysis(), FilePosition { file_id, offset }, annotations)
 }
 
-/// Creates analysis from a multi-file fixture with annonations without $0
+/// Creates analysis from a multi-file fixture with annotations without $0
 pub(crate) fn annotations_without_marker(ra_fixture: &str) -> (Analysis, Vec<(FileRange, String)>) {
     let mut host = AnalysisHost::default();
     let change_fixture = ChangeFixture::parse(ra_fixture);
diff --git a/crates/ide/src/hover/tests.rs b/crates/ide/src/hover/tests.rs
index 73ab3d2e16f..7294b625539 100644
--- a/crates/ide/src/hover/tests.rs
+++ b/crates/ide/src/hover/tests.rs
@@ -3115,7 +3115,7 @@ mod Foo$0 {
 }
 
 #[test]
-fn hover_doc_outer_inner_attribue() {
+fn hover_doc_outer_inner_attribute() {
     check(
         r#"
 #[doc = "Be quick;"]
@@ -3146,7 +3146,7 @@ mod Foo$0 {
 }
 
 #[test]
-fn hover_doc_block_style_indentend() {
+fn hover_doc_block_style_indent_end() {
     check(
         r#"
 /**
@@ -4288,7 +4288,7 @@ fn hover_builtin() {
     check(
         r#"
 //- /main.rs crate:main deps:std
-cosnt _: &str$0 = ""; }
+const _: &str$0 = ""; }
 
 //- /libstd.rs crate:std
 /// Docs for prim_str
diff --git a/crates/ide/src/inlay_hints/adjustment.rs b/crates/ide/src/inlay_hints/adjustment.rs
index fea4b89b89f..d5be0c5b883 100644
--- a/crates/ide/src/inlay_hints/adjustment.rs
+++ b/crates/ide/src/inlay_hints/adjustment.rs
@@ -148,7 +148,7 @@ pub(super) fn hints(
     Some(())
 }
 
-/// Returns whatever the hint should be postfix and if we need to add paretheses on the inside and/or outside of `expr`,
+/// Returns whatever the hint should be postfix and if we need to add parentheses on the inside and/or outside of `expr`,
 /// if we are going to add (`postfix`) adjustments hints to it.
 fn mode_and_needs_parens_for_adjustment_hints(
     expr: &ast::Expr,
@@ -183,7 +183,7 @@ fn mode_and_needs_parens_for_adjustment_hints(
     }
 }
 
-/// Returns whatever we need to add paretheses on the inside and/or outside of `expr`,
+/// Returns whatever we need to add parentheses on the inside and/or outside of `expr`,
 /// if we are going to add (`postfix`) adjustments hints to it.
 fn needs_parens_for_adjustment_hints(expr: &ast::Expr, postfix: bool) -> (bool, bool) {
     // This is a very miserable pile of hacks...
@@ -194,10 +194,10 @@ fn needs_parens_for_adjustment_hints(expr: &ast::Expr, postfix: bool) -> (bool,
     // But we want to check what would happen if we add `*`/`.*` to the inner expression.
     // To check for inner we need `` expr.needs_parens_in(`*expr`) ``,
     // to check for outer we need `` `*expr`.needs_parens_in(parent) ``,
-    // where "expr" is the `expr` parameter, `*expr` is the editted `expr`,
+    // where "expr" is the `expr` parameter, `*expr` is the edited `expr`,
     // and "parent" is the parent of the original expression...
     //
-    // For this we utilize mutable mutable trees, which is a HACK, but it works.
+    // For this we utilize mutable trees, which is a HACK, but it works.
     //
     // FIXME: comeup with a better API for `needs_parens_in`, so that we don't have to do *this*
 
@@ -243,7 +243,7 @@ fn needs_parens_for_adjustment_hints(expr: &ast::Expr, postfix: bool) -> (bool,
     };
 
     // At this point
-    // - `parent`     is the parrent of the original expression
+    // - `parent`     is the parent of the original expression
     // - `dummy_expr` is the original expression wrapped in the operator we want (`*`/`.*`)
     // - `expr`       is the clone of the original expression (with `dummy_expr` as the parent)
 
diff --git a/crates/mbe/src/benchmark.rs b/crates/mbe/src/benchmark.rs
index 894355fcbc9..141f77abb8b 100644
--- a/crates/mbe/src/benchmark.rs
+++ b/crates/mbe/src/benchmark.rs
@@ -108,7 +108,7 @@ fn invocation_fixtures(rules: &FxHashMap<String, DeclarativeMacro>) -> Vec<(Stri
                     }
                     try_cnt += 1;
                     if try_cnt > 100 {
-                        panic!("invocaton fixture {name} cannot be generated.\n");
+                        panic!("invocation fixture {name} cannot be generated.\n");
                     }
                 }
             }
@@ -195,7 +195,7 @@ fn invocation_fixtures(rules: &FxHashMap<String, DeclarativeMacro>) -> Vec<(Stri
             Op::Ignore { .. } | Op::Index { .. } => {}
         };
 
-        // Simple linear congruential generator for determistic result
+        // Simple linear congruential generator for deterministic result
         fn rand(seed: &mut usize) -> usize {
             let a = 1664525;
             let c = 1013904223;
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index f4ea9e5c816..6fe8c005cf5 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -332,7 +332,7 @@ struct MatchState<'t> {
     /// Cached result of meta variable parsing
     meta_result: Option<(TtIter<'t>, ExpandResult<Option<Fragment>>)>,
 
-    /// Is error occuried in this state, will `poised` to "parent"
+    /// Is error occurred in this state, will `poised` to "parent"
     is_error: bool,
 }
 
diff --git a/crates/parser/src/grammar/types.rs b/crates/parser/src/grammar/types.rs
index 7d0b156c5a0..5ae16475b65 100644
--- a/crates/parser/src/grammar/types.rs
+++ b/crates/parser/src/grammar/types.rs
@@ -59,7 +59,7 @@ pub(super) fn ascription(p: &mut Parser<'_>) {
     assert!(p.at(T![:]));
     p.bump(T![:]);
     if p.at(T![=]) {
-        // recover from `let x: = expr;`, `const X: = expr;` and similars
+        // recover from `let x: = expr;`, `const X: = expr;` and similar
         // hopefully no type starts with `=`
         p.error("missing type");
         return;
diff --git a/crates/parser/test_data/parser/err/0027_incomplere_where_for.rast b/crates/parser/test_data/parser/err/0027_incomplere_where_for.rast
deleted file mode 100644
index 674c8d536ca..00000000000
--- a/crates/parser/test_data/parser/err/0027_incomplere_where_for.rast
+++ /dev/null
@@ -1,29 +0,0 @@
-SOURCE_FILE
-  FN
-    FN_KW "fn"
-    WHITESPACE " "
-    NAME
-      IDENT "foo"
-    PARAM_LIST
-      L_PAREN "("
-      R_PAREN ")"
-    WHITESPACE "\n    "
-    WHERE_CLAUSE
-      WHERE_KW "where"
-      WHITESPACE " "
-      WHERE_PRED
-        FOR_KW "for"
-        GENERIC_PARAM_LIST
-          L_ANGLE "<"
-          LIFETIME_PARAM
-            LIFETIME
-              LIFETIME_IDENT "'a"
-          R_ANGLE ">"
-    WHITESPACE "\n"
-    BLOCK_EXPR
-      STMT_LIST
-        L_CURLY "{"
-        R_CURLY "}"
-  WHITESPACE "\n"
-error 26: expected type
-error 26: expected colon
diff --git a/crates/parser/test_data/parser/err/0027_incomplere_where_for.rs b/crates/parser/test_data/parser/err/0027_incomplere_where_for.rs
deleted file mode 100644
index 2792c20843a..00000000000
--- a/crates/parser/test_data/parser/err/0027_incomplere_where_for.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn foo()
-    where for<'a>
-{}
diff --git a/crates/parser/test_data/parser/err/0027_incomplete_where_for.rast b/crates/parser/test_data/parser/err/0027_incomplete_where_for.rast
new file mode 100644
index 00000000000..674c8d536ca
--- /dev/null
+++ b/crates/parser/test_data/parser/err/0027_incomplete_where_for.rast
@@ -0,0 +1,29 @@
+SOURCE_FILE
+  FN
+    FN_KW "fn"
+    WHITESPACE " "
+    NAME
+      IDENT "foo"
+    PARAM_LIST
+      L_PAREN "("
+      R_PAREN ")"
+    WHITESPACE "\n    "
+    WHERE_CLAUSE
+      WHERE_KW "where"
+      WHITESPACE " "
+      WHERE_PRED
+        FOR_KW "for"
+        GENERIC_PARAM_LIST
+          L_ANGLE "<"
+          LIFETIME_PARAM
+            LIFETIME
+              LIFETIME_IDENT "'a"
+          R_ANGLE ">"
+    WHITESPACE "\n"
+    BLOCK_EXPR
+      STMT_LIST
+        L_CURLY "{"
+        R_CURLY "}"
+  WHITESPACE "\n"
+error 26: expected type
+error 26: expected colon
diff --git a/crates/parser/test_data/parser/err/0027_incomplete_where_for.rs b/crates/parser/test_data/parser/err/0027_incomplete_where_for.rs
new file mode 100644
index 00000000000..2792c20843a
--- /dev/null
+++ b/crates/parser/test_data/parser/err/0027_incomplete_where_for.rs
@@ -0,0 +1,3 @@
+fn foo()
+    where for<'a>
+{}
diff --git a/crates/parser/test_data/parser/err/0047_repated_extern_modifier.rast b/crates/parser/test_data/parser/err/0047_repated_extern_modifier.rast
deleted file mode 100644
index 4b2a740362e..00000000000
--- a/crates/parser/test_data/parser/err/0047_repated_extern_modifier.rast
+++ /dev/null
@@ -1,15 +0,0 @@
-SOURCE_FILE
-  ERROR
-    ABI
-      EXTERN_KW "extern"
-      WHITESPACE " "
-      STRING "\"C\""
-  WHITESPACE " "
-  ERROR
-    ABI
-      EXTERN_KW "extern"
-      WHITESPACE " "
-      STRING "\"C\""
-  WHITESPACE "\n"
-error 10: expected existential, fn, trait or impl
-error 21: expected existential, fn, trait or impl
diff --git a/crates/parser/test_data/parser/err/0047_repated_extern_modifier.rs b/crates/parser/test_data/parser/err/0047_repated_extern_modifier.rs
deleted file mode 100644
index db32b98dfb0..00000000000
--- a/crates/parser/test_data/parser/err/0047_repated_extern_modifier.rs
+++ /dev/null
@@ -1 +0,0 @@
-extern "C" extern "C"
diff --git a/crates/parser/test_data/parser/err/0047_repeated_extern_modifier.rast b/crates/parser/test_data/parser/err/0047_repeated_extern_modifier.rast
new file mode 100644
index 00000000000..4b2a740362e
--- /dev/null
+++ b/crates/parser/test_data/parser/err/0047_repeated_extern_modifier.rast
@@ -0,0 +1,15 @@
+SOURCE_FILE
+  ERROR
+    ABI
+      EXTERN_KW "extern"
+      WHITESPACE " "
+      STRING "\"C\""
+  WHITESPACE " "
+  ERROR
+    ABI
+      EXTERN_KW "extern"
+      WHITESPACE " "
+      STRING "\"C\""
+  WHITESPACE "\n"
+error 10: expected existential, fn, trait or impl
+error 21: expected existential, fn, trait or impl
diff --git a/crates/parser/test_data/parser/err/0047_repeated_extern_modifier.rs b/crates/parser/test_data/parser/err/0047_repeated_extern_modifier.rs
new file mode 100644
index 00000000000..db32b98dfb0
--- /dev/null
+++ b/crates/parser/test_data/parser/err/0047_repeated_extern_modifier.rs
@@ -0,0 +1 @@
+extern "C" extern "C"
diff --git a/crates/parser/test_data/parser/ok/0045_block_attrs.rast b/crates/parser/test_data/parser/ok/0045_block_attrs.rast
index bef13807116..fad574a4769 100644
--- a/crates/parser/test_data/parser/ok/0045_block_attrs.rast
+++ b/crates/parser/test_data/parser/ok/0045_block_attrs.rast
@@ -60,7 +60,7 @@ SOURCE_FILE
                         IDENT "doc"
                   TOKEN_TREE
                     L_PAREN "("
-                    STRING "\"Being validated is not affected by duplcates\""
+                    STRING "\"Being validated is not affected by duplicates\""
                     R_PAREN ")"
                 R_BRACK "]"
               WHITESPACE "\n        "
diff --git a/crates/parser/test_data/parser/ok/0045_block_attrs.rs b/crates/parser/test_data/parser/ok/0045_block_attrs.rs
index f16c4566e77..0969ea1659d 100644
--- a/crates/parser/test_data/parser/ok/0045_block_attrs.rs
+++ b/crates/parser/test_data/parser/ok/0045_block_attrs.rs
@@ -3,7 +3,7 @@ fn inner() {
     //! As are ModuleDoc style comments
     {
         #![doc("Inner attributes are allowed in blocks used as statements")]
-        #![doc("Being validated is not affected by duplcates")]
+        #![doc("Being validated is not affected by duplicates")]
         //! As are ModuleDoc style comments
     };
     {
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 3f2cfed806f..e2a815fb7c5 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -48,7 +48,7 @@ tracing-tree = "0.2.1"
 always-assert = "0.1.2"
 
 # These dependencies are unused, but we pin them to a version here to restrict them for our transitive dependencies
-# so that we don't pull in duplicates of their depdendenceies like windows-sys and syn 1 vs 2
+# so that we don't pull in duplicates of their dependencies like windows-sys and syn 1 vs 2
 # these would pull in serde 2
 thiserror = "=1.0.39"
 serde_repr = "=0.1.11"
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 27445d1f712..a7e949e21f3 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -338,7 +338,7 @@ config_data! {
         inlayHints_closingBraceHints_minLines: usize               = "25",
         /// Whether to show inlay type hints for return types of closures.
         inlayHints_closureReturnTypeHints_enable: ClosureReturnTypeHintsDef  = "\"never\"",
-        /// Closure notation in type and chaining inaly hints.
+        /// Closure notation in type and chaining inlay hints.
         inlayHints_closureStyle: ClosureStyle                                = "\"impl_fn\"",
         /// Whether to show enum variant discriminant hints.
         inlayHints_discriminantHints_enable: DiscriminantHintsDef            = "\"never\"",
@@ -488,7 +488,7 @@ config_data! {
         /// When enabled, rust-analyzer will emit special token types for operator tokens instead
         /// of the generic `operator` token type.
         semanticHighlighting_operator_specialization_enable: bool = "false",
-        /// Use semantic tokens for punctuations.
+        /// Use semantic tokens for punctuation.
         ///
         /// When disabled, rust-analyzer will emit semantic tokens only for punctuation tokens when
         /// they are tagged with modifiers or have a special role.
@@ -496,7 +496,7 @@ config_data! {
         /// When enabled, rust-analyzer will emit a punctuation semantic token for the `!` of macro
         /// calls.
         semanticHighlighting_punctuation_separate_macro_bang: bool = "false",
-        /// Use specialized semantic tokens for punctuations.
+        /// Use specialized semantic tokens for punctuation.
         ///
         /// When enabled, rust-analyzer will emit special token types for punctuation tokens instead
         /// of the generic `punctuation` token type.
@@ -1967,7 +1967,7 @@ fn get_field<T: DeserializeOwned>(
     alias: Option<&'static str>,
     default: &str,
 ) -> T {
-    // XXX: check alias first, to work-around the VS Code where it pre-fills the
+    // XXX: check alias first, to work around the VS Code where it pre-fills the
     // defaults instead of sending an empty object.
     alias
         .into_iter()
@@ -2199,8 +2199,8 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json
             "enumDescriptions": [
                 "Always show adjustment hints as prefix (`*expr`).",
                 "Always show adjustment hints as postfix (`expr.*`).",
-                "Show prefix or postfix depending on which uses less parenthesis, prefering prefix.",
-                "Show prefix or postfix depending on which uses less parenthesis, prefering postfix.",
+                "Show prefix or postfix depending on which uses less parenthesis, preferring prefix.",
+                "Show prefix or postfix depending on which uses less parenthesis, preferring postfix.",
             ]
         },
         "CargoFeaturesDef" => set! {
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 616d8fca5f3..4fe957e854d 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -288,7 +288,7 @@ impl GlobalState {
         {
             let raw_database = self.analysis_host.raw_database();
             // FIXME: ideally we should only trigger a workspace fetch for non-library changes
-            // but somethings going wrong with the source root business when we add a new local
+            // but something's going wrong with the source root business when we add a new local
             // crate see https://github.com/rust-lang/rust-analyzer/issues/13029
             if let Some(path) = workspace_structure_change {
                 self.fetch_workspaces_queue
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index f9930fb2599..ccb04cb0f15 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -36,7 +36,7 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
     // temporary bumped. This optimization backfires in our case: each time the
     // `main_loop` schedules a task to run on a threadpool, the worker threads
     // gets a higher priority, and (on a machine with fewer cores) displaces the
-    // main loop! We work-around this by marking the main loop as a
+    // main loop! We work around this by marking the main loop as a
     // higher-priority thread.
     //
     // https://docs.microsoft.com/en-us/windows/win32/procthread/scheduling-priorities
diff --git a/crates/syntax/src/parsing/reparsing.rs b/crates/syntax/src/parsing/reparsing.rs
index 701e6232d58..f3d644c680e 100644
--- a/crates/syntax/src/parsing/reparsing.rs
+++ b/crates/syntax/src/parsing/reparsing.rs
@@ -166,8 +166,8 @@ fn merge_errors(
     }
     res.extend(new_errors.into_iter().map(|new_err| {
         // fighting borrow checker with a variable ;)
-        let offseted_range = new_err.range() + range_before_reparse.start();
-        new_err.with_range(offseted_range)
+        let offsetted_range = new_err.range() + range_before_reparse.start();
+        new_err.with_range(offsetted_range)
     }));
     res
 }
@@ -408,7 +408,7 @@ enum Foo {
 
     #[test]
     fn reparse_str_token_with_error_fixed() {
-        do_check(r#""unterinated$0$0"#, "\"", 12);
+        do_check(r#""unterminated$0$0"#, "\"", 13);
     }
 
     #[test]
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs
index fb2381110bf..5ff01eb44e7 100644
--- a/crates/syntax/src/validation.rs
+++ b/crates/syntax/src/validation.rs
@@ -175,14 +175,14 @@ pub(crate) fn validate_block_structure(root: &SyntaxNode) {
                     assert_eq!(
                         node.parent(),
                         pair.parent(),
-                        "\nunpaired curlys:\n{}\n{:#?}\n",
+                        "\nunpaired curlies:\n{}\n{:#?}\n",
                         root.text(),
                         root,
                     );
                     assert!(
                         node.next_sibling_or_token().is_none()
                             && pair.prev_sibling_or_token().is_none(),
-                        "\nfloating curlys at {:?}\nfile:\n{}\nerror:\n{}\n",
+                        "\nfloating curlies at {:?}\nfile:\n{}\nerror:\n{}\n",
                         node,
                         root.text(),
                         node,
diff --git a/crates/syntax/test_data/parser/fuzz-failures/0000.rs b/crates/syntax/test_data/parser/fuzz-failures/0000.rs
index f977d23c480..13852aa78b8 100644
--- a/crates/syntax/test_data/parser/fuzz-failures/0000.rs
+++ b/crates/syntax/test_data/parser/fuzz-failures/0000.rs
@@ -39,13 +39,13 @@
         ast::Root::cast(self.syntax()).unwrap()
     }
     pub fn syntax(&self) -> SyntaxNodeRef {
-        self.root.brroowed()
+        self.root.borrowed()
     }
     mp_tree(root),
                     );
                     assert!(
                         node.next_sibling().is_none() && pair.prev_sibling().is_none(),
-                        "\nfloating curlys at {:?}\nfile:\n{}\nerror:\n{}\n",
+                        "\nfloating curlies at {:?}\nfile:\n{}\nerror:\n{}\n",
                         node,
                         root.text(),
                         node.text(),
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 9df6b0ff28f..d748400b695 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -333,7 +333,7 @@ Moreover, it would be cool if editors didn't need to implement even basic langua
 
 ### Unresolved Question
 
-* Should we return a nested brace structure, to allow paredit-like actions of jump *out* of the current brace pair?
+* Should we return a nested brace structure, to allow [paredit](https://paredit.org/)-like actions of jump *out* of the current brace pair?
   This is how `SelectionRange` request works.
 * Alternatively, should we perhaps flag certain `SelectionRange`s as being brace pairs?
 
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index e92e6ae92cc..0c3432e9036 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -477,7 +477,7 @@ Whether to show inlay type hints for return types of closures.
 [[rust-analyzer.inlayHints.closureStyle]]rust-analyzer.inlayHints.closureStyle (default: `"impl_fn"`)::
 +
 --
-Closure notation in type and chaining inaly hints.
+Closure notation in type and chaining inlay hints.
 --
 [[rust-analyzer.inlayHints.discriminantHints.enable]]rust-analyzer.inlayHints.discriminantHints.enable (default: `"never"`)::
 +
@@ -758,7 +758,7 @@ of the generic `operator` token type.
 [[rust-analyzer.semanticHighlighting.punctuation.enable]]rust-analyzer.semanticHighlighting.punctuation.enable (default: `false`)::
 +
 --
-Use semantic tokens for punctuations.
+Use semantic tokens for punctuation.
 
 When disabled, rust-analyzer will emit semantic tokens only for punctuation tokens when
 they are tagged with modifiers or have a special role.
@@ -772,7 +772,7 @@ calls.
 [[rust-analyzer.semanticHighlighting.punctuation.specialization.enable]]rust-analyzer.semanticHighlighting.punctuation.specialization.enable (default: `false`)::
 +
 --
-Use specialized semantic tokens for punctuations.
+Use specialized semantic tokens for punctuation.
 
 When enabled, rust-analyzer will emit special token types for punctuation tokens instead
 of the generic `punctuation` token type.
diff --git a/editors/code/package.json b/editors/code/package.json
index 3c0486ad680..f6ad2f7908f 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -1030,7 +1030,7 @@
                     ]
                 },
                 "rust-analyzer.inlayHints.closureStyle": {
-                    "markdownDescription": "Closure notation in type and chaining inaly hints.",
+                    "markdownDescription": "Closure notation in type and chaining inlay hints.",
                     "default": "impl_fn",
                     "type": "string",
                     "enum": [
@@ -1094,8 +1094,8 @@
                     "enumDescriptions": [
                         "Always show adjustment hints as prefix (`*expr`).",
                         "Always show adjustment hints as postfix (`expr.*`).",
-                        "Show prefix or postfix depending on which uses less parenthesis, prefering prefix.",
-                        "Show prefix or postfix depending on which uses less parenthesis, prefering postfix."
+                        "Show prefix or postfix depending on which uses less parenthesis, preferring prefix.",
+                        "Show prefix or postfix depending on which uses less parenthesis, preferring postfix."
                     ]
                 },
                 "rust-analyzer.inlayHints.lifetimeElisionHints.enable": {
@@ -1381,7 +1381,7 @@
                     "type": "boolean"
                 },
                 "rust-analyzer.semanticHighlighting.punctuation.enable": {
-                    "markdownDescription": "Use semantic tokens for punctuations.\n\nWhen disabled, rust-analyzer will emit semantic tokens only for punctuation tokens when\nthey are tagged with modifiers or have a special role.",
+                    "markdownDescription": "Use semantic tokens for punctuation.\n\nWhen disabled, rust-analyzer will emit semantic tokens only for punctuation tokens when\nthey are tagged with modifiers or have a special role.",
                     "default": false,
                     "type": "boolean"
                 },
@@ -1391,7 +1391,7 @@
                     "type": "boolean"
                 },
                 "rust-analyzer.semanticHighlighting.punctuation.specialization.enable": {
-                    "markdownDescription": "Use specialized semantic tokens for punctuations.\n\nWhen enabled, rust-analyzer will emit special token types for punctuation tokens instead\nof the generic `punctuation` token type.",
+                    "markdownDescription": "Use specialized semantic tokens for punctuation.\n\nWhen enabled, rust-analyzer will emit special token types for punctuation tokens instead\nof the generic `punctuation` token type.",
                     "default": false,
                     "type": "boolean"
                 },
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index 35627e2fc6b..623fb102953 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -157,7 +157,7 @@ export async function createTask(runnable: ra.Runnable, config: Config): Promise
 
     cargoTask.presentationOptions.clear = true;
     // Sadly, this doesn't prevent focus stealing if the terminal is currently
-    // hidden, and will become revealed due to task exucution.
+    // hidden, and will become revealed due to task execution.
     cargoTask.presentationOptions.focus = false;
 
     return cargoTask;
-- 
cgit 1.4.1-3-g733a5


From 770734fdbb066f89fa951273a4ac03003ce0ff59 Mon Sep 17 00:00:00 2001
From: Nagy Botond <75550932+westernwontons@users.noreply.github.com>
Date: Thu, 20 Apr 2023 19:41:15 +0300
Subject: Automatic parameter hints trigger can be toggled on/off

---
 editors/code/package.json    | 5 +++++
 editors/code/src/commands.ts | 8 +++++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index f6ad2f7908f..4b6406ee7dd 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -1455,6 +1455,11 @@
                         "Search in current workspace and dependencies."
                     ]
                 },
+                "rust-analyzer.autoTriggerParameterHints": {
+                    "type": "boolean",
+                    "default": true,
+                    "markdownDescription": "Enable or disable automatic triggering of parameter hints when accepting suggestions."
+                },
                 "$generated-end": {}
             }
         },
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 5209fecc069..c1da65d8915 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -89,7 +89,13 @@ export function shuffleCrateGraph(ctx: CtxInit): Cmd {
 
 export function triggerParameterHints(_: CtxInit): Cmd {
     return async () => {
-        await vscode.commands.executeCommand("editor.action.triggerParameterHints");
+        const autoTriggerParameterHints = vscode.workspace
+            .getConfiguration("rust-analyzer")
+            .get<boolean>("autoTriggerParameterHints");
+
+        if (autoTriggerParameterHints) {
+            await vscode.commands.executeCommand("editor.action.triggerParameterHints");
+        }
     };
 }
 
-- 
cgit 1.4.1-3-g733a5


From 36281e0745b7740fcb880e48cdb417ff7944414b Mon Sep 17 00:00:00 2001
From: Nagy Botond <75550932+westernwontons@users.noreply.github.com>
Date: Thu, 20 Apr 2023 22:13:33 +0300
Subject: using VSCode's native parameterHints.enabled setting

---
 editors/code/package.json    | 5 -----
 editors/code/src/commands.ts | 8 ++++----
 2 files changed, 4 insertions(+), 9 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index 4b6406ee7dd..f6ad2f7908f 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -1455,11 +1455,6 @@
                         "Search in current workspace and dependencies."
                     ]
                 },
-                "rust-analyzer.autoTriggerParameterHints": {
-                    "type": "boolean",
-                    "default": true,
-                    "markdownDescription": "Enable or disable automatic triggering of parameter hints when accepting suggestions."
-                },
                 "$generated-end": {}
             }
         },
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index c1da65d8915..0d91548b9b3 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -89,11 +89,11 @@ export function shuffleCrateGraph(ctx: CtxInit): Cmd {
 
 export function triggerParameterHints(_: CtxInit): Cmd {
     return async () => {
-        const autoTriggerParameterHints = vscode.workspace
-            .getConfiguration("rust-analyzer")
-            .get<boolean>("autoTriggerParameterHints");
+        const parameterHintsEnabled = vscode.workspace
+            .getConfiguration("editor")
+            .get<boolean>("parameterHints.enabled");
 
-        if (autoTriggerParameterHints) {
+        if (parameterHintsEnabled) {
             await vscode.commands.executeCommand("editor.action.triggerParameterHints");
         }
     };
-- 
cgit 1.4.1-3-g733a5


From cf8f13b531f649e37202780c7f6353db911062ba Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Fri, 28 Apr 2023 21:34:31 +0200
Subject: fix: Fix restart server button trying to start instead of restart the
 server

---
 crates/hir-def/src/nameres/collector.rs | 2 +-
 editors/code/package.json               | 4 ++--
 editors/code/src/config.ts              | 5 ++---
 editors/code/src/ctx.ts                 | 4 +++-
 editors/code/src/main.ts                | 4 +---
 5 files changed, 9 insertions(+), 10 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/hir-def/src/nameres/collector.rs b/crates/hir-def/src/nameres/collector.rs
index 51879dd5553..05d49ee814b 100644
--- a/crates/hir-def/src/nameres/collector.rs
+++ b/crates/hir-def/src/nameres/collector.rs
@@ -1874,7 +1874,6 @@ impl ModCollector<'_, '_> {
         let vis = def_map
             .resolve_visibility(self.def_collector.db, self.module_id, visibility, false)
             .unwrap_or(Visibility::Public);
-        let modules = &mut def_map.modules;
         let origin = match definition {
             None => ModuleOrigin::Inline {
                 definition: declaration,
@@ -1888,6 +1887,7 @@ impl ModCollector<'_, '_> {
             },
         };
 
+        let modules = &mut def_map.modules;
         let res = modules.alloc(ModuleData::new(origin, vis));
         modules[res].parent = Some(self.module_id);
         for (name, mac) in modules[self.module_id].scope.collect_legacy_macros() {
diff --git a/editors/code/package.json b/editors/code/package.json
index c164595aff8..79e2c62e823 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -211,7 +211,7 @@
                 "category": "rust-analyzer"
             },
             {
-                "command": "rust-analyzer.reload",
+                "command": "rust-analyzer.restartServer",
                 "title": "Restart server",
                 "category": "rust-analyzer"
             },
@@ -1909,7 +1909,7 @@
                     "when": "inRustProject"
                 },
                 {
-                    "command": "rust-analyzer.reload",
+                    "command": "rust-analyzer.restartServer",
                     "when": "inRustProject"
                 },
                 {
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index da7c74c28ba..d6b8cc7a56a 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -21,7 +21,6 @@ export class Config {
         "serverPath",
         "server",
         "files",
-        "lens", // works as lens.*
     ].map((opt) => `${this.rootSection}.${opt}`);
 
     readonly package: {
@@ -70,7 +69,7 @@ export class Config {
         if (!requiresReloadOpt) return;
 
         if (this.restartServerOnConfigChange) {
-            await vscode.commands.executeCommand("rust-analyzer.reload");
+            await vscode.commands.executeCommand("rust-analyzer.restartServer");
             return;
         }
 
@@ -78,7 +77,7 @@ export class Config {
         const userResponse = await vscode.window.showInformationMessage(message, "Restart now");
 
         if (userResponse) {
-            const command = "rust-analyzer.reload";
+            const command = "rust-analyzer.restartServer";
             await vscode.commands.executeCommand(command);
         }
     }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 0ffa42c2a5a..567b9216bc1 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -390,7 +390,9 @@ export class Ctx {
         statusBar.tooltip.appendMarkdown(
             "\n\n[Rebuild Proc Macros](command:rust-analyzer.rebuildProcMacros)"
         );
-        statusBar.tooltip.appendMarkdown("\n\n[Restart server](command:rust-analyzer.startServer)");
+        statusBar.tooltip.appendMarkdown(
+            "\n\n[Restart server](command:rust-analyzer.restartServer)"
+        );
         statusBar.tooltip.appendMarkdown("\n\n[Stop server](command:rust-analyzer.stopServer)");
         if (!status.quiescent) icon = "$(sync~spin) ";
         statusBar.text = `${icon}rust-analyzer`;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index de40f99e003..6c990f804b0 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -120,13 +120,11 @@ function createCommands(): Record<string, CommandFactory> {
             enabled: commands.onEnter,
             disabled: (_) => () => vscode.commands.executeCommand("default:type", { text: "\n" }),
         },
-        reload: {
+        restartServer: {
             enabled: (ctx) => async () => {
-                void vscode.window.showInformationMessage("Reloading rust-analyzer...");
                 await ctx.restart();
             },
             disabled: (ctx) => async () => {
-                void vscode.window.showInformationMessage("Reloading rust-analyzer...");
                 await ctx.start();
             },
         },
-- 
cgit 1.4.1-3-g733a5


From 6312fbf521e42e5a5ff193ceee6a8c7735be3a45 Mon Sep 17 00:00:00 2001
From: hkalbasi <hamidrezakalbasi@protonmail.com>
Date: Fri, 28 Apr 2023 20:44:30 +0330
Subject: MIR episode 4

---
 crates/base-db/src/change.rs                       |   2 +-
 crates/hir-def/src/body/lower.rs                   |  33 +-
 crates/hir-ty/src/builder.rs                       |  19 +
 crates/hir-ty/src/chalk_db.rs                      |   4 +-
 crates/hir-ty/src/chalk_ext.rs                     |  36 +-
 crates/hir-ty/src/consteval.rs                     |   9 +-
 crates/hir-ty/src/consteval/tests.rs               | 395 ++++++++-
 crates/hir-ty/src/consteval/tests/intrinsics.rs    | 129 +++
 crates/hir-ty/src/db.rs                            |   4 +-
 .../src/diagnostics/match_check/deconstruct_pat.rs |   2 +-
 crates/hir-ty/src/display.rs                       | 177 ++--
 crates/hir-ty/src/infer.rs                         |   5 +-
 crates/hir-ty/src/infer/closure.rs                 |  84 +-
 crates/hir-ty/src/infer/coerce.rs                  |   8 +-
 crates/hir-ty/src/infer/expr.rs                    |   2 +-
 crates/hir-ty/src/layout.rs                        |  20 +-
 crates/hir-ty/src/layout/tests.rs                  |  16 +
 crates/hir-ty/src/lib.rs                           |  16 +-
 crates/hir-ty/src/mir.rs                           |  71 +-
 crates/hir-ty/src/mir/borrowck.rs                  |  62 +-
 crates/hir-ty/src/mir/eval.rs                      | 963 +++++++++++++--------
 crates/hir-ty/src/mir/eval/shim.rs                 | 396 +++++++++
 crates/hir-ty/src/mir/lower.rs                     | 337 ++++---
 crates/hir-ty/src/mir/lower/as_place.rs            |  54 +-
 crates/hir-ty/src/mir/lower/pattern_matching.rs    |  81 +-
 crates/hir-ty/src/mir/pretty.rs                    | 120 ++-
 crates/hir-ty/src/utils.rs                         |  36 +-
 crates/hir/src/lib.rs                              |  18 +-
 crates/ide/src/hover.rs                            |   1 -
 crates/ide/src/hover/render.rs                     |  17 +-
 crates/ide/src/hover/tests.rs                      |   1 -
 crates/ide/src/inlay_hints/adjustment.rs           |  13 +-
 crates/ide/src/inlay_hints/chaining.rs             |  12 +-
 crates/ide/src/interpret_function.rs               |  49 ++
 crates/ide/src/lib.rs                              |   5 +
 crates/ide/src/static_index.rs                     |   1 -
 crates/rust-analyzer/src/config.rs                 |   5 +-
 crates/rust-analyzer/src/handlers.rs               |  10 +
 crates/rust-analyzer/src/lsp_ext.rs                |   8 +
 crates/rust-analyzer/src/main_loop.rs              |   1 +
 crates/rust-analyzer/src/to_proto.rs               |  17 +
 crates/test-utils/src/minicore.rs                  |  62 ++
 docs/dev/lsp-extensions.md                         |  14 +-
 editors/code/package.json                          |   5 +
 editors/code/src/commands.ts                       |  36 +-
 editors/code/src/lsp_ext.ts                        |   3 +
 editors/code/src/main.ts                           |   1 +
 47 files changed, 2556 insertions(+), 804 deletions(-)
 create mode 100644 crates/hir-ty/src/mir/eval/shim.rs
 create mode 100644 crates/ide/src/interpret_function.rs

(limited to 'editors/code/src')

diff --git a/crates/base-db/src/change.rs b/crates/base-db/src/change.rs
index fe3792ef6c1..f1973a20714 100644
--- a/crates/base-db/src/change.rs
+++ b/crates/base-db/src/change.rs
@@ -34,7 +34,7 @@ impl fmt::Debug for Change {
 }
 
 impl Change {
-    pub fn new() -> Change {
+    pub fn new() -> Self {
         Change::default()
     }
 
diff --git a/crates/hir-def/src/body/lower.rs b/crates/hir-def/src/body/lower.rs
index 27dfe766d33..d31340fe8f3 100644
--- a/crates/hir-def/src/body/lower.rs
+++ b/crates/hir-def/src/body/lower.rs
@@ -17,7 +17,7 @@ use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
 use syntax::{
     ast::{
-        self, ArrayExprKind, AstChildren, BlockExpr, HasArgList, HasLoopBody, HasName,
+        self, ArrayExprKind, AstChildren, BlockExpr, HasArgList, HasAttrs, HasLoopBody, HasName,
         SlicePatComponents,
     },
     AstNode, AstPtr, SyntaxNodePtr,
@@ -302,16 +302,29 @@ impl ExprCollector<'_> {
                 self.alloc_expr(Expr::For { iterable, pat, body, label }, syntax_ptr)
             }
             ast::Expr::CallExpr(e) => {
-                let callee = self.collect_expr_opt(e.expr());
-                let args = if let Some(arg_list) = e.arg_list() {
-                    arg_list.args().filter_map(|e| self.maybe_collect_expr(e)).collect()
-                } else {
-                    Box::default()
+                let is_rustc_box = {
+                    let attrs = e.attrs();
+                    attrs.filter_map(|x| x.as_simple_atom()).any(|x| x == "rustc_box")
                 };
-                self.alloc_expr(
-                    Expr::Call { callee, args, is_assignee_expr: self.is_lowering_assignee_expr },
-                    syntax_ptr,
-                )
+                if is_rustc_box {
+                    let expr = self.collect_expr_opt(e.arg_list().and_then(|x| x.args().next()));
+                    self.alloc_expr(Expr::Box { expr }, syntax_ptr)
+                } else {
+                    let callee = self.collect_expr_opt(e.expr());
+                    let args = if let Some(arg_list) = e.arg_list() {
+                        arg_list.args().filter_map(|e| self.maybe_collect_expr(e)).collect()
+                    } else {
+                        Box::default()
+                    };
+                    self.alloc_expr(
+                        Expr::Call {
+                            callee,
+                            args,
+                            is_assignee_expr: self.is_lowering_assignee_expr,
+                        },
+                        syntax_ptr,
+                    )
+                }
             }
             ast::Expr::MethodCallExpr(e) => {
                 let receiver = self.collect_expr_opt(e.receiver());
diff --git a/crates/hir-ty/src/builder.rs b/crates/hir-ty/src/builder.rs
index 97924569ccc..2362b08f79a 100644
--- a/crates/hir-ty/src/builder.rs
+++ b/crates/hir-ty/src/builder.rs
@@ -232,6 +232,25 @@ impl TyBuilder<()> {
         TyBuilder::new((), params, parent_subst)
     }
 
+    pub fn subst_for_closure(
+        db: &dyn HirDatabase,
+        parent: DefWithBodyId,
+        sig_ty: Ty,
+    ) -> Substitution {
+        let sig_ty = sig_ty.cast(Interner);
+        let self_subst = iter::once(&sig_ty);
+        let Some(parent) = parent.as_generic_def_id() else {
+            return Substitution::from_iter(Interner, self_subst);
+        };
+        Substitution::from_iter(
+            Interner,
+            self_subst
+                .chain(generics(db.upcast(), parent).placeholder_subst(db).iter(Interner))
+                .cloned()
+                .collect::<Vec<_>>(),
+        )
+    }
+
     pub fn build(self) -> Substitution {
         let ((), subst) = self.build_internal();
         subst
diff --git a/crates/hir-ty/src/chalk_db.rs b/crates/hir-ty/src/chalk_db.rs
index fb7d99711d9..e5be852bc68 100644
--- a/crates/hir-ty/src/chalk_db.rs
+++ b/crates/hir-ty/src/chalk_db.rs
@@ -24,7 +24,7 @@ use crate::{
     method_resolution::{TraitImpls, TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
     to_assoc_type_id, to_chalk_trait_id,
     traits::ChalkContext,
-    utils::generics,
+    utils::{generics, ClosureSubst},
     wrap_empty_binders, AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId,
     Interner, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause, Substitution, TraitRef,
     TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
@@ -337,7 +337,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
         _closure_id: chalk_ir::ClosureId<Interner>,
         substs: &chalk_ir::Substitution<Interner>,
     ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> {
-        let sig_ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone();
+        let sig_ty = ClosureSubst(substs).sig_ty();
         let sig = &sig_ty.callable_sig(self.db).expect("first closure param should be fn ptr");
         let io = rust_ir::FnDefInputsAndOutputDatum {
             argument_types: sig.params().to_vec(),
diff --git a/crates/hir-ty/src/chalk_ext.rs b/crates/hir-ty/src/chalk_ext.rs
index d6a56124856..33c598fe364 100644
--- a/crates/hir-ty/src/chalk_ext.rs
+++ b/crates/hir-ty/src/chalk_ext.rs
@@ -1,20 +1,22 @@
 //! Various extensions traits for Chalk types.
 
-use chalk_ir::{FloatTy, IntTy, Mutability, Scalar, TyVariableKind, UintTy};
+use chalk_ir::{cast::Cast, FloatTy, IntTy, Mutability, Scalar, TyVariableKind, UintTy};
 use hir_def::{
     builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType, BuiltinUint},
     generics::TypeOrConstParamData,
     lang_item::LangItem,
     type_ref::Rawness,
-    FunctionId, GenericDefId, HasModule, ItemContainerId, Lookup, TraitId,
+    DefWithBodyId, FunctionId, GenericDefId, HasModule, ItemContainerId, Lookup, TraitId,
 };
 
 use crate::{
-    db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
-    from_placeholder_idx, to_chalk_trait_id, utils::generics, AdtId, AliasEq, AliasTy, Binders,
-    CallableDefId, CallableSig, ClosureId, DynTy, FnPointer, ImplTraitId, Interner, Lifetime,
-    ProjectionTy, QuantifiedWhereClause, Substitution, TraitRef, Ty, TyBuilder, TyKind, TypeFlags,
-    WhereClause,
+    db::HirDatabase,
+    from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx,
+    to_chalk_trait_id,
+    utils::{generics, ClosureSubst},
+    AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, Canonical, CanonicalVarKinds,
+    ClosureId, DynTy, FnPointer, ImplTraitId, InEnvironment, Interner, Lifetime, ProjectionTy,
+    QuantifiedWhereClause, Substitution, TraitRef, Ty, TyBuilder, TyKind, TypeFlags, WhereClause,
 };
 
 pub trait TyExt {
@@ -46,6 +48,7 @@ pub trait TyExt {
 
     fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<QuantifiedWhereClause>>;
     fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId>;
+    fn is_copy(self, db: &dyn HirDatabase, owner: DefWithBodyId) -> bool;
 
     /// FIXME: Get rid of this, it's not a good abstraction
     fn equals_ctor(&self, other: &Ty) -> bool;
@@ -185,10 +188,7 @@ impl TyExt for Ty {
                 let sig = db.callable_item_signature(callable_def);
                 Some(sig.substitute(Interner, parameters))
             }
-            TyKind::Closure(.., substs) => {
-                let sig_param = substs.at(Interner, 0).assert_ty_ref(Interner);
-                sig_param.callable_sig(db)
-            }
+            TyKind::Closure(.., substs) => ClosureSubst(substs).sig_ty().callable_sig(db),
             _ => None,
         }
     }
@@ -327,6 +327,20 @@ impl TyExt for Ty {
         }
     }
 
+    fn is_copy(self, db: &dyn HirDatabase, owner: DefWithBodyId) -> bool {
+        let crate_id = owner.module(db.upcast()).krate();
+        let Some(copy_trait) = db.lang_item(crate_id, LangItem::Copy).and_then(|x| x.as_trait()) else {
+            return false;
+        };
+        let trait_ref = TyBuilder::trait_ref(db, copy_trait).push(self).build();
+        let env = db.trait_environment_for_body(owner);
+        let goal = Canonical {
+            value: InEnvironment::new(&env.env, trait_ref.cast(Interner)),
+            binders: CanonicalVarKinds::empty(Interner),
+        };
+        db.trait_solve(crate_id, None, goal).is_some()
+    }
+
     fn equals_ctor(&self, other: &Ty) -> bool {
         match (self.kind(Interner), other.kind(Interner)) {
             (TyKind::Adt(adt, ..), TyKind::Adt(adt2, ..)) => adt == adt2,
diff --git a/crates/hir-ty/src/consteval.rs b/crates/hir-ty/src/consteval.rs
index 78033b4e89b..80b72768b3c 100644
--- a/crates/hir-ty/src/consteval.rs
+++ b/crates/hir-ty/src/consteval.rs
@@ -7,7 +7,7 @@ use hir_def::{
     path::Path,
     resolver::{Resolver, ValueNs},
     type_ref::ConstRef,
-    ConstId, EnumVariantId,
+    DefWithBodyId, EnumVariantId,
 };
 use la_arena::{Idx, RawIdx};
 use stdx::never;
@@ -57,7 +57,7 @@ pub enum ConstEvalError {
 impl From<MirLowerError> for ConstEvalError {
     fn from(value: MirLowerError) -> Self {
         match value {
-            MirLowerError::ConstEvalError(e) => *e,
+            MirLowerError::ConstEvalError(_, e) => *e,
             _ => ConstEvalError::MirLowerError(value),
         }
     }
@@ -168,7 +168,7 @@ pub fn try_const_usize(c: &Const) -> Option<u128> {
 pub(crate) fn const_eval_recover(
     _: &dyn HirDatabase,
     _: &[String],
-    _: &ConstId,
+    _: &DefWithBodyId,
     _: &Substitution,
 ) -> Result<Const, ConstEvalError> {
     Err(ConstEvalError::MirLowerError(MirLowerError::Loop))
@@ -184,10 +184,9 @@ pub(crate) fn const_eval_discriminant_recover(
 
 pub(crate) fn const_eval_query(
     db: &dyn HirDatabase,
-    const_id: ConstId,
+    def: DefWithBodyId,
     subst: Substitution,
 ) -> Result<Const, ConstEvalError> {
-    let def = const_id.into();
     let body = db.mir_body(def)?;
     let c = interpret_mir(db, &body, subst, false)?;
     Ok(c)
diff --git a/crates/hir-ty/src/consteval/tests.rs b/crates/hir-ty/src/consteval/tests.rs
index d987f41c706..e95e1755363 100644
--- a/crates/hir-ty/src/consteval/tests.rs
+++ b/crates/hir-ty/src/consteval/tests.rs
@@ -1,4 +1,4 @@
-use base_db::fixture::WithFixture;
+use base_db::{fixture::WithFixture, FileId};
 use chalk_ir::Substitution;
 use hir_def::db::DefDatabase;
 
@@ -16,7 +16,7 @@ mod intrinsics;
 
 fn simplify(e: ConstEvalError) -> ConstEvalError {
     match e {
-        ConstEvalError::MirEvalError(MirEvalError::InFunction(_, e)) => {
+        ConstEvalError::MirEvalError(MirEvalError::InFunction(_, e, _, _)) => {
             simplify(ConstEvalError::MirEvalError(*e))
         }
         _ => e,
@@ -24,13 +24,30 @@ fn simplify(e: ConstEvalError) -> ConstEvalError {
 }
 
 #[track_caller]
-fn check_fail(ra_fixture: &str, error: ConstEvalError) {
-    assert_eq!(eval_goal(ra_fixture).map_err(simplify), Err(error));
+fn check_fail(ra_fixture: &str, error: impl FnOnce(ConstEvalError) -> bool) {
+    let (db, file_id) = TestDB::with_single_file(ra_fixture);
+    match eval_goal(&db, file_id).map_err(simplify) {
+        Ok(_) => panic!("Expected fail, but it succeeded"),
+        Err(e) => assert!(error(e)),
+    }
 }
 
 #[track_caller]
 fn check_number(ra_fixture: &str, answer: i128) {
-    let r = eval_goal(ra_fixture).unwrap();
+    let (db, file_id) = TestDB::with_single_file(ra_fixture);
+    let r = match eval_goal(&db, file_id) {
+        Ok(t) => t,
+        Err(e) => {
+            let mut err = String::new();
+            let span_formatter = |file, range| format!("{:?} {:?}", file, range);
+            match e {
+                ConstEvalError::MirLowerError(e) => e.pretty_print(&mut err, &db, span_formatter),
+                ConstEvalError::MirEvalError(e) => e.pretty_print(&mut err, &db, span_formatter),
+            }
+            .unwrap();
+            panic!("Error in evaluating goal: {}", err);
+        }
+    };
     match &r.data(Interner).value {
         chalk_ir::ConstValue::Concrete(c) => match &c.interned {
             ConstScalar::Bytes(b, _) => {
@@ -47,10 +64,9 @@ fn check_number(ra_fixture: &str, answer: i128) {
     }
 }
 
-fn eval_goal(ra_fixture: &str) -> Result<Const, ConstEvalError> {
-    let (db, file_id) = TestDB::with_single_file(ra_fixture);
+fn eval_goal(db: &TestDB, file_id: FileId) -> Result<Const, ConstEvalError> {
     let module_id = db.module_for_file(file_id);
-    let def_map = module_id.def_map(&db);
+    let def_map = module_id.def_map(db);
     let scope = &def_map[module_id.local_id].scope;
     let const_id = scope
         .declarations()
@@ -65,7 +81,7 @@ fn eval_goal(ra_fixture: &str) -> Result<Const, ConstEvalError> {
             _ => None,
         })
         .unwrap();
-    db.const_eval(const_id, Substitution::empty(Interner))
+    db.const_eval(const_id.into(), Substitution::empty(Interner))
 }
 
 #[test]
@@ -303,6 +319,81 @@ fn overloaded_index() {
     );
 }
 
+#[test]
+fn overloaded_binop() {
+    check_number(
+        r#"
+    //- minicore: add
+    enum Color {
+        Red,
+        Green,
+        Yellow,
+    }
+
+    use Color::*;
+
+    impl core::ops::Add for Color {
+        type Output = Color;
+        fn add(self, rhs: Color) -> Self::Output {
+            Yellow
+        }
+    }
+
+    impl core::ops::AddAssign for Color {
+        fn add_assign(&mut self, rhs: Color) {
+            *self = Red;
+        }
+    }
+
+    const GOAL: bool = {
+        let x = Red + Green;
+        let mut y = Green;
+        y += x;
+        x == Yellow && y == Red && Red + Green == Yellow && Red + Red == Yellow && Yellow + Green == Yellow
+    };
+    "#,
+        1,
+    );
+    check_number(
+        r#"
+    //- minicore: add
+    impl core::ops::Add for usize {
+        type Output = usize;
+        fn add(self, rhs: usize) -> Self::Output {
+            self + rhs
+        }
+    }
+
+    impl core::ops::AddAssign for usize {
+        fn add_assign(&mut self, rhs: usize) {
+            *self += rhs;
+        }
+    }
+
+    #[lang = "shl"]
+    pub trait Shl<Rhs = Self> {
+        type Output;
+
+        fn shl(self, rhs: Rhs) -> Self::Output;
+    }
+
+    impl Shl<u8> for usize {
+        type Output = usize;
+
+        fn shl(self, rhs: u8) -> Self::Output {
+            self << rhs
+        }
+    }
+
+    const GOAL: usize = {
+        let mut x = 10;
+        x += 20;
+        2 + 2 + (x << 1u8)
+    };"#,
+        64,
+    );
+}
+
 #[test]
 fn function_call() {
     check_number(
@@ -426,6 +517,16 @@ fn generic_fn() {
         "#,
         12,
     );
+    check_number(
+        r#"
+        const fn y<T>(b: T) -> (T, ) {
+            let alloc = b;
+            (alloc, )
+        }
+        const GOAL: u8 = y(2).0;
+        "#,
+        2,
+    );
     check_number(
         r#"
     //- minicore: coerce_unsized, index, slice
@@ -590,6 +691,30 @@ fn loops() {
         "#,
         8,
     );
+    check_number(
+        r#"
+    //- minicore: add
+    const GOAL: u8 = {
+        let mut x = 0;
+        'a: loop {
+            'b: loop {
+                'c: while x < 20 {
+                    'd: while x < 5 {
+                        'e: loop {
+                            x += 1;
+                            continue 'c;
+                        };
+                    };
+                    x += 1;
+                };
+                break 'a;
+            };
+        }
+        x
+    };
+        "#,
+        20,
+    );
 }
 
 #[test]
@@ -790,10 +915,12 @@ fn path_pattern_matching() {
 
     use Season::*;
 
+    const MY_SEASON: Season = Summer;
+
     const fn f(x: Season) -> i32 {
         match x {
             Spring => 1,
-            Summer => 2,
+            MY_SEASON => 2,
             Fall => 3,
             Winter => 4,
         }
@@ -944,19 +1071,10 @@ fn function_param_patterns() {
 fn match_guards() {
     check_number(
         r#"
-    //- minicore: option, eq
-    impl<T: PartialEq> PartialEq for Option<T> {
-        fn eq(&self, other: &Rhs) -> bool {
-            match (self, other) {
-                (Some(x), Some(y)) => x == y,
-                (None, None) => true,
-                _ => false,
-            }
-        }
-    }
+    //- minicore: option
     fn f(x: Option<i32>) -> i32 {
         match x {
-            y if y == Some(42) => 42000,
+            y if let Some(42) = y => 42000,
             Some(y) => y,
             None => 10
         }
@@ -967,6 +1085,59 @@ fn match_guards() {
     );
 }
 
+#[test]
+fn result_layout_niche_optimization() {
+    check_number(
+        r#"
+    //- minicore: option, result
+    const GOAL: i32 = match Some(2).ok_or(Some(2)) {
+        Ok(x) => x,
+        Err(_) => 1000,
+    };
+        "#,
+        2,
+    );
+    check_number(
+        r#"
+    //- minicore: result
+    pub enum AlignmentEnum64 {
+        _Align1Shl0 = 1 << 0,
+        _Align1Shl1 = 1 << 1,
+        _Align1Shl2 = 1 << 2,
+        _Align1Shl3 = 1 << 3,
+        _Align1Shl4 = 1 << 4,
+        _Align1Shl5 = 1 << 5,
+    }
+    const GOAL: Result<AlignmentEnum64, ()> = {
+        let align = Err(());
+        align
+    };
+    "#,
+        0, // It is 0 since result is niche encoded and 1 is valid for `AlignmentEnum64`
+    );
+    check_number(
+        r#"
+    //- minicore: result
+    pub enum AlignmentEnum64 {
+        _Align1Shl0 = 1 << 0,
+        _Align1Shl1 = 1 << 1,
+        _Align1Shl2 = 1 << 2,
+        _Align1Shl3 = 1 << 3,
+        _Align1Shl4 = 1 << 4,
+        _Align1Shl5 = 1 << 5,
+    }
+    const GOAL: i32 = {
+        let align = Ok::<_, ()>(AlignmentEnum64::_Align1Shl0);
+        match align {
+            Ok(_) => 2,
+            Err(_) => 1,
+        }
+    };
+    "#,
+        2,
+    );
+}
+
 #[test]
 fn options() {
     check_number(
@@ -1147,6 +1318,16 @@ fn closures() {
     check_number(
         r#"
     //- minicore: fn, copy
+    const GOAL: i32 = {
+        let c: fn(i32) -> i32 = |x| 2 * x;
+        c(2) + c(10)
+    };
+        "#,
+        24,
+    );
+    check_number(
+        r#"
+    //- minicore: fn, copy
     struct X(i32);
     impl X {
         fn mult(&mut self, n: i32) {
@@ -1180,6 +1361,36 @@ fn closures() {
     );
 }
 
+#[test]
+fn closure_and_impl_fn() {
+    check_number(
+        r#"
+    //- minicore: fn, copy
+    fn closure_wrapper<F: FnOnce() -> i32>(c: F) -> impl FnOnce() -> F {
+        || c
+    }
+
+    const GOAL: i32 = {
+        let y = 5;
+        let c = closure_wrapper(|| y);
+        c()()
+    };
+        "#,
+        5,
+    );
+    check_number(
+        r#"
+    //- minicore: fn, copy
+    fn f<T, F: Fn() -> T>(t: F) -> impl Fn() -> T {
+        move || t()
+    }
+
+    const GOAL: i32 = f(|| 2)();
+        "#,
+        2,
+    );
+}
+
 #[test]
 fn or_pattern() {
     check_number(
@@ -1218,6 +1429,23 @@ fn or_pattern() {
     );
 }
 
+#[test]
+fn function_pointer_in_constants() {
+    check_number(
+        r#"
+    struct Foo {
+        f: fn(u8) -> u8,
+    }
+    const FOO: Foo = Foo { f: add2 };
+    fn add2(x: u8) -> u8 {
+        x + 2
+    }
+    const GOAL: u8 = (FOO.f)(3);
+        "#,
+        5,
+    );
+}
+
 #[test]
 fn function_pointer() {
     check_number(
@@ -1432,6 +1660,51 @@ fn dyn_trait() {
     );
 }
 
+#[test]
+fn boxes() {
+    check_number(
+        r#"
+//- minicore: coerce_unsized, deref_mut, slice
+use core::ops::{Deref, DerefMut};
+use core::{marker::Unsize, ops::CoerceUnsized};
+
+#[lang = "owned_box"]
+pub struct Box<T: ?Sized> {
+    inner: *mut T,
+}
+impl<T> Box<T> {
+    fn new(t: T) -> Self {
+        #[rustc_box]
+        Box::new(t)
+    }
+}
+
+impl<T: ?Sized> Deref for Box<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &**self
+    }
+}
+
+impl<T: ?Sized> DerefMut for Box<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut **self
+    }
+}
+
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Box<U>> for Box<T> {}
+
+const GOAL: usize = {
+    let x = Box::new(5);
+    let y: Box<[i32]> = Box::new([1, 2, 3]);
+    *x + y.len()
+};
+"#,
+        8,
+    );
+}
+
 #[test]
 fn array_and_index() {
     check_number(
@@ -1504,6 +1777,37 @@ fn consts() {
     );
 }
 
+#[test]
+fn statics() {
+    check_number(
+        r#"
+    //- minicore: cell
+    use core::cell::Cell;
+    fn f() -> i32 {
+        static S: Cell<i32> = Cell::new(10);
+        S.set(S.get() + 1);
+        S.get()
+    }
+    const GOAL: i32 = f() + f() + f();
+    "#,
+        36,
+    );
+}
+
+#[test]
+fn extern_weak_statics() {
+    check_number(
+        r#"
+    extern "C" {
+        #[linkage = "extern_weak"]
+        static __dso_handle: *mut u8;
+    }
+    const GOAL: usize = __dso_handle as usize;
+    "#,
+        0,
+    );
+}
+
 #[test]
 fn enums() {
     check_number(
@@ -1531,13 +1835,13 @@ fn enums() {
     "#,
         0,
     );
-    let r = eval_goal(
+    let (db, file_id) = TestDB::with_single_file(
         r#"
         enum E { A = 1, B }
         const GOAL: E = E::A;
         "#,
-    )
-    .unwrap();
+    );
+    let r = eval_goal(&db, file_id).unwrap();
     assert_eq!(try_const_usize(&r), Some(1));
 }
 
@@ -1550,7 +1854,7 @@ fn const_loop() {
     const F2: i32 = 2 * F1;
     const GOAL: i32 = F3;
     "#,
-        ConstEvalError::MirLowerError(MirLowerError::Loop),
+        |e| e == ConstEvalError::MirLowerError(MirLowerError::Loop),
     );
 }
 
@@ -1609,8 +1913,7 @@ fn const_generic_subst_assoc_const_impl() {
 
 #[test]
 fn const_trait_assoc() {
-    // FIXME: this should evaluate to 0
-    check_fail(
+    check_number(
         r#"
     struct U0;
     trait ToConst {
@@ -1619,9 +1922,35 @@ fn const_trait_assoc() {
     impl ToConst for U0 {
         const VAL: usize = 0;
     }
-    const GOAL: usize = U0::VAL;
+    impl ToConst for i32 {
+        const VAL: usize = 32;
+    }
+    const GOAL: usize = U0::VAL + i32::VAL;
     "#,
-        ConstEvalError::MirLowerError(MirLowerError::IncompleteExpr),
+        32,
+    );
+    check_number(
+        r#"
+    struct S<T>(*mut T);
+
+    trait MySized: Sized {
+        const SIZE: S<Self> = S(1 as *mut Self);
+    }
+
+    impl MySized for i32 {
+        const SIZE: S<i32> = S(10 as *mut i32);
+    }
+
+    impl MySized for i64 {
+    }
+
+    const fn f<T: MySized>() -> usize {
+        T::SIZE.0 as usize
+    }
+
+    const GOAL: usize = f::<i32>() + f::<i64>() * 2;
+    "#,
+        12,
     );
 }
 
@@ -1631,7 +1960,7 @@ fn exec_limits() {
         r#"
     const GOAL: usize = loop {};
     "#,
-        ConstEvalError::MirEvalError(MirEvalError::ExecutionLimitExceeded),
+        |e| e == ConstEvalError::MirEvalError(MirEvalError::ExecutionLimitExceeded),
     );
     check_fail(
         r#"
@@ -1640,7 +1969,7 @@ fn exec_limits() {
     }
     const GOAL: i32 = f(0);
     "#,
-        ConstEvalError::MirEvalError(MirEvalError::StackOverflow),
+        |e| e == ConstEvalError::MirEvalError(MirEvalError::StackOverflow),
     );
     // Reasonable code should still work
     check_number(
@@ -1665,7 +1994,7 @@ fn exec_limits() {
 
 #[test]
 fn type_error() {
-    let e = eval_goal(
+    check_fail(
         r#"
     const GOAL: u8 = {
         let x: u16 = 2;
@@ -1673,6 +2002,6 @@ fn type_error() {
         y.0
     };
     "#,
+        |e| matches!(e, ConstEvalError::MirLowerError(MirLowerError::TypeMismatch(_))),
     );
-    assert!(matches!(e, Err(ConstEvalError::MirLowerError(MirLowerError::TypeMismatch(_)))));
 }
diff --git a/crates/hir-ty/src/consteval/tests/intrinsics.rs b/crates/hir-ty/src/consteval/tests/intrinsics.rs
index 5c47e1f00a4..40e68823acd 100644
--- a/crates/hir-ty/src/consteval/tests/intrinsics.rs
+++ b/crates/hir-ty/src/consteval/tests/intrinsics.rs
@@ -67,6 +67,135 @@ fn wrapping_add() {
     );
 }
 
+#[test]
+fn allocator() {
+    check_number(
+        r#"
+        extern "Rust" {
+            #[rustc_allocator]
+            fn __rust_alloc(size: usize, align: usize) -> *mut u8;
+            #[rustc_deallocator]
+            fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize);
+            #[rustc_reallocator]
+            fn __rust_realloc(ptr: *mut u8, old_size: usize, align: usize, new_size: usize) -> *mut u8;
+            #[rustc_allocator_zeroed]
+            fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8;
+        }
+
+        const GOAL: u8 = unsafe {
+            let ptr = __rust_alloc(4, 1);
+            let ptr2 = ((ptr as usize) + 1) as *mut u8;
+            *ptr = 23;
+            *ptr2 = 32;
+            let ptr = __rust_realloc(ptr, 4, 1, 8);
+            let ptr2 = ((ptr as usize) + 1) as *mut u8;
+            *ptr + *ptr2
+        };
+        "#,
+        55,
+    );
+}
+
+#[test]
+fn overflowing_add() {
+    check_number(
+        r#"
+        extern "rust-intrinsic" {
+            pub fn add_with_overflow<T>(x: T, y: T) -> (T, bool);
+        }
+
+        const GOAL: u8 = add_with_overflow(1, 2).0;
+        "#,
+        3,
+    );
+    check_number(
+        r#"
+        extern "rust-intrinsic" {
+            pub fn add_with_overflow<T>(x: T, y: T) -> (T, bool);
+        }
+
+        const GOAL: u8 = add_with_overflow(1, 2).1 as u8;
+        "#,
+        0,
+    );
+}
+
+#[test]
+fn needs_drop() {
+    check_number(
+        r#"
+        //- minicore: copy, sized
+        extern "rust-intrinsic" {
+            pub fn needs_drop<T: ?Sized>() -> bool;
+        }
+        struct X;
+        const GOAL: bool = !needs_drop::<i32>() && needs_drop::<X>();
+        "#,
+        1,
+    );
+}
+
+#[test]
+fn likely() {
+    check_number(
+        r#"
+        extern "rust-intrinsic" {
+            pub fn likely(b: bool) -> bool;
+            pub fn unlikely(b: bool) -> bool;
+        }
+
+        const GOAL: bool = likely(true) && unlikely(true) && !likely(false) && !unlikely(false);
+        "#,
+        1,
+    );
+}
+
+#[test]
+fn atomic() {
+    check_number(
+        r#"
+        //- minicore: copy
+        extern "rust-intrinsic" {
+            pub fn atomic_load_seqcst<T: Copy>(src: *const T) -> T;
+            pub fn atomic_xchg_acquire<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_cxchg_release_seqcst<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+            pub fn atomic_cxchgweak_acquire_acquire<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+            pub fn atomic_store_release<T: Copy>(dst: *mut T, val: T);
+            pub fn atomic_xadd_acqrel<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_xsub_seqcst<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_and_acquire<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_nand_seqcst<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_or_release<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_xor_seqcst<T: Copy>(dst: *mut T, src: T) -> T;
+        }
+
+        fn should_not_reach() {
+            _ // fails the test if executed
+        }
+
+        const GOAL: i32 = {
+            let mut x = 5;
+            atomic_store_release(&mut x, 10);
+            let mut y = atomic_xchg_acquire(&mut x, 100);
+            atomic_xadd_acqrel(&mut y, 20);
+            if (30, true) != atomic_cxchg_release_seqcst(&mut y, 30, 40) {
+                should_not_reach();
+            }
+            if (40, false) != atomic_cxchg_release_seqcst(&mut y, 30, 50) {
+                should_not_reach();
+            }
+            if (40, true) != atomic_cxchgweak_acquire_acquire(&mut y, 40, 30) {
+                should_not_reach();
+            }
+            let mut z = atomic_xsub_seqcst(&mut x, -200);
+            atomic_xor_seqcst(&mut x, 1024);
+            atomic_load_seqcst(&x) + z * 3 + atomic_load_seqcst(&y) * 2
+        };
+        "#,
+        660 + 1024,
+    );
+}
+
 #[test]
 fn offset() {
     check_number(
diff --git a/crates/hir-ty/src/db.rs b/crates/hir-ty/src/db.rs
index c415689399f..963b3b72abb 100644
--- a/crates/hir-ty/src/db.rs
+++ b/crates/hir-ty/src/db.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use base_db::{impl_intern_key, salsa, CrateId, Upcast};
 use hir_def::{
-    db::DefDatabase, hir::ExprId, layout::TargetDataLayout, AdtId, BlockId, ConstId, ConstParamId,
+    db::DefDatabase, hir::ExprId, layout::TargetDataLayout, AdtId, BlockId, ConstParamId,
     DefWithBodyId, EnumVariantId, FunctionId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId,
     TypeOrConstParamId, VariantId,
 };
@@ -59,7 +59,7 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
 
     #[salsa::invoke(crate::consteval::const_eval_query)]
     #[salsa::cycle(crate::consteval::const_eval_recover)]
-    fn const_eval(&self, def: ConstId, subst: Substitution) -> Result<Const, ConstEvalError>;
+    fn const_eval(&self, def: DefWithBodyId, subst: Substitution) -> Result<Const, ConstEvalError>;
 
     #[salsa::invoke(crate::consteval::const_eval_discriminant_variant)]
     #[salsa::cycle(crate::consteval::const_eval_discriminant_recover)]
diff --git a/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs b/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs
index 7460f43387f..a0f6b9368ee 100644
--- a/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs
+++ b/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs
@@ -772,7 +772,7 @@ impl<'p> Fields<'p> {
 
         (0..fields_len).map(|idx| LocalFieldId::from_raw(idx.into())).filter_map(move |fid| {
             let ty = field_ty[fid].clone().substitute(Interner, substs);
-            let ty = normalize(cx.db, cx.body, ty);
+            let ty = normalize(cx.db, cx.db.trait_environment_for_body(cx.body), ty);
             let is_visible = matches!(adt, hir_def::AdtId::EnumId(..))
                 || visibility[fid].is_visible_from(cx.db.upcast(), cx.module);
             let is_uninhabited = cx.is_uninhabited(&ty);
diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index d445abae923..3cfe78141d4 100644
--- a/crates/hir-ty/src/display.rs
+++ b/crates/hir-ty/src/display.rs
@@ -32,7 +32,7 @@ use crate::{
     mapping::from_chalk,
     mir::pad16,
     primitive, to_assoc_type_id,
-    utils::{self, generics},
+    utils::{self, generics, ClosureSubst},
     AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, Const, ConstScalar, ConstValue,
     DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData, LifetimeOutlives,
     MemoryMap, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause, Scalar,
@@ -419,6 +419,16 @@ impl HirDisplay for Const {
             }
             ConstValue::Concrete(c) => match &c.interned {
                 ConstScalar::Bytes(b, m) => render_const_scalar(f, &b, m, &data.ty),
+                ConstScalar::UnevaluatedConst(c, parameters) => {
+                    let const_data = f.db.const_data(*c);
+                    write!(
+                        f,
+                        "{}",
+                        const_data.name.as_ref().and_then(|x| x.as_str()).unwrap_or("_")
+                    )?;
+                    hir_fmt_generics(f, parameters, Some((*c).into()))?;
+                    Ok(())
+                }
                 ConstScalar::Unknown => f.write_char('_'),
             },
         }
@@ -485,7 +495,7 @@ fn render_const_scalar(
         chalk_ir::TyKind::Ref(_, _, t) => match t.kind(Interner) {
             chalk_ir::TyKind::Str => {
                 let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());
-                let bytes = memory_map.0.get(&addr).map(|x| &**x).unwrap_or(&[]);
+                let bytes = memory_map.memory.get(&addr).map(|x| &**x).unwrap_or(&[]);
                 let s = std::str::from_utf8(bytes).unwrap_or("<utf8-error>");
                 write!(f, "{s:?}")
             }
@@ -574,6 +584,11 @@ fn render_const_scalar(
             hir_def::AdtId::EnumId(_) => f.write_str("<enum-not-supported>"),
         },
         chalk_ir::TyKind::FnDef(..) => ty.hir_fmt(f),
+        chalk_ir::TyKind::Raw(_, _) => {
+            let x = u128::from_le_bytes(pad16(b, false));
+            write!(f, "{:#X} as ", x)?;
+            ty.hir_fmt(f)
+        }
         _ => f.write_str("<not-supported>"),
     }
 }
@@ -794,82 +809,9 @@ impl HirDisplay for Ty {
                 }
                 f.end_location_link();
 
-                if parameters.len(Interner) > 0 {
-                    let parameters_to_write = if f.display_target.is_source_code()
-                        || f.omit_verbose_types()
-                    {
-                        match self
-                            .as_generic_def(db)
-                            .map(|generic_def_id| db.generic_defaults(generic_def_id))
-                            .filter(|defaults| !defaults.is_empty())
-                        {
-                            None => parameters.as_slice(Interner),
-                            Some(default_parameters) => {
-                                fn should_show(
-                                    parameter: &GenericArg,
-                                    default_parameters: &[Binders<GenericArg>],
-                                    i: usize,
-                                    parameters: &Substitution,
-                                ) -> bool {
-                                    if parameter.ty(Interner).map(|x| x.kind(Interner))
-                                        == Some(&TyKind::Error)
-                                    {
-                                        return true;
-                                    }
-                                    if let Some(ConstValue::Concrete(c)) = parameter
-                                        .constant(Interner)
-                                        .map(|x| &x.data(Interner).value)
-                                    {
-                                        if c.interned == ConstScalar::Unknown {
-                                            return true;
-                                        }
-                                    }
-                                    let default_parameter = match default_parameters.get(i) {
-                                        Some(x) => x,
-                                        None => return true,
-                                    };
-                                    let actual_default =
-                                        default_parameter.clone().substitute(Interner, &parameters);
-                                    parameter != &actual_default
-                                }
-                                let mut default_from = 0;
-                                for (i, parameter) in parameters.iter(Interner).enumerate() {
-                                    if should_show(parameter, &default_parameters, i, parameters) {
-                                        default_from = i + 1;
-                                    }
-                                }
-                                &parameters.as_slice(Interner)[0..default_from]
-                            }
-                        }
-                    } else {
-                        parameters.as_slice(Interner)
-                    };
-                    if !parameters_to_write.is_empty() {
-                        write!(f, "<")?;
-
-                        if f.display_target.is_source_code() {
-                            let mut first = true;
-                            for generic_arg in parameters_to_write {
-                                if !first {
-                                    write!(f, ", ")?;
-                                }
-                                first = false;
-
-                                if generic_arg.ty(Interner).map(|ty| ty.kind(Interner))
-                                    == Some(&TyKind::Error)
-                                {
-                                    write!(f, "_")?;
-                                } else {
-                                    generic_arg.hir_fmt(f)?;
-                                }
-                            }
-                        } else {
-                            f.write_joined(parameters_to_write, ", ")?;
-                        }
+                let generic_def = self.as_generic_def(db);
 
-                        write!(f, ">")?;
-                    }
-                }
+                hir_fmt_generics(f, parameters, generic_def)?;
             }
             TyKind::AssociatedType(assoc_type_id, parameters) => {
                 let type_alias = from_assoc_type_id(*assoc_type_id);
@@ -983,7 +925,7 @@ impl HirDisplay for Ty {
                     }
                     _ => (),
                 }
-                let sig = substs.at(Interner, 0).assert_ty_ref(Interner).callable_sig(db);
+                let sig = ClosureSubst(substs).sig_ty().callable_sig(db);
                 if let Some(sig) = sig {
                     let (def, _) = db.lookup_intern_closure((*id).into());
                     let infer = db.infer(def);
@@ -1141,6 +1083,85 @@ impl HirDisplay for Ty {
     }
 }
 
+fn hir_fmt_generics(
+    f: &mut HirFormatter<'_>,
+    parameters: &Substitution,
+    generic_def: Option<hir_def::GenericDefId>,
+) -> Result<(), HirDisplayError> {
+    let db = f.db;
+    if parameters.len(Interner) > 0 {
+        let parameters_to_write = if f.display_target.is_source_code() || f.omit_verbose_types() {
+            match generic_def
+                .map(|generic_def_id| db.generic_defaults(generic_def_id))
+                .filter(|defaults| !defaults.is_empty())
+            {
+                None => parameters.as_slice(Interner),
+                Some(default_parameters) => {
+                    fn should_show(
+                        parameter: &GenericArg,
+                        default_parameters: &[Binders<GenericArg>],
+                        i: usize,
+                        parameters: &Substitution,
+                    ) -> bool {
+                        if parameter.ty(Interner).map(|x| x.kind(Interner)) == Some(&TyKind::Error)
+                        {
+                            return true;
+                        }
+                        if let Some(ConstValue::Concrete(c)) =
+                            parameter.constant(Interner).map(|x| &x.data(Interner).value)
+                        {
+                            if c.interned == ConstScalar::Unknown {
+                                return true;
+                            }
+                        }
+                        let default_parameter = match default_parameters.get(i) {
+                            Some(x) => x,
+                            None => return true,
+                        };
+                        let actual_default =
+                            default_parameter.clone().substitute(Interner, &parameters);
+                        parameter != &actual_default
+                    }
+                    let mut default_from = 0;
+                    for (i, parameter) in parameters.iter(Interner).enumerate() {
+                        if should_show(parameter, &default_parameters, i, parameters) {
+                            default_from = i + 1;
+                        }
+                    }
+                    &parameters.as_slice(Interner)[0..default_from]
+                }
+            }
+        } else {
+            parameters.as_slice(Interner)
+        };
+        if !parameters_to_write.is_empty() {
+            write!(f, "<")?;
+
+            if f.display_target.is_source_code() {
+                let mut first = true;
+                for generic_arg in parameters_to_write {
+                    if !first {
+                        write!(f, ", ")?;
+                    }
+                    first = false;
+
+                    if generic_arg.ty(Interner).map(|ty| ty.kind(Interner)) == Some(&TyKind::Error)
+                    {
+                        write!(f, "_")?;
+                    } else {
+                        generic_arg.hir_fmt(f)?;
+                    }
+                }
+            } else {
+                f.write_joined(parameters_to_write, ", ")?;
+            }
+
+            write!(f, ">")?;
+        }
+    }
+    Ok(())
+}
+
 impl HirDisplay for CallableSig {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         write!(f, "fn(")?;
diff --git a/crates/hir-ty/src/infer.rs b/crates/hir-ty/src/infer.rs
index 64e31583095..ba0b6d254b7 100644
--- a/crates/hir-ty/src/infer.rs
+++ b/crates/hir-ty/src/infer.rs
@@ -44,7 +44,7 @@ use crate::{
     db::HirDatabase, fold_tys, infer::coerce::CoerceMany, lower::ImplTraitLoweringMode,
     static_lifetime, to_assoc_type_id, traits::FnTrait, AliasEq, AliasTy, ClosureId, DomainGoal,
     GenericArg, Goal, ImplTraitId, InEnvironment, Interner, ProjectionTy, RpitId, Substitution,
-    TraitRef, Ty, TyBuilder, TyExt, TyKind,
+    TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind,
 };
 
 // This lint has a false positive here. See the link below for details.
@@ -117,11 +117,10 @@ pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<Infer
 ///
 /// This is appropriate to use only after type-check: it assumes
 /// that normalization will succeed, for example.
-pub(crate) fn normalize(db: &dyn HirDatabase, owner: DefWithBodyId, ty: Ty) -> Ty {
+pub(crate) fn normalize(db: &dyn HirDatabase, trait_env: Arc<TraitEnvironment>, ty: Ty) -> Ty {
     if !ty.data(Interner).flags.intersects(TypeFlags::HAS_PROJECTION) {
         return ty;
     }
-    let trait_env = db.trait_environment_for_body(owner);
     let mut table = unify::InferenceTable::new(db, trait_env);
 
     let ty_with_vars = table.normalize_associated_types_in(ty);
diff --git a/crates/hir-ty/src/infer/closure.rs b/crates/hir-ty/src/infer/closure.rs
index 346c7f6df66..d3acbf7b404 100644
--- a/crates/hir-ty/src/infer/closure.rs
+++ b/crates/hir-ty/src/infer/closure.rs
@@ -2,7 +2,11 @@
 
 use std::{cmp, collections::HashMap, convert::Infallible, mem};
 
-use chalk_ir::{cast::Cast, AliasEq, AliasTy, FnSubst, Mutability, TyKind, WhereClause};
+use chalk_ir::{
+    cast::Cast,
+    fold::{FallibleTypeFolder, TypeFoldable},
+    AliasEq, AliasTy, BoundVar, DebruijnIndex, FnSubst, Mutability, TyKind, WhereClause,
+};
 use hir_def::{
     data::adt::VariantData,
     hir::{
@@ -11,7 +15,7 @@ use hir_def::{
     },
     lang_item::LangItem,
     resolver::{resolver_for_expr, ResolveValueResult, ValueNs},
-    FieldId, HasModule, VariantId,
+    DefWithBodyId, FieldId, HasModule, VariantId,
 };
 use hir_expand::name;
 use rustc_hash::FxHashMap;
@@ -20,12 +24,13 @@ use stdx::never;
 
 use crate::{
     db::HirDatabase,
+    from_placeholder_idx, make_binders,
     mir::{BorrowKind, MirSpan, ProjectionElem},
     static_lifetime, to_chalk_trait_id,
     traits::FnTrait,
-    utils::{self, pattern_matching_dereference_count},
-    Adjust, Adjustment, Canonical, CanonicalVarKinds, ChalkTraitId, ClosureId, DynTy, FnPointer,
-    FnSig, InEnvironment, Interner, Substitution, Ty, TyBuilder, TyExt,
+    utils::{self, generics, pattern_matching_dereference_count, Generics},
+    Adjust, Adjustment, Binders, ChalkTraitId, ClosureId, DynTy, FnPointer, FnSig, Interner,
+    Substitution, Ty, TyExt,
 };
 
 use super::{Expectation, InferenceContext};
@@ -117,7 +122,7 @@ impl HirPlace {
     fn ty(&self, ctx: &mut InferenceContext<'_>) -> Ty {
         let mut ty = ctx.table.resolve_completely(ctx.result[self.local].clone());
         for p in &self.projections {
-            ty = p.projected_ty(ty, ctx.db, |_, _| {
+            ty = p.projected_ty(ty, ctx.db, |_, _, _| {
                 unreachable!("Closure field only happens in MIR");
             });
         }
@@ -152,7 +157,7 @@ pub struct CapturedItem {
     pub(crate) place: HirPlace,
     pub(crate) kind: CaptureKind,
     pub(crate) span: MirSpan,
-    pub(crate) ty: Ty,
+    pub(crate) ty: Binders<Ty>,
 }
 
 impl CapturedItem {
@@ -232,6 +237,52 @@ pub(crate) struct CapturedItemWithoutTy {
 
 impl CapturedItemWithoutTy {
     fn with_ty(self, ctx: &mut InferenceContext<'_>) -> CapturedItem {
+        fn replace_placeholder_with_binder(
+            db: &dyn HirDatabase,
+            owner: DefWithBodyId,
+            ty: Ty,
+        ) -> Binders<Ty> {
+            struct Filler<'a> {
+                db: &'a dyn HirDatabase,
+                generics: Generics,
+            }
+            impl FallibleTypeFolder<Interner> for Filler<'_> {
+                type Error = ();
+
+                fn as_dyn(&mut self) -> &mut dyn FallibleTypeFolder<Interner, Error = Self::Error> {
+                    self
+                }
+
+                fn interner(&self) -> Interner {
+                    Interner
+                }
+
+                fn try_fold_free_placeholder_ty(
+                    &mut self,
+                    idx: chalk_ir::PlaceholderIndex,
+                    _outer_binder: DebruijnIndex,
+                ) -> std::result::Result<Ty, Self::Error> {
+                    let x = from_placeholder_idx(self.db, idx);
+                    let Some(idx) = self.generics.param_idx(x) else {
+                        return Err(());
+                    };
+                    Ok(TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, idx))
+                        .intern(Interner))
+                }
+            }
+            let g_def = match owner {
+                DefWithBodyId::FunctionId(f) => Some(f.into()),
+                DefWithBodyId::StaticId(_) => None,
+                DefWithBodyId::ConstId(f) => Some(f.into()),
+                DefWithBodyId::VariantId(f) => Some(f.into()),
+            };
+            let Some(generics) = g_def.map(|g_def| generics(db.upcast(), g_def)) else {
+                return Binders::empty(Interner, ty);
+            };
+            let filler = &mut Filler { db, generics };
+            let result = ty.clone().try_fold_with(filler, DebruijnIndex::INNERMOST).unwrap_or(ty);
+            make_binders(db, &filler.generics, result)
+        }
         let ty = self.place.ty(ctx).clone();
         let ty = match &self.kind {
             CaptureKind::ByValue => ty,
@@ -243,7 +294,12 @@ impl CapturedItemWithoutTy {
                 TyKind::Ref(m, static_lifetime(), ty).intern(Interner)
             }
         };
-        CapturedItem { place: self.place, kind: self.kind, span: self.span, ty }
+        CapturedItem {
+            place: self.place,
+            kind: self.kind,
+            span: self.span,
+            ty: replace_placeholder_with_binder(ctx.db, ctx.owner, ty),
+        }
     }
 }
 
@@ -590,17 +646,7 @@ impl InferenceContext<'_> {
             // without creating query cycles.
             return self.result.closure_info.get(id).map(|x| x.1 == FnTrait::Fn).unwrap_or(true);
         }
-        let crate_id = self.owner.module(self.db.upcast()).krate();
-        let Some(copy_trait) = self.db.lang_item(crate_id, LangItem::Copy).and_then(|x| x.as_trait()) else {
-            return false;
-        };
-        let trait_ref = TyBuilder::trait_ref(self.db, copy_trait).push(ty).build();
-        let env = self.db.trait_environment_for_body(self.owner);
-        let goal = Canonical {
-            value: InEnvironment::new(&env.env, trait_ref.cast(Interner)),
-            binders: CanonicalVarKinds::empty(Interner),
-        };
-        self.db.trait_solve(crate_id, None, goal).is_some()
+        ty.is_copy(self.db, self.owner)
     }
 
     fn select_from_expr(&mut self, expr: ExprId) {
diff --git a/crates/hir-ty/src/infer/coerce.rs b/crates/hir-ty/src/infer/coerce.rs
index 2249d84edbf..d613a5ff504 100644
--- a/crates/hir-ty/src/infer/coerce.rs
+++ b/crates/hir-ty/src/infer/coerce.rs
@@ -21,8 +21,10 @@ use crate::{
         Adjust, Adjustment, AutoBorrow, InferOk, InferenceContext, OverloadedDeref, PointerCast,
         TypeError, TypeMismatch,
     },
-    static_lifetime, Canonical, DomainGoal, FnPointer, FnSig, Guidance, InEnvironment, Interner,
-    Solution, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt,
+    static_lifetime,
+    utils::ClosureSubst,
+    Canonical, DomainGoal, FnPointer, FnSig, Guidance, InEnvironment, Interner, Solution,
+    Substitution, TraitEnvironment, Ty, TyBuilder, TyExt,
 };
 
 use super::unify::InferenceTable;
@@ -670,7 +672,7 @@ impl<'a> InferenceTable<'a> {
 }
 
 fn coerce_closure_fn_ty(closure_substs: &Substitution, safety: chalk_ir::Safety) -> Ty {
-    let closure_sig = closure_substs.at(Interner, 0).assert_ty_ref(Interner).clone();
+    let closure_sig = ClosureSubst(closure_substs).sig_ty().clone();
     match closure_sig.kind(Interner) {
         TyKind::Function(fn_ty) => TyKind::Function(FnPointer {
             num_binders: fn_ty.num_binders,
diff --git a/crates/hir-ty/src/infer/expr.rs b/crates/hir-ty/src/infer/expr.rs
index 2c37d25f54b..06ca9b026e3 100644
--- a/crates/hir-ty/src/infer/expr.rs
+++ b/crates/hir-ty/src/infer/expr.rs
@@ -282,7 +282,7 @@ impl<'a> InferenceContext<'a> {
                         let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into();
                         let closure_ty = TyKind::Closure(
                             closure_id,
-                            Substitution::from1(Interner, sig_ty.clone()),
+                            TyBuilder::subst_for_closure(self.db, self.owner, sig_ty.clone()),
                         )
                         .intern(Interner);
                         self.deferred_closures.entry(closure_id).or_default();
diff --git a/crates/hir-ty/src/layout.rs b/crates/hir-ty/src/layout.rs
index 512836afbf3..ebbf16caee1 100644
--- a/crates/hir-ty/src/layout.rs
+++ b/crates/hir-ty/src/layout.rs
@@ -1,5 +1,7 @@
 //! Compute the binary representation of a type
 
+use std::sync::Arc;
+
 use base_db::CrateId;
 use chalk_ir::{AdtId, TyKind};
 use hir_def::{
@@ -13,8 +15,8 @@ use la_arena::{Idx, RawIdx};
 use stdx::never;
 
 use crate::{
-    consteval::try_const_usize, db::HirDatabase, layout::adt::struct_variant_idx, Interner,
-    Substitution, Ty,
+    consteval::try_const_usize, db::HirDatabase, infer::normalize, layout::adt::struct_variant_idx,
+    utils::ClosureSubst, Interner, Substitution, TraitEnvironment, Ty,
 };
 
 pub use self::{
@@ -80,6 +82,8 @@ pub fn layout_of_ty(db: &dyn HirDatabase, ty: &Ty, krate: CrateId) -> Result<Lay
     let Some(target) = db.target_data_layout(krate) else { return Err(LayoutError::TargetLayoutNotAvailable) };
     let cx = LayoutCx { krate, target: &target };
     let dl = &*cx.current_data_layout();
+    let trait_env = Arc::new(TraitEnvironment::empty(krate));
+    let ty = normalize(db, trait_env, ty.clone());
     Ok(match ty.kind(Interner) {
         TyKind::Adt(AdtId(def), subst) => db.layout_of_adt(*def, subst.clone())?,
         TyKind::Scalar(s) => match s {
@@ -146,7 +150,7 @@ pub fn layout_of_ty(db: &dyn HirDatabase, ty: &Ty, krate: CrateId) -> Result<Lay
         }
         TyKind::Array(element, count) => {
             let count = try_const_usize(&count).ok_or(LayoutError::UserError(
-                "mismatched type of const generic parameter".to_string(),
+                "unevaluated or mistyped const generic parameter".to_string(),
             ))? as u64;
             let element = layout_of_ty(db, element, krate)?;
             let size = element.size.checked_mul(count, dl).ok_or(LayoutError::SizeOverflow)?;
@@ -252,13 +256,19 @@ pub fn layout_of_ty(db: &dyn HirDatabase, ty: &Ty, krate: CrateId) -> Result<Lay
                 }
             }
         }
-        TyKind::Closure(c, _) => {
+        TyKind::Closure(c, subst) => {
             let (def, _) = db.lookup_intern_closure((*c).into());
             let infer = db.infer(def);
             let (captures, _) = infer.closure_info(c);
             let fields = captures
                 .iter()
-                .map(|x| layout_of_ty(db, &x.ty, krate))
+                .map(|x| {
+                    layout_of_ty(
+                        db,
+                        &x.ty.clone().substitute(Interner, ClosureSubst(subst).parent_subst()),
+                        krate,
+                    )
+                })
                 .collect::<Result<Vec<_>, _>>()?;
             let fields = fields.iter().collect::<Vec<_>>();
             let fields = fields.iter().collect::<Vec<_>>();
diff --git a/crates/hir-ty/src/layout/tests.rs b/crates/hir-ty/src/layout/tests.rs
index 3cd0cd399c4..1502ab14cc7 100644
--- a/crates/hir-ty/src/layout/tests.rs
+++ b/crates/hir-ty/src/layout/tests.rs
@@ -218,6 +218,22 @@ fn generic() {
     }
 }
 
+#[test]
+fn associated_types() {
+    size_and_align! {
+        trait Tr {
+            type Ty;
+        }
+
+        impl Tr for i32 {
+            type Ty = i64;
+        }
+
+        struct Foo<A: Tr>(<A as Tr>::Ty);
+        struct Goal(Foo<i32>);
+    }
+}
+
 #[test]
 fn return_position_impl_trait() {
     size_and_align_expr! {
diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs
index e5b356dde6c..071d95839ec 100644
--- a/crates/hir-ty/src/lib.rs
+++ b/crates/hir-ty/src/lib.rs
@@ -44,10 +44,10 @@ use chalk_ir::{
     NoSolution, TyData,
 };
 use either::Either;
-use hir_def::{hir::ExprId, type_ref::Rawness, TypeOrConstParamId};
+use hir_def::{hir::ExprId, type_ref::Rawness, ConstId, TypeOrConstParamId};
 use hir_expand::name;
 use la_arena::{Arena, Idx};
-use mir::MirEvalError;
+use mir::{MirEvalError, VTableMap};
 use rustc_hash::FxHashSet;
 use traits::FnTrait;
 use utils::Generics;
@@ -151,11 +151,14 @@ pub type WhereClause = chalk_ir::WhereClause<Interner>;
 /// the necessary bits of memory of the const eval session to keep the constant
 /// meaningful.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub struct MemoryMap(pub HashMap<usize, Vec<u8>>);
+pub struct MemoryMap {
+    pub memory: HashMap<usize, Vec<u8>>,
+    pub vtable: VTableMap,
+}
 
 impl MemoryMap {
     fn insert(&mut self, addr: usize, x: Vec<u8>) {
-        self.0.insert(addr, x);
+        self.memory.insert(addr, x);
     }
 
     /// This functions convert each address by a function `f` which gets the byte intervals and assign an address
@@ -165,7 +168,7 @@ impl MemoryMap {
         &self,
         mut f: impl FnMut(&[u8]) -> Result<usize, MirEvalError>,
     ) -> Result<HashMap<usize, usize>, MirEvalError> {
-        self.0.iter().map(|x| Ok((*x.0, f(x.1)?))).collect()
+        self.memory.iter().map(|x| Ok((*x.0, f(x.1)?))).collect()
     }
 }
 
@@ -173,6 +176,9 @@ impl MemoryMap {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ConstScalar {
     Bytes(Vec<u8>, MemoryMap),
+    // FIXME: this is a hack to get around chalk not being able to represent unevaluatable
+    // constants
+    UnevaluatedConst(ConstId, Substitution),
     /// Case of an unknown value that rustc might know but we don't
     // FIXME: this is a hack to get around chalk not being able to represent unevaluatable
     // constants
diff --git a/crates/hir-ty/src/mir.rs b/crates/hir-ty/src/mir.rs
index fef00771199..4846bbfe5fd 100644
--- a/crates/hir-ty/src/mir.rs
+++ b/crates/hir-ty/src/mir.rs
@@ -3,13 +3,14 @@
 use std::{fmt::Display, iter};
 
 use crate::{
-    db::HirDatabase, display::HirDisplay, infer::PointerCast, lang_items::is_box, ClosureId, Const,
-    ConstScalar, InferenceResult, Interner, MemoryMap, Substitution, Ty, TyKind,
+    db::HirDatabase, display::HirDisplay, infer::PointerCast, lang_items::is_box, mapping::ToChalk,
+    CallableDefId, ClosureId, Const, ConstScalar, InferenceResult, Interner, MemoryMap,
+    Substitution, Ty, TyKind,
 };
 use chalk_ir::Mutability;
 use hir_def::{
     hir::{BindingId, Expr, ExprId, Ordering, PatId},
-    DefWithBodyId, FieldId, UnionId, VariantId,
+    DefWithBodyId, FieldId, StaticId, UnionId, VariantId,
 };
 use la_arena::{Arena, ArenaMap, Idx, RawIdx};
 
@@ -19,7 +20,7 @@ mod borrowck;
 mod pretty;
 
 pub use borrowck::{borrowck_query, BorrowckResult, MutabilityReason};
-pub use eval::{interpret_mir, pad16, Evaluator, MirEvalError};
+pub use eval::{interpret_mir, pad16, Evaluator, MirEvalError, VTableMap};
 pub use lower::{
     lower_to_mir, mir_body_for_closure_query, mir_body_query, mir_body_recover, MirLowerError,
 };
@@ -76,6 +77,9 @@ pub enum Operand {
     Move(Place),
     /// Constants are already semantically values, and remain unchanged.
     Constant(Const),
+    /// NON STANDARD: This kind of operand returns an immutable reference to that static memory. Rustc
+    /// handles it with the `Constant` variant somehow.
+    Static(StaticId),
 }
 
 impl Operand {
@@ -90,6 +94,17 @@ impl Operand {
     fn const_zst(ty: Ty) -> Operand {
         Self::from_bytes(vec![], ty)
     }
+
+    fn from_fn(
+        db: &dyn HirDatabase,
+        func_id: hir_def::FunctionId,
+        generic_args: Substitution,
+    ) -> Operand {
+        let ty =
+            chalk_ir::TyKind::FnDef(CallableDefId::FunctionId(func_id).to_chalk(db), generic_args)
+                .intern(Interner);
+        Operand::from_bytes(vec![], ty)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -110,7 +125,7 @@ impl<V, T> ProjectionElem<V, T> {
         &self,
         base: Ty,
         db: &dyn HirDatabase,
-        closure_field: impl FnOnce(ClosureId, usize) -> Ty,
+        closure_field: impl FnOnce(ClosureId, &Substitution, usize) -> Ty,
     ) -> Ty {
         match self {
             ProjectionElem::Deref => match &base.data(Interner).kind {
@@ -142,7 +157,7 @@ impl<V, T> ProjectionElem<V, T> {
                         never!("Out of bound tuple field");
                         TyKind::Error.intern(Interner)
                     }),
-                TyKind::Closure(id, _) => closure_field(*id, *f),
+                TyKind::Closure(id, subst) => closure_field(*id, subst, *f),
                 _ => {
                     never!("Only tuple or closure has tuple or closure field");
                     return TyKind::Error.intern(Interner);
@@ -261,7 +276,13 @@ impl SwitchTargets {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub enum Terminator {
+pub struct Terminator {
+    span: MirSpan,
+    kind: TerminatorKind,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum TerminatorKind {
     /// Block has one successor; we continue execution there.
     Goto { target: BasicBlockId },
 
@@ -836,6 +857,9 @@ pub enum Rvalue {
     /// affects alias analysis.
     ShallowInitBox(Operand, Ty),
 
+    /// NON STANDARD: allocates memory with the type's layout, and shallow init the box with the resulting pointer.
+    ShallowInitBoxWithAlloc(Ty),
+
     /// A CopyForDeref is equivalent to a read from a place at the
     /// codegen level, but is treated specially by drop elaboration. When such a read happens, it
     /// is guaranteed (via nature of the mir_opt `Derefer` in rustc_mir_transform/src/deref_separator)
@@ -918,7 +942,7 @@ impl MirBody {
                 Operand::Copy(p) | Operand::Move(p) => {
                     f(p);
                 }
-                Operand::Constant(_) => (),
+                Operand::Constant(_) | Operand::Static(_) => (),
             }
         }
         for (_, block) in self.basic_blocks.iter_mut() {
@@ -927,6 +951,7 @@ impl MirBody {
                     StatementKind::Assign(p, r) => {
                         f(p);
                         match r {
+                            Rvalue::ShallowInitBoxWithAlloc(_) => (),
                             Rvalue::ShallowInitBox(o, _)
                             | Rvalue::UnaryOp(_, o)
                             | Rvalue::Cast(_, o, _)
@@ -954,32 +979,32 @@ impl MirBody {
                 }
             }
             match &mut block.terminator {
-                Some(x) => match x {
-                    Terminator::SwitchInt { discr, .. } => for_operand(discr, &mut f),
-                    Terminator::FalseEdge { .. }
-                    | Terminator::FalseUnwind { .. }
-                    | Terminator::Goto { .. }
-                    | Terminator::Resume
-                    | Terminator::GeneratorDrop
-                    | Terminator::Abort
-                    | Terminator::Return
-                    | Terminator::Unreachable => (),
-                    Terminator::Drop { place, .. } => {
+                Some(x) => match &mut x.kind {
+                    TerminatorKind::SwitchInt { discr, .. } => for_operand(discr, &mut f),
+                    TerminatorKind::FalseEdge { .. }
+                    | TerminatorKind::FalseUnwind { .. }
+                    | TerminatorKind::Goto { .. }
+                    | TerminatorKind::Resume
+                    | TerminatorKind::GeneratorDrop
+                    | TerminatorKind::Abort
+                    | TerminatorKind::Return
+                    | TerminatorKind::Unreachable => (),
+                    TerminatorKind::Drop { place, .. } => {
                         f(place);
                     }
-                    Terminator::DropAndReplace { place, value, .. } => {
+                    TerminatorKind::DropAndReplace { place, value, .. } => {
                         f(place);
                         for_operand(value, &mut f);
                     }
-                    Terminator::Call { func, args, destination, .. } => {
+                    TerminatorKind::Call { func, args, destination, .. } => {
                         for_operand(func, &mut f);
                         args.iter_mut().for_each(|x| for_operand(x, &mut f));
                         f(destination);
                     }
-                    Terminator::Assert { cond, .. } => {
+                    TerminatorKind::Assert { cond, .. } => {
                         for_operand(cond, &mut f);
                     }
-                    Terminator::Yield { value, resume_arg, .. } => {
+                    TerminatorKind::Yield { value, resume_arg, .. } => {
                         for_operand(value, &mut f);
                         f(resume_arg);
                     }
diff --git a/crates/hir-ty/src/mir/borrowck.rs b/crates/hir-ty/src/mir/borrowck.rs
index 016090d509b..7b99fbf42f0 100644
--- a/crates/hir-ty/src/mir/borrowck.rs
+++ b/crates/hir-ty/src/mir/borrowck.rs
@@ -13,7 +13,7 @@ use crate::{db::HirDatabase, ClosureId};
 
 use super::{
     BasicBlockId, BorrowKind, LocalId, MirBody, MirLowerError, MirSpan, Place, ProjectionElem,
-    Rvalue, StatementKind, Terminator,
+    Rvalue, StatementKind, TerminatorKind,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -141,26 +141,26 @@ fn ever_initialized_map(body: &MirBody) -> ArenaMap<BasicBlockId, ArenaMap<Local
             never!("Terminator should be none only in construction");
             return;
         };
-        let targets = match terminator {
-            Terminator::Goto { target } => vec![*target],
-            Terminator::SwitchInt { targets, .. } => targets.all_targets().to_vec(),
-            Terminator::Resume
-            | Terminator::Abort
-            | Terminator::Return
-            | Terminator::Unreachable => vec![],
-            Terminator::Call { target, cleanup, destination, .. } => {
+        let targets = match &terminator.kind {
+            TerminatorKind::Goto { target } => vec![*target],
+            TerminatorKind::SwitchInt { targets, .. } => targets.all_targets().to_vec(),
+            TerminatorKind::Resume
+            | TerminatorKind::Abort
+            | TerminatorKind::Return
+            | TerminatorKind::Unreachable => vec![],
+            TerminatorKind::Call { target, cleanup, destination, .. } => {
                 if destination.projection.len() == 0 && destination.local == l {
                     is_ever_initialized = true;
                 }
                 target.into_iter().chain(cleanup.into_iter()).copied().collect()
             }
-            Terminator::Drop { .. }
-            | Terminator::DropAndReplace { .. }
-            | Terminator::Assert { .. }
-            | Terminator::Yield { .. }
-            | Terminator::GeneratorDrop
-            | Terminator::FalseEdge { .. }
-            | Terminator::FalseUnwind { .. } => {
+            TerminatorKind::Drop { .. }
+            | TerminatorKind::DropAndReplace { .. }
+            | TerminatorKind::Assert { .. }
+            | TerminatorKind::Yield { .. }
+            | TerminatorKind::GeneratorDrop
+            | TerminatorKind::FalseEdge { .. }
+            | TerminatorKind::FalseUnwind { .. } => {
                 never!("We don't emit these MIR terminators yet");
                 vec![]
             }
@@ -228,21 +228,21 @@ fn mutability_of_locals(body: &MirBody) -> ArenaMap<LocalId, MutabilityReason> {
             never!("Terminator should be none only in construction");
             continue;
         };
-        match terminator {
-            Terminator::Goto { .. }
-            | Terminator::Resume
-            | Terminator::Abort
-            | Terminator::Return
-            | Terminator::Unreachable
-            | Terminator::FalseEdge { .. }
-            | Terminator::FalseUnwind { .. }
-            | Terminator::GeneratorDrop
-            | Terminator::SwitchInt { .. }
-            | Terminator::Drop { .. }
-            | Terminator::DropAndReplace { .. }
-            | Terminator::Assert { .. }
-            | Terminator::Yield { .. } => (),
-            Terminator::Call { destination, .. } => {
+        match &terminator.kind {
+            TerminatorKind::Goto { .. }
+            | TerminatorKind::Resume
+            | TerminatorKind::Abort
+            | TerminatorKind::Return
+            | TerminatorKind::Unreachable
+            | TerminatorKind::FalseEdge { .. }
+            | TerminatorKind::FalseUnwind { .. }
+            | TerminatorKind::GeneratorDrop
+            | TerminatorKind::SwitchInt { .. }
+            | TerminatorKind::Drop { .. }
+            | TerminatorKind::DropAndReplace { .. }
+            | TerminatorKind::Assert { .. }
+            | TerminatorKind::Yield { .. } => (),
+            TerminatorKind::Call { destination, .. } => {
                 if destination.projection.len() == 0 {
                     if ever_init_map.get(destination.local).copied().unwrap_or_default() {
                         push_mut_span(destination.local, MirSpan::Unknown);
diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs
index bb33da97e33..01d27f2672c 100644
--- a/crates/hir-ty/src/mir/eval.rs
+++ b/crates/hir-ty/src/mir/eval.rs
@@ -1,39 +1,49 @@
 //! This module provides a MIR interpreter, which is used in const eval.
 
-use std::{borrow::Cow, collections::HashMap, iter, ops::Range, sync::Arc};
+use std::{borrow::Cow, collections::HashMap, fmt::Write, iter, ops::Range, sync::Arc};
 
-use base_db::CrateId;
+use base_db::{CrateId, FileId};
 use chalk_ir::{
     fold::{FallibleTypeFolder, TypeFoldable, TypeSuperFoldable},
-    DebruijnIndex, TyKind,
+    DebruijnIndex, Mutability,
 };
+use either::Either;
 use hir_def::{
     builtin_type::BuiltinType,
     lang_item::{lang_attr, LangItem},
     layout::{TagEncoding, Variants},
-    AdtId, DefWithBodyId, EnumVariantId, FunctionId, HasModule, ItemContainerId, Lookup, VariantId,
+    AdtId, DefWithBodyId, EnumVariantId, FunctionId, HasModule, ItemContainerId, Lookup, StaticId,
+    TypeOrConstParamId, VariantId,
 };
+use hir_expand::{name::Name, InFile};
 use intern::Interned;
 use la_arena::ArenaMap;
+use rustc_hash::FxHashMap;
+use syntax::{SyntaxNodePtr, TextRange};
 
 use crate::{
     consteval::{intern_const_scalar, ConstEvalError},
     db::HirDatabase,
+    display::{ClosureStyle, HirDisplay},
     from_placeholder_idx,
     infer::{normalize, PointerCast},
     layout::{layout_of_ty, Layout, LayoutError, RustcEnumVariantIdx},
     mapping::from_chalk,
-    method_resolution::{is_dyn_method, lookup_impl_method},
+    method_resolution::{is_dyn_method, lookup_impl_const, lookup_impl_method},
+    static_lifetime,
     traits::FnTrait,
+    utils::{generics, ClosureSubst, Generics},
     CallableDefId, ClosureId, Const, ConstScalar, FnDefId, GenericArgData, Interner, MemoryMap,
-    Substitution, TraitEnvironment, Ty, TyBuilder, TyExt,
+    Substitution, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,
 };
 
 use super::{
     const_as_usize, return_slot, AggregateKind, BinOp, CastKind, LocalId, MirBody, MirLowerError,
-    Operand, Place, ProjectionElem, Rvalue, StatementKind, Terminator, UnOp,
+    MirSpan, Operand, Place, ProjectionElem, Rvalue, StatementKind, TerminatorKind, UnOp,
 };
 
+mod shim;
+
 macro_rules! from_bytes {
     ($ty:tt, $value:expr) => {
         ($ty::from_le_bytes(match ($value).try_into() {
@@ -43,9 +53,15 @@ macro_rules! from_bytes {
     };
 }
 
-#[derive(Debug, Default)]
-struct VTableMap {
-    ty_to_id: HashMap<Ty, usize>,
+macro_rules! not_supported {
+    ($x: expr) => {
+        return Err(MirEvalError::NotSupported(format!($x)))
+    };
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct VTableMap {
+    ty_to_id: FxHashMap<Ty, usize>,
     id_to_ty: Vec<Ty>,
 }
 
@@ -75,6 +91,9 @@ pub struct Evaluator<'a> {
     trait_env: Arc<TraitEnvironment>,
     stack: Vec<u8>,
     heap: Vec<u8>,
+    /// Stores the global location of the statics. We const evaluate every static first time we need it
+    /// and see it's missing, then we add it to this to reuse.
+    static_locations: FxHashMap<StaticId, Address>,
     /// We don't really have function pointers, i.e. pointers to some assembly instructions that we can run. Instead, we
     /// store the type as an interned id in place of function and vtable pointers, and we recover back the type at the
     /// time of use.
@@ -88,7 +107,7 @@ pub struct Evaluator<'a> {
     stack_depth_limit: usize,
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 enum Address {
     Stack(usize),
     Heap(usize),
@@ -153,6 +172,13 @@ enum IntervalOrOwned {
     Owned(Vec<u8>),
     Borrowed(Interval),
 }
+
+impl From<Interval> for IntervalOrOwned {
+    fn from(it: Interval) -> IntervalOrOwned {
+        IntervalOrOwned::Borrowed(it)
+    }
+}
+
 impl IntervalOrOwned {
     pub(crate) fn to_vec(self, memory: &Evaluator<'_>) -> Result<Vec<u8>> {
         Ok(match self {
@@ -160,6 +186,13 @@ impl IntervalOrOwned {
             IntervalOrOwned::Borrowed(b) => b.get(memory)?.to_vec(),
         })
     }
+
+    fn get<'a>(&'a self, memory: &'a Evaluator<'a>) -> Result<&'a [u8]> {
+        Ok(match self {
+            IntervalOrOwned::Owned(o) => o,
+            IntervalOrOwned::Borrowed(b) => b.get(memory)?,
+        })
+    }
 }
 
 impl Address {
@@ -205,30 +238,129 @@ impl Address {
 
 #[derive(Clone, PartialEq, Eq)]
 pub enum MirEvalError {
-    ConstEvalError(Box<ConstEvalError>),
+    ConstEvalError(String, Box<ConstEvalError>),
     LayoutError(LayoutError, Ty),
     /// Means that code had type errors (or mismatched args) and we shouldn't generate mir in first place.
     TypeError(&'static str),
     /// Means that code had undefined behavior. We don't try to actively detect UB, but if it was detected
     /// then use this type of error.
-    UndefinedBehavior(&'static str),
+    UndefinedBehavior(String),
+    GenericArgNotProvided(TypeOrConstParamId, Substitution),
     Panic(String),
     MirLowerError(FunctionId, MirLowerError),
     MirLowerErrorForClosure(ClosureId, MirLowerError),
     TypeIsUnsized(Ty, &'static str),
     NotSupported(String),
     InvalidConst(Const),
-    InFunction(FunctionId, Box<MirEvalError>),
+    InFunction(Either<FunctionId, ClosureId>, Box<MirEvalError>, MirSpan, DefWithBodyId),
     ExecutionLimitExceeded,
     StackOverflow,
     TargetDataLayoutNotAvailable,
     InvalidVTableId(usize),
+    CoerceUnsizedError(Ty),
+}
+
+impl MirEvalError {
+    pub fn pretty_print(
+        &self,
+        f: &mut String,
+        db: &dyn HirDatabase,
+        span_formatter: impl Fn(FileId, TextRange) -> String,
+    ) -> std::result::Result<(), std::fmt::Error> {
+        writeln!(f, "Mir eval error:")?;
+        let mut err = self;
+        while let MirEvalError::InFunction(func, e, span, def) = err {
+            err = e;
+            match func {
+                Either::Left(func) => {
+                    let function_name = db.function_data(*func);
+                    writeln!(f, "In function {} ({:?})", function_name.name, func)?;
+                }
+                Either::Right(clos) => {
+                    writeln!(f, "In {:?}", clos)?;
+                }
+            }
+            let source_map = db.body_with_source_map(*def).1;
+            let span: InFile<SyntaxNodePtr> = match span {
+                MirSpan::ExprId(e) => match source_map.expr_syntax(*e) {
+                    Ok(s) => s.map(|x| x.into()),
+                    Err(_) => continue,
+                },
+                MirSpan::PatId(p) => match source_map.pat_syntax(*p) {
+                    Ok(s) => s.map(|x| match x {
+                        Either::Left(e) => e.into(),
+                        Either::Right(e) => e.into(),
+                    }),
+                    Err(_) => continue,
+                },
+                MirSpan::Unknown => continue,
+            };
+            let file_id = span.file_id.original_file(db.upcast());
+            let text_range = span.value.text_range();
+            writeln!(f, "{}", span_formatter(file_id, text_range))?;
+        }
+        match err {
+            MirEvalError::InFunction(..) => unreachable!(),
+            MirEvalError::LayoutError(err, ty) => {
+                write!(
+                    f,
+                    "Layout for type `{}` is not available due {err:?}",
+                    ty.display(db).with_closure_style(ClosureStyle::ClosureWithId).to_string()
+                )?;
+            }
+            MirEvalError::GenericArgNotProvided(id, subst) => {
+                let parent = id.parent;
+                let param = &db.generic_params(parent).type_or_consts[id.local_id];
+                writeln!(
+                    f,
+                    "Generic arg not provided for {}",
+                    param.name().unwrap_or(&Name::missing())
+                )?;
+                writeln!(f, "Provided args: [")?;
+                for g in subst.iter(Interner) {
+                    write!(f, "    {},", g.display(db).to_string())?;
+                }
+                writeln!(f, "]")?;
+            }
+            MirEvalError::MirLowerError(func, err) => {
+                let function_name = db.function_data(*func);
+                writeln!(
+                    f,
+                    "MIR lowering for function `{}` ({:?}) failed due:",
+                    function_name.name, func
+                )?;
+                err.pretty_print(f, db, span_formatter)?;
+            }
+            MirEvalError::ConstEvalError(name, err) => {
+                MirLowerError::ConstEvalError(name.clone(), err.clone()).pretty_print(
+                    f,
+                    db,
+                    span_formatter,
+                )?;
+            }
+            MirEvalError::TypeError(_)
+            | MirEvalError::UndefinedBehavior(_)
+            | MirEvalError::Panic(_)
+            | MirEvalError::MirLowerErrorForClosure(_, _)
+            | MirEvalError::TypeIsUnsized(_, _)
+            | MirEvalError::NotSupported(_)
+            | MirEvalError::InvalidConst(_)
+            | MirEvalError::ExecutionLimitExceeded
+            | MirEvalError::StackOverflow
+            | MirEvalError::TargetDataLayoutNotAvailable
+            | MirEvalError::CoerceUnsizedError(_)
+            | MirEvalError::InvalidVTableId(_) => writeln!(f, "{:?}", err)?,
+        }
+        Ok(())
+    }
 }
 
 impl std::fmt::Debug for MirEvalError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::ConstEvalError(arg0) => f.debug_tuple("ConstEvalError").field(arg0).finish(),
+            Self::ConstEvalError(arg0, arg1) => {
+                f.debug_tuple("ConstEvalError").field(arg0).field(arg1).finish()
+            }
             Self::LayoutError(arg0, arg1) => {
                 f.debug_tuple("LayoutError").field(arg0).field(arg1).finish()
             }
@@ -241,24 +373,28 @@ impl std::fmt::Debug for MirEvalError {
             Self::TypeIsUnsized(ty, it) => write!(f, "{ty:?} is unsized. {it} should be sized."),
             Self::ExecutionLimitExceeded => write!(f, "execution limit exceeded"),
             Self::StackOverflow => write!(f, "stack overflow"),
+            Self::GenericArgNotProvided(..) => f.debug_tuple("GenericArgNotProvided").finish(),
             Self::MirLowerError(arg0, arg1) => {
                 f.debug_tuple("MirLowerError").field(arg0).field(arg1).finish()
             }
             Self::MirLowerErrorForClosure(arg0, arg1) => {
                 f.debug_tuple("MirLowerError").field(arg0).field(arg1).finish()
             }
+            Self::CoerceUnsizedError(arg0) => {
+                f.debug_tuple("CoerceUnsizedError").field(arg0).finish()
+            }
             Self::InvalidVTableId(arg0) => f.debug_tuple("InvalidVTableId").field(arg0).finish(),
             Self::NotSupported(arg0) => f.debug_tuple("NotSupported").field(arg0).finish(),
             Self::InvalidConst(arg0) => {
                 let data = &arg0.data(Interner);
                 f.debug_struct("InvalidConst").field("ty", &data.ty).field("value", &arg0).finish()
             }
-            Self::InFunction(func, e) => {
+            Self::InFunction(func, e, span, _) => {
                 let mut e = &**e;
-                let mut stack = vec![*func];
-                while let Self::InFunction(f, next_e) = e {
+                let mut stack = vec![(*func, *span)];
+                while let Self::InFunction(f, next_e, span, _) = e {
                     e = &next_e;
-                    stack.push(*f);
+                    stack.push((*f, *span));
                 }
                 f.debug_struct("WithStack").field("error", e).field("stack", &stack).finish()
             }
@@ -266,22 +402,9 @@ impl std::fmt::Debug for MirEvalError {
     }
 }
 
-macro_rules! not_supported {
-    ($x: expr) => {
-        return Err(MirEvalError::NotSupported(format!($x)))
-    };
-}
-
-impl From<ConstEvalError> for MirEvalError {
-    fn from(value: ConstEvalError) -> Self {
-        match value {
-            _ => MirEvalError::ConstEvalError(Box::new(value)),
-        }
-    }
-}
-
 type Result<T> = std::result::Result<T, MirEvalError>;
 
+#[derive(Debug)]
 struct Locals<'a> {
     ptr: &'a ArenaMap<LocalId, Address>,
     body: &'a MirBody,
@@ -301,12 +424,14 @@ pub fn interpret_mir(
 ) -> Result<Const> {
     let ty = body.locals[return_slot()].ty.clone();
     let mut evaluator = Evaluator::new(db, body, assert_placeholder_ty_is_unused);
+    let ty = evaluator.ty_filler(&ty, &subst, body.owner)?;
     let bytes = evaluator.interpret_mir(&body, None.into_iter(), subst.clone())?;
-    let memory_map = evaluator.create_memory_map(
+    let mut memory_map = evaluator.create_memory_map(
         &bytes,
         &ty,
         &Locals { ptr: &ArenaMap::new(), body: &body, subst: &subst },
     )?;
+    memory_map.vtable = evaluator.vtable_map;
     return Ok(intern_const_scalar(ConstScalar::Bytes(bytes, memory_map), ty));
 }
 
@@ -322,6 +447,7 @@ impl Evaluator<'_> {
             stack: vec![0],
             heap: vec![0],
             vtable_map: VTableMap::default(),
+            static_locations: HashMap::default(),
             db,
             trait_env,
             crate_id,
@@ -365,15 +491,21 @@ impl Evaluator<'_> {
         let mut metadata = None; // locals are always sized
         for proj in &p.projection {
             let prev_ty = ty.clone();
-            ty = proj.projected_ty(ty, self.db, |c, f| {
+            ty = proj.projected_ty(ty, self.db, |c, subst, f| {
                 let (def, _) = self.db.lookup_intern_closure(c.into());
                 let infer = self.db.infer(def);
                 let (captures, _) = infer.closure_info(&c);
-                captures.get(f).expect("broken closure field").ty.clone()
+                let parent_subst = ClosureSubst(subst).parent_subst();
+                captures
+                    .get(f)
+                    .expect("broken closure field")
+                    .ty
+                    .clone()
+                    .substitute(Interner, parent_subst)
             });
             match proj {
                 ProjectionElem::Deref => {
-                    metadata = if self.size_of(&ty, locals)?.is_none() {
+                    metadata = if self.size_align_of(&ty, locals)?.is_none() {
                         Some(Interval { addr: addr.offset(self.ptr_size()), size: self.ptr_size() })
                     } else {
                         None
@@ -435,6 +567,11 @@ impl Evaluator<'_> {
             .map_err(|e| MirEvalError::LayoutError(e, ty.clone()))
     }
 
+    fn layout_filled(&self, ty: &Ty, locals: &Locals<'_>) -> Result<Layout> {
+        let ty = &self.ty_filler(ty, locals.subst, locals.body.owner)?;
+        self.layout(ty)
+    }
+
     fn layout_adt(&self, adt: AdtId, subst: Substitution) -> Result<Layout> {
         self.db.layout_of_adt(adt, subst.clone()).map_err(|e| {
             MirEvalError::LayoutError(e, TyKind::Adt(chalk_ir::AdtId(adt), subst).intern(Interner))
@@ -449,6 +586,10 @@ impl Evaluator<'_> {
         Ok(match o {
             Operand::Copy(p) | Operand::Move(p) => self.place_ty(p, locals)?,
             Operand::Constant(c) => c.data(Interner).ty.clone(),
+            &Operand::Static(s) => {
+                let ty = self.db.infer(s.into())[self.db.body(s.into()).body_expr].clone();
+                TyKind::Ref(Mutability::Not, static_lifetime(), ty).intern(Interner)
+            }
         })
     }
 
@@ -524,11 +665,11 @@ impl Evaluator<'_> {
             let Some(terminator) = current_block.terminator.as_ref() else {
                 not_supported!("block without terminator");
             };
-            match terminator {
-                Terminator::Goto { target } => {
+            match &terminator.kind {
+                TerminatorKind::Goto { target } => {
                     current_block_idx = *target;
                 }
-                Terminator::Call {
+                TerminatorKind::Call {
                     func,
                     args,
                     destination,
@@ -545,23 +686,36 @@ impl Evaluator<'_> {
                     match &fn_ty.data(Interner).kind {
                         TyKind::Function(_) => {
                             let bytes = self.eval_operand(func, &locals)?;
-                            self.exec_fn_pointer(bytes, destination, &args, &locals)?;
+                            self.exec_fn_pointer(
+                                bytes,
+                                destination,
+                                &args,
+                                &locals,
+                                terminator.span,
+                            )?;
                         }
                         TyKind::FnDef(def, generic_args) => {
-                            self.exec_fn_def(*def, generic_args, destination, &args, &locals)?;
+                            self.exec_fn_def(
+                                *def,
+                                generic_args,
+                                destination,
+                                &args,
+                                &locals,
+                                terminator.span,
+                            )?;
                         }
                         x => not_supported!("unknown function type {x:?}"),
                     }
                     current_block_idx = target.expect("broken mir, function without target");
                 }
-                Terminator::SwitchInt { discr, targets } => {
+                TerminatorKind::SwitchInt { discr, targets } => {
                     let val = u128::from_le_bytes(pad16(
                         self.eval_operand(discr, &locals)?.get(&self)?,
                         false,
                     ));
                     current_block_idx = targets.target_for_value(val);
                 }
-                Terminator::Return => {
+                TerminatorKind::Return => {
                     let ty = body.locals[return_slot()].ty.clone();
                     self.stack_depth_limit += 1;
                     return Ok(self
@@ -571,8 +725,8 @@ impl Evaluator<'_> {
                         )?
                         .to_owned());
                 }
-                Terminator::Unreachable => {
-                    return Err(MirEvalError::UndefinedBehavior("unreachable executed"));
+                TerminatorKind::Unreachable => {
+                    return Err(MirEvalError::UndefinedBehavior("unreachable executed".to_owned()));
                 }
                 _ => not_supported!("unknown terminator"),
             }
@@ -725,13 +879,13 @@ impl Evaluator<'_> {
                 };
                 match layout.variants {
                     Variants::Single { index } => {
-                        let r = self.db.const_eval_discriminant(EnumVariantId {
+                        let r = self.const_eval_discriminant(EnumVariantId {
                             parent: enum_id,
                             local_id: index.0,
                         })?;
                         Owned(r.to_le_bytes().to_vec())
                     }
-                    Variants::Multiple { tag, tag_encoding, .. } => {
+                    Variants::Multiple { tag, tag_encoding, variants, .. } => {
                         let Some(target_data_layout) = self.db.target_data_layout(self.crate_id) else {
                             not_supported!("missing target data layout");
                         };
@@ -744,25 +898,20 @@ impl Evaluator<'_> {
                             }
                             TagEncoding::Niche { untagged_variant, niche_start, .. } => {
                                 let tag = &bytes[offset..offset + size];
-                                let candidate_discriminant = i128::from_le_bytes(pad16(tag, false))
-                                    .wrapping_sub(niche_start as i128);
-                                let enum_data = self.db.enum_data(enum_id);
-                                let result = 'b: {
-                                    for (local_id, _) in enum_data.variants.iter() {
-                                        if candidate_discriminant
-                                            == self.db.const_eval_discriminant(EnumVariantId {
-                                                parent: enum_id,
-                                                local_id,
-                                            })?
-                                        {
-                                            break 'b candidate_discriminant;
-                                        }
-                                    }
-                                    self.db.const_eval_discriminant(EnumVariantId {
-                                        parent: enum_id,
-                                        local_id: untagged_variant.0,
-                                    })?
-                                };
+                                let candidate_tag = i128::from_le_bytes(pad16(tag, false))
+                                    .wrapping_sub(niche_start as i128)
+                                    as usize;
+                                let variant = variants
+                                    .iter_enumerated()
+                                    .map(|(x, _)| x)
+                                    .filter(|x| *x != untagged_variant)
+                                    .nth(candidate_tag)
+                                    .unwrap_or(untagged_variant)
+                                    .0;
+                                let result = self.const_eval_discriminant(EnumVariantId {
+                                    parent: enum_id,
+                                    local_id: variant,
+                                })?;
                                 Owned(result.to_le_bytes().to_vec())
                             }
                         }
@@ -771,6 +920,13 @@ impl Evaluator<'_> {
             }
             Rvalue::Repeat(_, _) => not_supported!("evaluating repeat rvalue"),
             Rvalue::ShallowInitBox(_, _) => not_supported!("shallow init box"),
+            Rvalue::ShallowInitBoxWithAlloc(ty) => {
+                let Some((size, align)) = self.size_align_of(ty, locals)? else {
+                    not_supported!("unsized box initialization");
+                };
+                let addr = self.heap_allocate(size, align);
+                Owned(addr.to_bytes())
+            }
             Rvalue::CopyForDeref(_) => not_supported!("copy for deref"),
             Rvalue::Aggregate(kind, values) => {
                 let values = values
@@ -787,12 +943,12 @@ impl Evaluator<'_> {
                         Owned(r)
                     }
                     AggregateKind::Tuple(ty) => {
-                        let layout = self.layout(&ty)?;
+                        let layout = self.layout_filled(&ty, locals)?;
                         Owned(self.make_by_layout(
                             layout.size.bytes_usize(),
                             &layout,
                             None,
-                            values.iter().copied(),
+                            values.iter().map(|&x| x.into()),
                         )?)
                     }
                     AggregateKind::Union(x, f) => {
@@ -814,74 +970,44 @@ impl Evaluator<'_> {
                             size,
                             &variant_layout,
                             tag,
-                            values.iter().copied(),
+                            values.iter().map(|&x| x.into()),
                         )?)
                     }
                     AggregateKind::Closure(ty) => {
-                        let layout = self.layout(&ty)?;
+                        let layout = self.layout_filled(&ty, locals)?;
                         Owned(self.make_by_layout(
                             layout.size.bytes_usize(),
                             &layout,
                             None,
-                            values.iter().copied(),
+                            values.iter().map(|&x| x.into()),
                         )?)
                     }
                 }
             }
             Rvalue::Cast(kind, operand, target_ty) => match kind {
                 CastKind::Pointer(cast) => match cast {
-                    PointerCast::ReifyFnPointer => {
+                    PointerCast::ReifyFnPointer | PointerCast::ClosureFnPointer(_) => {
                         let current_ty = self.operand_ty(operand, locals)?;
-                        if let TyKind::FnDef(_, _) = &current_ty.data(Interner).kind {
+                        if let TyKind::FnDef(_, _) | TyKind::Closure(_, _) =
+                            &current_ty.data(Interner).kind
+                        {
                             let id = self.vtable_map.id(current_ty);
                             let ptr_size = self.ptr_size();
                             Owned(id.to_le_bytes()[0..ptr_size].to_vec())
                         } else {
-                            not_supported!("ReifyFnPointer cast of a non FnDef type");
+                            not_supported!(
+                                "creating a fn pointer from a non FnDef or Closure type"
+                            );
                         }
                     }
                     PointerCast::Unsize => {
                         let current_ty = self.operand_ty(operand, locals)?;
-                        match &target_ty.data(Interner).kind {
-                            TyKind::Raw(_, ty) | TyKind::Ref(_, _, ty) => {
-                                match &ty.data(Interner).kind {
-                                    TyKind::Slice(_) => match &current_ty.data(Interner).kind {
-                                        TyKind::Raw(_, ty) | TyKind::Ref(_, _, ty) => {
-                                            match &ty.data(Interner).kind {
-                                                TyKind::Array(_, size) => {
-                                                    let addr = self
-                                                        .eval_operand(operand, locals)?
-                                                        .get(&self)?;
-                                                    let len = const_as_usize(size);
-                                                    let mut r = Vec::with_capacity(16);
-                                                    r.extend(addr.iter().copied());
-                                                    r.extend(len.to_le_bytes().into_iter());
-                                                    Owned(r)
-                                                }
-                                                _ => {
-                                                    not_supported!("slice unsizing from non arrays")
-                                                }
-                                            }
-                                        }
-                                        _ => not_supported!("slice unsizing from non pointers"),
-                                    },
-                                    TyKind::Dyn(_) => match &current_ty.data(Interner).kind {
-                                        TyKind::Raw(_, ty) | TyKind::Ref(_, _, ty) => {
-                                            let vtable = self.vtable_map.id(ty.clone());
-                                            let addr =
-                                                self.eval_operand(operand, locals)?.get(&self)?;
-                                            let mut r = Vec::with_capacity(16);
-                                            r.extend(addr.iter().copied());
-                                            r.extend(vtable.to_le_bytes().into_iter());
-                                            Owned(r)
-                                        }
-                                        _ => not_supported!("dyn unsizing from non pointers"),
-                                    },
-                                    _ => not_supported!("unknown unsized cast"),
-                                }
-                            }
-                            _ => not_supported!("unsized cast on unknown pointer type"),
-                        }
+                        let addr = self.eval_operand(operand, locals)?;
+                        self.coerce_unsized(addr, &current_ty, target_ty)?
+                    }
+                    PointerCast::MutToConstPointer | PointerCast::UnsafeFnPointer => {
+                        // This is no-op
+                        Borrowed(self.eval_operand(operand, locals)?)
                     }
                     x => not_supported!("pointer cast {x:?}"),
                 },
@@ -909,6 +1035,77 @@ impl Evaluator<'_> {
         })
     }
 
+    fn coerce_unsized_look_through_fields<T>(
+        &self,
+        ty: &Ty,
+        goal: impl Fn(&TyKind) -> Option<T>,
+    ) -> Result<T> {
+        let kind = ty.kind(Interner);
+        if let Some(x) = goal(kind) {
+            return Ok(x);
+        }
+        if let TyKind::Adt(id, subst) = kind {
+            if let AdtId::StructId(struct_id) = id.0 {
+                let field_types = self.db.field_types(struct_id.into());
+                let mut field_types = field_types.iter();
+                if let Some(ty) =
+                    field_types.next().map(|x| x.1.clone().substitute(Interner, subst))
+                {
+                    return self.coerce_unsized_look_through_fields(&ty, goal);
+                }
+            }
+        }
+        Err(MirEvalError::CoerceUnsizedError(ty.clone()))
+    }
+
+    fn coerce_unsized(
+        &mut self,
+        addr: Interval,
+        current_ty: &Ty,
+        target_ty: &Ty,
+    ) -> Result<IntervalOrOwned> {
+        use IntervalOrOwned::*;
+        fn for_ptr(x: &TyKind) -> Option<Ty> {
+            match x {
+                TyKind::Raw(_, ty) | TyKind::Ref(_, _, ty) => Some(ty.clone()),
+                _ => None,
+            }
+        }
+        Ok(match self.coerce_unsized_look_through_fields(target_ty, for_ptr)? {
+            ty => match &ty.data(Interner).kind {
+                TyKind::Slice(_) => {
+                    match self.coerce_unsized_look_through_fields(current_ty, for_ptr)? {
+                        ty => match &ty.data(Interner).kind {
+                            TyKind::Array(_, size) => {
+                                let len = const_as_usize(size);
+                                let mut r = Vec::with_capacity(16);
+                                let addr = addr.get(self)?;
+                                r.extend(addr.iter().copied());
+                                r.extend(len.to_le_bytes().into_iter());
+                                Owned(r)
+                            }
+                            _ => {
+                                not_supported!("slice unsizing from non arrays")
+                            }
+                        },
+                    }
+                }
+                TyKind::Dyn(_) => match &current_ty.data(Interner).kind {
+                    TyKind::Raw(_, ty) | TyKind::Ref(_, _, ty) => {
+                        let vtable = self.vtable_map.id(ty.clone());
+                        let mut r = Vec::with_capacity(16);
+                        let addr = addr.get(self)?;
+                        r.extend(addr.iter().copied());
+                        r.extend(vtable.to_le_bytes().into_iter());
+                        Owned(r)
+                    }
+                    _ => not_supported!("dyn unsizing from non pointers"),
+                },
+                _ => not_supported!("unknown unsized cast"),
+            },
+        })
+    }
+
     fn layout_of_variant(
         &mut self,
         x: VariantId,
@@ -921,7 +1118,7 @@ impl Evaluator<'_> {
                 if AdtId::from(f.parent) == adt {
                     // Computing the exact size of enums require resolving the enum discriminants. In order to prevent loops (and
                     // infinite sized type errors) we use a dummy layout
-                    let i = self.db.const_eval_discriminant(x)?;
+                    let i = self.const_eval_discriminant(x)?;
                     return Ok((16, self.layout(&TyBuilder::unit())?, Some((0, 16, i))));
                 }
             }
@@ -939,13 +1136,22 @@ impl Evaluator<'_> {
                     _ => not_supported!("multi variant layout for non-enums"),
                 };
                 let rustc_enum_variant_idx = RustcEnumVariantIdx(enum_variant_id.local_id);
-                let mut discriminant = self.db.const_eval_discriminant(enum_variant_id)?;
+                let mut discriminant = self.const_eval_discriminant(enum_variant_id)?;
                 let variant_layout = variants[rustc_enum_variant_idx].clone();
                 let have_tag = match tag_encoding {
                     TagEncoding::Direct => true,
                     TagEncoding::Niche { untagged_variant, niche_variants: _, niche_start } => {
-                        discriminant = discriminant.wrapping_add(niche_start as i128);
-                        untagged_variant != rustc_enum_variant_idx
+                        if untagged_variant == rustc_enum_variant_idx {
+                            false
+                        } else {
+                            discriminant = (variants
+                                .iter_enumerated()
+                                .filter(|(x, _)| *x != untagged_variant)
+                                .position(|(x, _)| x == rustc_enum_variant_idx)
+                                .unwrap() as i128)
+                                .wrapping_add(niche_start as i128);
+                            true
+                        }
                     }
                 };
                 (
@@ -970,7 +1176,7 @@ impl Evaluator<'_> {
         size: usize, // Not necessarily equal to variant_layout.size
         variant_layout: &Layout,
         tag: Option<(usize, usize, i128)>,
-        values: impl Iterator<Item = Interval>,
+        values: impl Iterator<Item = IntervalOrOwned>,
     ) -> Result<Vec<u8>> {
         let mut result = vec![0; size];
         if let Some((offset, size, value)) = tag {
@@ -987,6 +1193,10 @@ impl Evaluator<'_> {
     fn eval_operand(&mut self, x: &Operand, locals: &Locals<'_>) -> Result<Interval> {
         Ok(match x {
             Operand::Copy(p) | Operand::Move(p) => self.eval_place(p, locals)?,
+            Operand::Static(st) => {
+                let addr = self.eval_static(*st, locals)?;
+                Interval::new(addr, self.ptr_size())
+            }
             Operand::Constant(konst) => {
                 let data = &konst.data(Interner);
                 match &data.value {
@@ -1003,37 +1213,71 @@ impl Evaluator<'_> {
                         not_supported!("inference var constant")
                     }
                     chalk_ir::ConstValue::Placeholder(_) => not_supported!("placeholder constant"),
-                    chalk_ir::ConstValue::Concrete(c) => match &c.interned {
-                        ConstScalar::Bytes(v, memory_map) => {
-                            let mut v: Cow<'_, [u8]> = Cow::Borrowed(v);
-                            let patch_map = memory_map.transform_addresses(|b| {
-                                let addr = self.heap_allocate(b.len());
-                                self.write_memory(addr, b)?;
-                                Ok(addr.to_usize())
-                            })?;
-                            let size = self.size_of(&data.ty, locals)?.unwrap_or(v.len());
-                            if size != v.len() {
-                                // Handle self enum
-                                if size == 16 && v.len() < 16 {
-                                    v = Cow::Owned(pad16(&v, false).to_vec());
-                                } else if size < 16 && v.len() == 16 {
-                                    v = Cow::Owned(v[0..size].to_vec());
-                                } else {
-                                    return Err(MirEvalError::InvalidConst(konst.clone()));
-                                }
-                            }
-                            let addr = self.heap_allocate(size);
-                            self.write_memory(addr, &v)?;
-                            self.patch_addresses(&patch_map, addr, &data.ty, locals)?;
-                            Interval::new(addr, size)
-                        }
-                        ConstScalar::Unknown => not_supported!("evaluating unknown const"),
-                    },
+                    chalk_ir::ConstValue::Concrete(c) => {
+                        self.allocate_const_in_heap(c, &data.ty, locals, konst)?
+                    }
                 }
             }
         })
     }
 
+    fn allocate_const_in_heap(
+        &mut self,
+        c: &chalk_ir::ConcreteConst<Interner>,
+        ty: &Ty,
+        locals: &Locals<'_>,
+        konst: &chalk_ir::Const<Interner>,
+    ) -> Result<Interval> {
+        Ok(match &c.interned {
+            ConstScalar::Bytes(v, memory_map) => {
+                let mut v: Cow<'_, [u8]> = Cow::Borrowed(v);
+                let patch_map = memory_map.transform_addresses(|b| {
+                    let addr = self.heap_allocate(b.len(), 1); // FIXME: align is wrong
+                    self.write_memory(addr, b)?;
+                    Ok(addr.to_usize())
+                })?;
+                let (size, align) = self.size_align_of(ty, locals)?.unwrap_or((v.len(), 1));
+                if size != v.len() {
+                    // Handle self enum
+                    if size == 16 && v.len() < 16 {
+                        v = Cow::Owned(pad16(&v, false).to_vec());
+                    } else if size < 16 && v.len() == 16 {
+                        v = Cow::Owned(v[0..size].to_vec());
+                    } else {
+                        return Err(MirEvalError::InvalidConst(konst.clone()));
+                    }
+                }
+                let addr = self.heap_allocate(size, align);
+                self.write_memory(addr, &v)?;
+                self.patch_addresses(&patch_map, &memory_map.vtable, addr, ty, locals)?;
+                Interval::new(addr, size)
+            }
+            ConstScalar::UnevaluatedConst(const_id, subst) => {
+                let subst = self.subst_filler(subst, locals);
+                let (const_id, subst) = lookup_impl_const(
+                    self.db,
+                    self.db.trait_environment_for_body(locals.body.owner),
+                    *const_id,
+                    subst,
+                );
+                let c = self.db.const_eval(const_id.into(), subst).map_err(|e| {
+                    let const_data = self.db.const_data(const_id);
+                    MirEvalError::ConstEvalError(
+                        const_data.name.as_ref().and_then(|x| x.as_str()).unwrap_or("_").to_owned(),
+                        Box::new(e),
+                    )
+                })?;
+                if let chalk_ir::ConstValue::Concrete(c) = &c.data(Interner).value {
+                    if let ConstScalar::Bytes(_, _) = &c.interned {
+                        return self.allocate_const_in_heap(&c, ty, locals, konst);
+                    }
+                }
+                not_supported!("failing at evaluating unevaluated const");
+            }
+            ConstScalar::Unknown => not_supported!("evaluating unknown const"),
+        })
+    }
+
     fn eval_place(&mut self, p: &Place, locals: &Locals<'_>) -> Result<Interval> {
         let addr = self.place_addr(p, locals)?;
         Ok(Interval::new(
@@ -1046,53 +1290,61 @@ impl Evaluator<'_> {
         let (mem, pos) = match addr {
             Stack(x) => (&self.stack, x),
             Heap(x) => (&self.heap, x),
-            Invalid(_) => {
-                return Err(MirEvalError::UndefinedBehavior("read invalid memory address"))
+            Invalid(x) => {
+                return Err(MirEvalError::UndefinedBehavior(format!(
+                    "read invalid memory address {x} with size {size}"
+                )));
             }
         };
-        mem.get(pos..pos + size).ok_or(MirEvalError::UndefinedBehavior("out of bound memory read"))
+        mem.get(pos..pos + size)
+            .ok_or_else(|| MirEvalError::UndefinedBehavior("out of bound memory read".to_string()))
     }
 
     fn write_memory(&mut self, addr: Address, r: &[u8]) -> Result<()> {
         let (mem, pos) = match addr {
             Stack(x) => (&mut self.stack, x),
             Heap(x) => (&mut self.heap, x),
-            Invalid(_) => {
-                return Err(MirEvalError::UndefinedBehavior("write invalid memory address"))
+            Invalid(x) => {
+                return Err(MirEvalError::UndefinedBehavior(format!(
+                    "write invalid memory address {x} with content {r:?}"
+                )));
             }
         };
         mem.get_mut(pos..pos + r.len())
-            .ok_or(MirEvalError::UndefinedBehavior("out of bound memory write"))?
+            .ok_or_else(|| {
+                MirEvalError::UndefinedBehavior("out of bound memory write".to_string())
+            })?
             .copy_from_slice(r);
         Ok(())
     }
 
-    fn size_of(&self, ty: &Ty, locals: &Locals<'_>) -> Result<Option<usize>> {
+    fn size_align_of(&self, ty: &Ty, locals: &Locals<'_>) -> Result<Option<(usize, usize)>> {
         if let DefWithBodyId::VariantId(f) = locals.body.owner {
             if let Some((adt, _)) = ty.as_adt() {
                 if AdtId::from(f.parent) == adt {
                     // Computing the exact size of enums require resolving the enum discriminants. In order to prevent loops (and
                     // infinite sized type errors) we use a dummy size
-                    return Ok(Some(16));
+                    return Ok(Some((16, 16)));
                 }
             }
         }
-        let ty = &self.ty_filler(ty, locals.subst, locals.body.owner)?;
-        let layout = self.layout(ty);
+        let layout = self.layout_filled(ty, locals);
         if self.assert_placeholder_ty_is_unused {
             if matches!(layout, Err(MirEvalError::LayoutError(LayoutError::HasPlaceholder, _))) {
-                return Ok(Some(0));
+                return Ok(Some((0, 1)));
             }
         }
         let layout = layout?;
-        Ok(layout.is_sized().then(|| layout.size.bytes_usize()))
+        Ok(layout
+            .is_sized()
+            .then(|| (layout.size.bytes_usize(), layout.align.abi.bytes() as usize)))
     }
 
     /// A version of `self.size_of` which returns error if the type is unsized. `what` argument should
     /// be something that complete this: `error: type {ty} was unsized. {what} should be sized`
     fn size_of_sized(&self, ty: &Ty, locals: &Locals<'_>, what: &'static str) -> Result<usize> {
-        match self.size_of(ty, locals)? {
-            Some(x) => Ok(x),
+        match self.size_align_of(ty, locals)? {
+            Some(x) => Ok(x.0),
             None => Err(MirEvalError::TypeIsUnsized(ty.clone(), what)),
         }
     }
@@ -1120,7 +1372,7 @@ impl Evaluator<'_> {
         struct Filler<'a> {
             db: &'a dyn HirDatabase,
             subst: &'a Substitution,
-            skip_params: usize,
+            generics: Option<Generics>,
         }
         impl FallibleTypeFolder<Interner> for Filler<'_> {
             type Error = MirEvalError;
@@ -1144,7 +1396,11 @@ impl Evaluator<'_> {
                         match impl_trait_id {
                             crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                                 let infer = self.db.infer(func.into());
-                                let filler = &mut Filler { db: self.db, subst, skip_params: 0 };
+                                let filler = &mut Filler {
+                                    db: self.db,
+                                    subst,
+                                    generics: Some(generics(self.db.upcast(), func.into())),
+                                };
                                 filler.try_fold_ty(infer.type_of_rpit[idx].clone(), outer_binder)
                             }
                             crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {
@@ -1162,22 +1418,36 @@ impl Evaluator<'_> {
                 _outer_binder: DebruijnIndex,
             ) -> std::result::Result<Ty, Self::Error> {
                 let x = from_placeholder_idx(self.db, idx);
+                let Some(idx) = self.generics.as_ref().and_then(|g| g.param_idx(x)) else {
+                    not_supported!("missing idx in generics");
+                };
                 Ok(self
                     .subst
                     .as_slice(Interner)
-                    .get((u32::from(x.local_id.into_raw()) as usize) + self.skip_params)
+                    .get(idx)
                     .and_then(|x| x.ty(Interner))
-                    .ok_or(MirEvalError::TypeError("Generic arg not provided"))?
+                    .ok_or_else(|| MirEvalError::GenericArgNotProvided(x, self.subst.clone()))?
                     .clone())
             }
         }
-        let filler = &mut Filler { db: self.db, subst, skip_params: 0 };
-        Ok(normalize(self.db, owner, ty.clone().try_fold_with(filler, DebruijnIndex::INNERMOST)?))
+        let g_def = match owner {
+            DefWithBodyId::FunctionId(f) => Some(f.into()),
+            DefWithBodyId::StaticId(_) => None,
+            DefWithBodyId::ConstId(f) => Some(f.into()),
+            DefWithBodyId::VariantId(f) => Some(f.into()),
+        };
+        let generics = g_def.map(|g_def| generics(self.db.upcast(), g_def));
+        let filler = &mut Filler { db: self.db, subst, generics };
+        Ok(normalize(
+            self.db,
+            self.trait_env.clone(),
+            ty.clone().try_fold_with(filler, DebruijnIndex::INNERMOST)?,
+        ))
     }
 
-    fn heap_allocate(&mut self, s: usize) -> Address {
+    fn heap_allocate(&mut self, size: usize, _align: usize) -> Address {
         let pos = self.heap.len();
-        self.heap.extend(iter::repeat(0).take(s));
+        self.heap.extend(iter::repeat(0).take(size));
         Address::Heap(pos)
     }
 
@@ -1185,16 +1455,6 @@ impl Evaluator<'_> {
         self.interpret_mir(&body, vec![].into_iter(), Substitution::empty(Interner))
     }
 
-    fn detect_lang_function(&self, def: FunctionId) -> Option<LangItem> {
-        use LangItem::*;
-        let candidate = lang_attr(self.db.upcast(), def)?;
-        // We want to execute these functions with special logic
-        if [PanicFmt, BeginPanic, SliceLen].contains(&candidate) {
-            return Some(candidate);
-        }
-        None
-    }
-
     fn detect_fn_trait(&self, def: FunctionId) -> Option<FnTrait> {
         use LangItem::*;
         let ItemContainerId::TraitId(parent) = self.db.lookup_intern_function(def).container else {
@@ -1214,9 +1474,9 @@ impl Evaluator<'_> {
         let mut mm = MemoryMap::default();
         match ty.kind(Interner) {
             TyKind::Ref(_, _, t) => {
-                let size = self.size_of(t, locals)?;
+                let size = self.size_align_of(t, locals)?;
                 match size {
-                    Some(size) => {
+                    Some((size, _)) => {
                         let addr_usize = from_bytes!(usize, bytes);
                         mm.insert(
                             addr_usize,
@@ -1246,15 +1506,17 @@ impl Evaluator<'_> {
     fn patch_addresses(
         &mut self,
         patch_map: &HashMap<usize, usize>,
+        old_vtable: &VTableMap,
         addr: Address,
         ty: &Ty,
         locals: &Locals<'_>,
     ) -> Result<()> {
         // FIXME: support indirect references
+        let layout = self.layout(ty)?;
         let my_size = self.size_of_sized(ty, locals, "value to patch address")?;
         match ty.kind(Interner) {
             TyKind::Ref(_, _, t) => {
-                let size = self.size_of(t, locals)?;
+                let size = self.size_align_of(t, locals)?;
                 match size {
                     Some(_) => {
                         let current = from_bytes!(usize, self.read_memory(addr, my_size)?);
@@ -1270,98 +1532,50 @@ impl Evaluator<'_> {
                     }
                 }
             }
-            _ => (),
-        }
-        Ok(())
-    }
-
-    fn exec_intrinsic(
-        &mut self,
-        as_str: &str,
-        args: &[IntervalAndTy],
-        generic_args: Substitution,
-        destination: Interval,
-        locals: &Locals<'_>,
-    ) -> Result<()> {
-        match as_str {
-            "size_of" => {
-                let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {
-                    return Err(MirEvalError::TypeError("size_of generic arg is not provided"));
-                };
-                let size = self.size_of_sized(ty, locals, "size_of arg")?;
-                destination.write_from_bytes(self, &size.to_le_bytes()[0..destination.size])
-            }
-            "wrapping_add" => {
-                let [lhs, rhs] = args else {
-                    return Err(MirEvalError::TypeError("const_eval_select args are not provided"));
-                };
-                let lhs = u128::from_le_bytes(pad16(lhs.get(self)?, false));
-                let rhs = u128::from_le_bytes(pad16(rhs.get(self)?, false));
-                let ans = lhs.wrapping_add(rhs);
-                destination.write_from_bytes(self, &ans.to_le_bytes()[0..destination.size])
-            }
-            "copy" | "copy_nonoverlapping" => {
-                let [src, dst, offset] = args else {
-                    return Err(MirEvalError::TypeError("copy_nonoverlapping args are not provided"));
-                };
-                let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {
-                    return Err(MirEvalError::TypeError("copy_nonoverlapping generic arg is not provided"));
-                };
-                let src = Address::from_bytes(src.get(self)?)?;
-                let dst = Address::from_bytes(dst.get(self)?)?;
-                let offset = from_bytes!(usize, offset.get(self)?);
-                let size = self.size_of_sized(ty, locals, "copy_nonoverlapping ptr type")?;
-                let size = offset * size;
-                let src = Interval { addr: src, size };
-                let dst = Interval { addr: dst, size };
-                dst.write_from_interval(self, src)
-            }
-            "offset" | "arith_offset" => {
-                let [ptr, offset] = args else {
-                    return Err(MirEvalError::TypeError("offset args are not provided"));
-                };
-                let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {
-                    return Err(MirEvalError::TypeError("offset generic arg is not provided"));
-                };
-                let ptr = u128::from_le_bytes(pad16(ptr.get(self)?, false));
-                let offset = u128::from_le_bytes(pad16(offset.get(self)?, false));
-                let size = self.size_of_sized(ty, locals, "offset ptr type")? as u128;
-                let ans = ptr + offset * size;
-                destination.write_from_bytes(self, &ans.to_le_bytes()[0..destination.size])
-            }
-            "assert_inhabited" | "assert_zero_valid" | "assert_uninit_valid" => {
-                // FIXME: We should actually implement these checks
-                Ok(())
-            }
-            "forget" => {
-                // We don't call any drop glue yet, so there is nothing here
-                Ok(())
-            }
-            "transmute" => {
-                let [arg] = args else {
-                    return Err(MirEvalError::TypeError("trasmute arg is not provided"));
-                };
-                destination.write_from_interval(self, arg.interval)
+            TyKind::Function(_) => {
+                let ty = old_vtable.ty_of_bytes(self.read_memory(addr, my_size)?)?.clone();
+                let new_id = self.vtable_map.id(ty);
+                self.write_memory(addr, &new_id.to_le_bytes())?;
             }
-            "const_eval_select" => {
-                let [tuple, const_fn, _] = args else {
-                    return Err(MirEvalError::TypeError("const_eval_select args are not provided"));
-                };
-                let mut args = vec![const_fn.clone()];
-                let TyKind::Tuple(_, fields) = tuple.ty.kind(Interner) else {
-                    return Err(MirEvalError::TypeError("const_eval_select arg[0] is not a tuple"));
-                };
-                let layout = self.layout(&tuple.ty)?;
-                for (i, field) in fields.iter(Interner).enumerate() {
-                    let field = field.assert_ty_ref(Interner).clone();
-                    let offset = layout.fields.offset(i).bytes_usize();
-                    let addr = tuple.interval.addr.offset(offset);
-                    args.push(IntervalAndTy::new(addr, field, self, locals)?);
+            TyKind::Adt(id, subst) => match id.0 {
+                AdtId::StructId(s) => {
+                    for (i, (_, ty)) in self.db.field_types(s.into()).iter().enumerate() {
+                        let offset = layout.fields.offset(i).bytes_usize();
+                        let ty = ty.clone().substitute(Interner, subst);
+                        self.patch_addresses(
+                            patch_map,
+                            old_vtable,
+                            addr.offset(offset),
+                            &ty,
+                            locals,
+                        )?;
+                    }
                 }
-                self.exec_fn_trait(&args, destination, locals)
-            }
-            _ => not_supported!("unknown intrinsic {as_str}"),
+                AdtId::UnionId(_) => (),
+                AdtId::EnumId(_) => (),
+            },
+            TyKind::AssociatedType(_, _)
+            | TyKind::Scalar(_)
+            | TyKind::Tuple(_, _)
+            | TyKind::Array(_, _)
+            | TyKind::Slice(_)
+            | TyKind::Raw(_, _)
+            | TyKind::OpaqueType(_, _)
+            | TyKind::FnDef(_, _)
+            | TyKind::Str
+            | TyKind::Never
+            | TyKind::Closure(_, _)
+            | TyKind::Generator(_, _)
+            | TyKind::GeneratorWitness(_, _)
+            | TyKind::Foreign(_)
+            | TyKind::Error
+            | TyKind::Placeholder(_)
+            | TyKind::Dyn(_)
+            | TyKind::Alias(_)
+            | TyKind::BoundVar(_)
+            | TyKind::InferenceVar(_, _) => (),
         }
+        Ok(())
     }
 
     fn exec_fn_pointer(
@@ -1370,13 +1584,18 @@ impl Evaluator<'_> {
         destination: Interval,
         args: &[IntervalAndTy],
         locals: &Locals<'_>,
+        span: MirSpan,
     ) -> Result<()> {
         let id = from_bytes!(usize, bytes.get(self)?);
         let next_ty = self.vtable_map.ty(id)?.clone();
-        if let TyKind::FnDef(def, generic_args) = &next_ty.data(Interner).kind {
-            self.exec_fn_def(*def, generic_args, destination, args, &locals)?;
-        } else {
-            return Err(MirEvalError::TypeError("function pointer to non function"));
+        match &next_ty.data(Interner).kind {
+            TyKind::FnDef(def, generic_args) => {
+                self.exec_fn_def(*def, generic_args, destination, args, &locals, span)?;
+            }
+            TyKind::Closure(id, subst) => {
+                self.exec_closure(*id, bytes.slice(0..0), subst, destination, args, locals, span)?;
+            }
+            _ => return Err(MirEvalError::TypeError("function pointer to non function")),
         }
         Ok(())
     }
@@ -1388,6 +1607,8 @@ impl Evaluator<'_> {
         generic_args: &Substitution,
         destination: Interval,
         args: &[IntervalAndTy],
+        locals: &Locals<'_>,
+        span: MirSpan,
     ) -> Result<()> {
         let mir_body = self
             .db
@@ -1396,7 +1617,16 @@ impl Evaluator<'_> {
         let arg_bytes = iter::once(Ok(closure_data.get(self)?.to_owned()))
             .chain(args.iter().map(|x| Ok(x.get(&self)?.to_owned())))
             .collect::<Result<Vec<_>>>()?;
-        let bytes = self.interpret_mir(&mir_body, arg_bytes.into_iter(), generic_args.clone())?;
+        let bytes = self
+            .interpret_mir(&mir_body, arg_bytes.into_iter(), generic_args.clone())
+            .map_err(|e| {
+                MirEvalError::InFunction(
+                    Either::Right(closure),
+                    Box::new(e),
+                    span,
+                    locals.body.owner,
+                )
+            })?;
         destination.write_from_bytes(self, &bytes)
     }
 
@@ -1407,16 +1637,17 @@ impl Evaluator<'_> {
         destination: Interval,
         args: &[IntervalAndTy],
         locals: &Locals<'_>,
+        span: MirSpan,
     ) -> Result<()> {
         let def: CallableDefId = from_chalk(self.db, def);
         let generic_args = self.subst_filler(generic_args, &locals);
         match def {
             CallableDefId::FunctionId(def) => {
                 if let Some(_) = self.detect_fn_trait(def) {
-                    self.exec_fn_trait(&args, destination, locals)?;
+                    self.exec_fn_trait(&args, destination, locals, span)?;
                     return Ok(());
                 }
-                self.exec_fn_with_args(def, args, generic_args, locals, destination)?;
+                self.exec_fn_with_args(def, args, generic_args, locals, destination, span)?;
             }
             CallableDefId::StructId(id) => {
                 let (size, variant_layout, tag) =
@@ -1425,7 +1656,7 @@ impl Evaluator<'_> {
                     size,
                     &variant_layout,
                     tag,
-                    args.iter().map(|x| x.interval),
+                    args.iter().map(|x| x.interval.into()),
                 )?;
                 destination.write_from_bytes(self, &result)?;
             }
@@ -1436,7 +1667,7 @@ impl Evaluator<'_> {
                     size,
                     &variant_layout,
                     tag,
-                    args.iter().map(|x| x.interval),
+                    args.iter().map(|x| x.interval.into()),
                 )?;
                 destination.write_from_bytes(self, &result)?;
             }
@@ -1451,50 +1682,37 @@ impl Evaluator<'_> {
         generic_args: Substitution,
         locals: &Locals<'_>,
         destination: Interval,
+        span: MirSpan,
     ) -> Result<()> {
-        let function_data = self.db.function_data(def);
-        let is_intrinsic = match &function_data.abi {
-            Some(abi) => *abi == Interned::new_str("rust-intrinsic"),
-            None => match def.lookup(self.db.upcast()).container {
-                hir_def::ItemContainerId::ExternBlockId(block) => {
-                    let id = block.lookup(self.db.upcast()).id;
-                    id.item_tree(self.db.upcast())[id.value].abi.as_deref()
-                        == Some("rust-intrinsic")
-                }
-                _ => false,
-            },
-        };
-        if is_intrinsic {
-            return self.exec_intrinsic(
-                function_data.name.as_text().unwrap_or_default().as_str(),
-                args,
-                generic_args,
-                destination,
-                &locals,
-            );
+        if self.detect_and_exec_special_function(
+            def,
+            args,
+            &generic_args,
+            locals,
+            destination,
+            span,
+        )? {
+            return Ok(());
         }
         let arg_bytes =
             args.iter().map(|x| Ok(x.get(&self)?.to_owned())).collect::<Result<Vec<_>>>()?;
-        let result = if let Some(x) = self.detect_lang_function(def) {
-            self.exec_lang_item(x, &arg_bytes)?
-        } else {
-            if let Some(self_ty_idx) =
-                is_dyn_method(self.db, self.trait_env.clone(), def, generic_args.clone())
-            {
-                // In the layout of current possible receiver, which at the moment of writing this code is one of
-                // `&T`, `&mut T`, `Box<T>`, `Rc<T>`, `Arc<T>`, and `Pin<P>` where `P` is one of possible receivers,
-                // the vtable is exactly in the `[ptr_size..2*ptr_size]` bytes. So we can use it without branching on
-                // the type.
-                let ty = self
-                    .vtable_map
-                    .ty_of_bytes(&arg_bytes[0][self.ptr_size()..self.ptr_size() * 2])?;
-                let mut args_for_target = args.to_vec();
-                args_for_target[0] = IntervalAndTy {
-                    interval: args_for_target[0].interval.slice(0..self.ptr_size()),
-                    ty: ty.clone(),
-                };
-                let ty = GenericArgData::Ty(ty.clone()).intern(Interner);
-                let generics_for_target = Substitution::from_iter(
+        if let Some(self_ty_idx) =
+            is_dyn_method(self.db, self.trait_env.clone(), def, generic_args.clone())
+        {
+            // In the layout of current possible receiver, which at the moment of writing this code is one of
+            // `&T`, `&mut T`, `Box<T>`, `Rc<T>`, `Arc<T>`, and `Pin<P>` where `P` is one of possible recievers,
+            // the vtable is exactly in the `[ptr_size..2*ptr_size]` bytes. So we can use it without branching on
+            // the type.
+            let ty =
+                self.vtable_map.ty_of_bytes(&arg_bytes[0][self.ptr_size()..self.ptr_size() * 2])?;
+            let mut args_for_target = args.to_vec();
+            args_for_target[0] = IntervalAndTy {
+                interval: args_for_target[0].interval.slice(0..self.ptr_size()),
+                ty: ty.clone(),
+            };
+            let ty = GenericArgData::Ty(ty.clone()).intern(Interner);
+            let generics_for_target =
+                Substitution::from_iter(
                     Interner,
                     generic_args.iter(Interner).enumerate().map(|(i, x)| {
                         if i == self_ty_idx {
@@ -1504,23 +1722,25 @@ impl Evaluator<'_> {
                         }
                     }),
                 );
-                return self.exec_fn_with_args(
-                    def,
-                    &args_for_target,
-                    generics_for_target,
-                    locals,
-                    destination,
-                );
-            }
-            let (imp, generic_args) =
-                lookup_impl_method(self.db, self.trait_env.clone(), def, generic_args);
-            let generic_args = self.subst_filler(&generic_args, &locals);
-            let def = imp.into();
-            let mir_body =
-                self.db.mir_body(def).map_err(|e| MirEvalError::MirLowerError(imp, e))?;
-            self.interpret_mir(&mir_body, arg_bytes.iter().cloned(), generic_args)
-                .map_err(|e| MirEvalError::InFunction(imp, Box::new(e)))?
-        };
+            return self.exec_fn_with_args(
+                def,
+                &args_for_target,
+                generics_for_target,
+                locals,
+                destination,
+                span,
+            );
+        }
+        let (imp, generic_args) =
+            lookup_impl_method(self.db, self.trait_env.clone(), def, generic_args);
+        let generic_args = self.subst_filler(&generic_args, &locals);
+        let def = imp.into();
+        let mir_body = self.db.mir_body(def).map_err(|e| MirEvalError::MirLowerError(imp, e))?;
+        let result = self
+            .interpret_mir(&mir_body, arg_bytes.iter().cloned(), generic_args)
+            .map_err(|e| {
+                MirEvalError::InFunction(Either::Left(imp), Box::new(e), span, locals.body.owner)
+            })?;
         destination.write_from_bytes(self, &result)?;
         Ok(())
     }
@@ -1530,6 +1750,7 @@ impl Evaluator<'_> {
         args: &[IntervalAndTy],
         destination: Interval,
         locals: &Locals<'_>,
+        span: MirSpan,
     ) -> Result<()> {
         let func = args.get(0).ok_or(MirEvalError::TypeError("fn trait with no arg"))?;
         let mut func_ty = func.ty.clone();
@@ -1547,35 +1768,69 @@ impl Evaluator<'_> {
         }
         match &func_ty.data(Interner).kind {
             TyKind::FnDef(def, subst) => {
-                self.exec_fn_def(*def, subst, destination, &args[1..], locals)?;
+                self.exec_fn_def(*def, subst, destination, &args[1..], locals, span)?;
             }
             TyKind::Function(_) => {
-                self.exec_fn_pointer(func_data, destination, &args[1..], locals)?;
+                self.exec_fn_pointer(func_data, destination, &args[1..], locals, span)?;
             }
             TyKind::Closure(closure, subst) => {
-                self.exec_closure(*closure, func_data, subst, destination, &args[1..])?;
+                self.exec_closure(
+                    *closure,
+                    func_data,
+                    &Substitution::from_iter(Interner, ClosureSubst(subst).parent_subst()),
+                    destination,
+                    &args[1..],
+                    locals,
+                    span,
+                )?;
             }
             x => not_supported!("Call FnTrait methods with type {x:?}"),
         }
         Ok(())
     }
 
-    fn exec_lang_item(&self, x: LangItem, args: &[Vec<u8>]) -> Result<Vec<u8>> {
-        use LangItem::*;
-        let mut args = args.iter();
-        match x {
-            // FIXME: we want to find the panic message from arguments, but it wouldn't work
-            // currently even if we do that, since macro expansion of panic related macros
-            // is dummy.
-            PanicFmt | BeginPanic => Err(MirEvalError::Panic("<format-args>".to_string())),
-            SliceLen => {
-                let arg = args
-                    .next()
-                    .ok_or(MirEvalError::TypeError("argument of <[T]>::len() is not provided"))?;
-                let ptr_size = arg.len() / 2;
-                Ok(arg[ptr_size..].into())
+    fn eval_static(&mut self, st: StaticId, locals: &Locals<'_>) -> Result<Address> {
+        if let Some(o) = self.static_locations.get(&st) {
+            return Ok(*o);
+        };
+        let static_data = self.db.static_data(st);
+        let result = if !static_data.is_extern {
+            let konst =
+                self.db.const_eval(st.into(), Substitution::empty(Interner)).map_err(|e| {
+                    MirEvalError::ConstEvalError(
+                        static_data.name.as_str().unwrap_or("_").to_owned(),
+                        Box::new(e),
+                    )
+                })?;
+            let data = &konst.data(Interner);
+            if let chalk_ir::ConstValue::Concrete(c) = &data.value {
+                self.allocate_const_in_heap(&c, &data.ty, locals, &konst)?
+            } else {
+                not_supported!("unevaluatable static");
+            }
+        } else {
+            let ty = &self.db.infer(st.into())[self.db.body(st.into()).body_expr];
+            let Some((size, align)) = self.size_align_of(&ty, locals)? else {
+                not_supported!("unsized extern static");
+            };
+            let addr = self.heap_allocate(size, align);
+            Interval::new(addr, size)
+        };
+        let addr = self.heap_allocate(self.ptr_size(), self.ptr_size());
+        self.write_memory(addr, &result.addr.to_bytes())?;
+        self.static_locations.insert(st, addr);
+        Ok(addr)
+    }
+
+    fn const_eval_discriminant(&self, variant: EnumVariantId) -> Result<i128> {
+        let r = self.db.const_eval_discriminant(variant);
+        match r {
+            Ok(r) => Ok(r),
+            Err(e) => {
+                let data = self.db.enum_data(variant.parent);
+                let name = format!("{}::{}", data.name, data.variants[variant.local_id].name);
+                Err(MirEvalError::ConstEvalError(name, Box::new(e)))
             }
-            x => not_supported!("Executing lang item {x:?}"),
         }
     }
 }
diff --git a/crates/hir-ty/src/mir/eval/shim.rs b/crates/hir-ty/src/mir/eval/shim.rs
new file mode 100644
index 00000000000..78938af15b8
--- /dev/null
+++ b/crates/hir-ty/src/mir/eval/shim.rs
@@ -0,0 +1,396 @@
+//! Interpret intrinsics, lang items and `extern "C"` wellknown functions which their implementation
+//! is not available.
+
+use super::*;
+
+macro_rules! from_bytes {
+    ($ty:tt, $value:expr) => {
+        ($ty::from_le_bytes(match ($value).try_into() {
+            Ok(x) => x,
+            Err(_) => return Err(MirEvalError::TypeError("mismatched size")),
+        }))
+    };
+}
+
+macro_rules! not_supported {
+    ($x: expr) => {
+        return Err(MirEvalError::NotSupported(format!($x)))
+    };
+}
+
+impl Evaluator<'_> {
+    pub(super) fn detect_and_exec_special_function(
+        &mut self,
+        def: FunctionId,
+        args: &[IntervalAndTy],
+        generic_args: &Substitution,
+        locals: &Locals<'_>,
+        destination: Interval,
+        span: MirSpan,
+    ) -> Result<bool> {
+        let function_data = self.db.function_data(def);
+        let is_intrinsic = match &function_data.abi {
+            Some(abi) => *abi == Interned::new_str("rust-intrinsic"),
+            None => match def.lookup(self.db.upcast()).container {
+                hir_def::ItemContainerId::ExternBlockId(block) => {
+                    let id = block.lookup(self.db.upcast()).id;
+                    id.item_tree(self.db.upcast())[id.value].abi.as_deref()
+                        == Some("rust-intrinsic")
+                }
+                _ => false,
+            },
+        };
+        if is_intrinsic {
+            self.exec_intrinsic(
+                function_data.name.as_text().unwrap_or_default().as_str(),
+                args,
+                generic_args,
+                destination,
+                &locals,
+                span,
+            )?;
+            return Ok(true);
+        }
+        let alloc_fn = function_data
+            .attrs
+            .iter()
+            .filter_map(|x| x.path().as_ident())
+            .filter_map(|x| x.as_str())
+            .find(|x| {
+                [
+                    "rustc_allocator",
+                    "rustc_deallocator",
+                    "rustc_reallocator",
+                    "rustc_allocator_zeroed",
+                ]
+                .contains(x)
+            });
+        if let Some(alloc_fn) = alloc_fn {
+            self.exec_alloc_fn(alloc_fn, args, destination)?;
+            return Ok(true);
+        }
+        if let Some(x) = self.detect_lang_function(def) {
+            let arg_bytes =
+                args.iter().map(|x| Ok(x.get(&self)?.to_owned())).collect::<Result<Vec<_>>>()?;
+            let result = self.exec_lang_item(x, &arg_bytes)?;
+            destination.write_from_bytes(self, &result)?;
+            return Ok(true);
+        }
+        Ok(false)
+    }
+
+    fn exec_alloc_fn(
+        &mut self,
+        alloc_fn: &str,
+        args: &[IntervalAndTy],
+        destination: Interval,
+    ) -> Result<()> {
+        match alloc_fn {
+            "rustc_allocator_zeroed" | "rustc_allocator" => {
+                let [size, align] = args else {
+                    return Err(MirEvalError::TypeError("rustc_allocator args are not provided"));
+                };
+                let size = from_bytes!(usize, size.get(self)?);
+                let align = from_bytes!(usize, align.get(self)?);
+                let result = self.heap_allocate(size, align);
+                destination.write_from_bytes(self, &result.to_bytes())?;
+            }
+            "rustc_deallocator" => { /* no-op for now */ }
+            "rustc_reallocator" => {
+                let [ptr, old_size, align, new_size] = args else {
+                    return Err(MirEvalError::TypeError("rustc_allocator args are not provided"));
+                };
+                let ptr = Address::from_bytes(ptr.get(self)?)?;
+                let old_size = from_bytes!(usize, old_size.get(self)?);
+                let new_size = from_bytes!(usize, new_size.get(self)?);
+                let align = from_bytes!(usize, align.get(self)?);
+                let result = self.heap_allocate(new_size, align);
+                Interval { addr: result, size: old_size }
+                    .write_from_interval(self, Interval { addr: ptr, size: old_size })?;
+                destination.write_from_bytes(self, &result.to_bytes())?;
+            }
+            _ => not_supported!("unknown alloc function"),
+        }
+        Ok(())
+    }
+
+    fn detect_lang_function(&self, def: FunctionId) -> Option<LangItem> {
+        use LangItem::*;
+        let candidate = lang_attr(self.db.upcast(), def)?;
+        // We want to execute these functions with special logic
+        if [PanicFmt, BeginPanic, SliceLen].contains(&candidate) {
+            return Some(candidate);
+        }
+        None
+    }
+
+    fn exec_lang_item(&self, x: LangItem, args: &[Vec<u8>]) -> Result<Vec<u8>> {
+        use LangItem::*;
+        let mut args = args.iter();
+        match x {
+            // FIXME: we want to find the panic message from arguments, but it wouldn't work
+            // currently even if we do that, since macro expansion of panic related macros
+            // is dummy.
+            PanicFmt | BeginPanic => Err(MirEvalError::Panic("<format-args>".to_string())),
+            SliceLen => {
+                let arg = args
+                    .next()
+                    .ok_or(MirEvalError::TypeError("argument of <[T]>::len() is not provided"))?;
+                let ptr_size = arg.len() / 2;
+                Ok(arg[ptr_size..].into())
+            }
+            x => not_supported!("Executing lang item {x:?}"),
+        }
+    }
+
+    fn exec_intrinsic(
+        &mut self,
+        as_str: &str,
+        args: &[IntervalAndTy],
+        generic_args: &Substitution,
+        destination: Interval,
+        locals: &Locals<'_>,
+        span: MirSpan,
+    ) -> Result<()> {
+        // We are a single threaded runtime with no UB checking and no optimization, so
+        // we can implement these as normal functions.
+        if let Some(name) = as_str.strip_prefix("atomic_") {
+            let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {
+                return Err(MirEvalError::TypeError("atomic intrinsic generic arg is not provided"));
+            };
+            let Some(arg0) = args.get(0) else {
+                return Err(MirEvalError::TypeError("atomic intrinsic arg0 is not provided"));
+            };
+            let arg0_addr = Address::from_bytes(arg0.get(self)?)?;
+            let arg0_interval = Interval::new(
+                arg0_addr,
+                self.size_of_sized(ty, locals, "atomic intrinsic type arg")?,
+            );
+            if name.starts_with("load_") {
+                return destination.write_from_interval(self, arg0_interval);
+            }
+            let Some(arg1) = args.get(1) else {
+                return Err(MirEvalError::TypeError("atomic intrinsic arg1 is not provided"));
+            };
+            if name.starts_with("store_") {
+                return arg0_interval.write_from_interval(self, arg1.interval);
+            }
+            if name.starts_with("xchg_") {
+                destination.write_from_interval(self, arg0_interval)?;
+                return arg0_interval.write_from_interval(self, arg1.interval);
+            }
+            if name.starts_with("xadd_") {
+                destination.write_from_interval(self, arg0_interval)?;
+                let lhs = u128::from_le_bytes(pad16(arg0_interval.get(self)?, false));
+                let rhs = u128::from_le_bytes(pad16(arg1.get(self)?, false));
+                let ans = lhs.wrapping_add(rhs);
+                return arg0_interval
+                    .write_from_bytes(self, &ans.to_le_bytes()[0..destination.size]);
+            }
+            if name.starts_with("xsub_") {
+                destination.write_from_interval(self, arg0_interval)?;
+                let lhs = u128::from_le_bytes(pad16(arg0_interval.get(self)?, false));
+                let rhs = u128::from_le_bytes(pad16(arg1.get(self)?, false));
+                let ans = lhs.wrapping_sub(rhs);
+                return arg0_interval
+                    .write_from_bytes(self, &ans.to_le_bytes()[0..destination.size]);
+            }
+            if name.starts_with("and_") {
+                destination.write_from_interval(self, arg0_interval)?;
+                let lhs = u128::from_le_bytes(pad16(arg0_interval.get(self)?, false));
+                let rhs = u128::from_le_bytes(pad16(arg1.get(self)?, false));
+                let ans = lhs & rhs;
+                return arg0_interval
+                    .write_from_bytes(self, &ans.to_le_bytes()[0..destination.size]);
+            }
+            if name.starts_with("or_") {
+                destination.write_from_interval(self, arg0_interval)?;
+                let lhs = u128::from_le_bytes(pad16(arg0_interval.get(self)?, false));
+                let rhs = u128::from_le_bytes(pad16(arg1.get(self)?, false));
+                let ans = lhs | rhs;
+                return arg0_interval
+                    .write_from_bytes(self, &ans.to_le_bytes()[0..destination.size]);
+            }
+            if name.starts_with("xor_") {
+                destination.write_from_interval(self, arg0_interval)?;
+                let lhs = u128::from_le_bytes(pad16(arg0_interval.get(self)?, false));
+                let rhs = u128::from_le_bytes(pad16(arg1.get(self)?, false));
+                let ans = lhs ^ rhs;
+                return arg0_interval
+                    .write_from_bytes(self, &ans.to_le_bytes()[0..destination.size]);
+            }
+            if name.starts_with("nand_") {
+                destination.write_from_interval(self, arg0_interval)?;
+                let lhs = u128::from_le_bytes(pad16(arg0_interval.get(self)?, false));
+                let rhs = u128::from_le_bytes(pad16(arg1.get(self)?, false));
+                let ans = !(lhs & rhs);
+                return arg0_interval
+                    .write_from_bytes(self, &ans.to_le_bytes()[0..destination.size]);
+            }
+            let Some(arg2) = args.get(2) else {
+                return Err(MirEvalError::TypeError("atomic intrinsic arg2 is not provided"));
+            };
+            if name.starts_with("cxchg_") || name.starts_with("cxchgweak_") {
+                let dest = if arg1.get(self)? == arg0_interval.get(self)? {
+                    arg0_interval.write_from_interval(self, arg2.interval)?;
+                    (arg1.interval, true)
+                } else {
+                    (arg0_interval, false)
+                };
+                let result_ty = TyKind::Tuple(
+                    2,
+                    Substitution::from_iter(Interner, [ty.clone(), TyBuilder::bool()]),
+                )
+                .intern(Interner);
+                let layout = self.layout(&result_ty)?;
+                let result = self.make_by_layout(
+                    layout.size.bytes_usize(),
+                    &layout,
+                    None,
+                    [
+                        IntervalOrOwned::Borrowed(dest.0),
+                        IntervalOrOwned::Owned(vec![u8::from(dest.1)]),
+                    ]
+                    .into_iter(),
+                )?;
+                return destination.write_from_bytes(self, &result);
+            }
+            not_supported!("unknown atomic intrinsic {name}");
+        }
+        match as_str {
+            "size_of" => {
+                let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {
+                    return Err(MirEvalError::TypeError("size_of generic arg is not provided"));
+                };
+                let size = self.size_of_sized(ty, locals, "size_of arg")?;
+                destination.write_from_bytes(self, &size.to_le_bytes()[0..destination.size])
+            }
+            "min_align_of" | "pref_align_of" => {
+                let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {
+                    return Err(MirEvalError::TypeError("align_of generic arg is not provided"));
+                };
+                let align = self.layout_filled(ty, locals)?.align.abi.bytes();
+                destination.write_from_bytes(self, &align.to_le_bytes()[0..destination.size])
+            }
+            "needs_drop" => {
+                let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {
+                    return Err(MirEvalError::TypeError("size_of generic arg is not provided"));
+                };
+                let result = !ty.clone().is_copy(self.db, locals.body.owner);
+                destination.write_from_bytes(self, &[u8::from(result)])
+            }
+            "ptr_guaranteed_cmp" => {
+                // FIXME: this is wrong for const eval, it should return 2 in some
+                // cases.
+                let [lhs, rhs] = args else {
+                    return Err(MirEvalError::TypeError("wrapping_add args are not provided"));
+                };
+                let ans = lhs.get(self)? == rhs.get(self)?;
+                destination.write_from_bytes(self, &[u8::from(ans)])
+            }
+            "wrapping_add" => {
+                let [lhs, rhs] = args else {
+                    return Err(MirEvalError::TypeError("wrapping_add args are not provided"));
+                };
+                let lhs = u128::from_le_bytes(pad16(lhs.get(self)?, false));
+                let rhs = u128::from_le_bytes(pad16(rhs.get(self)?, false));
+                let ans = lhs.wrapping_add(rhs);
+                destination.write_from_bytes(self, &ans.to_le_bytes()[0..destination.size])
+            }
+            "add_with_overflow" => {
+                let [lhs, rhs] = args else {
+                    return Err(MirEvalError::TypeError("const_eval_select args are not provided"));
+                };
+                let result_ty = TyKind::Tuple(
+                    2,
+                    Substitution::from_iter(Interner, [lhs.ty.clone(), TyBuilder::bool()]),
+                )
+                .intern(Interner);
+                let op_size =
+                    self.size_of_sized(&lhs.ty, locals, "operand of add_with_overflow")?;
+                let lhs = u128::from_le_bytes(pad16(lhs.get(self)?, false));
+                let rhs = u128::from_le_bytes(pad16(rhs.get(self)?, false));
+                let ans = lhs.wrapping_add(rhs);
+                let is_overflow = false;
+                let is_overflow = vec![u8::from(is_overflow)];
+                let layout = self.layout(&result_ty)?;
+                let result = self.make_by_layout(
+                    layout.size.bytes_usize(),
+                    &layout,
+                    None,
+                    [ans.to_le_bytes()[0..op_size].to_vec(), is_overflow]
+                        .into_iter()
+                        .map(IntervalOrOwned::Owned),
+                )?;
+                destination.write_from_bytes(self, &result)
+            }
+            "copy" | "copy_nonoverlapping" => {
+                let [src, dst, offset] = args else {
+                    return Err(MirEvalError::TypeError("copy_nonoverlapping args are not provided"));
+                };
+                let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {
+                    return Err(MirEvalError::TypeError("copy_nonoverlapping generic arg is not provided"));
+                };
+                let src = Address::from_bytes(src.get(self)?)?;
+                let dst = Address::from_bytes(dst.get(self)?)?;
+                let offset = from_bytes!(usize, offset.get(self)?);
+                let size = self.size_of_sized(ty, locals, "copy_nonoverlapping ptr type")?;
+                let size = offset * size;
+                let src = Interval { addr: src, size };
+                let dst = Interval { addr: dst, size };
+                dst.write_from_interval(self, src)
+            }
+            "offset" | "arith_offset" => {
+                let [ptr, offset] = args else {
+                    return Err(MirEvalError::TypeError("offset args are not provided"));
+                };
+                let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {
+                    return Err(MirEvalError::TypeError("offset generic arg is not provided"));
+                };
+                let ptr = u128::from_le_bytes(pad16(ptr.get(self)?, false));
+                let offset = u128::from_le_bytes(pad16(offset.get(self)?, false));
+                let size = self.size_of_sized(ty, locals, "offset ptr type")? as u128;
+                let ans = ptr + offset * size;
+                destination.write_from_bytes(self, &ans.to_le_bytes()[0..destination.size])
+            }
+            "assert_inhabited" | "assert_zero_valid" | "assert_uninit_valid" | "assume" => {
+                // FIXME: We should actually implement these checks
+                Ok(())
+            }
+            "forget" => {
+                // We don't call any drop glue yet, so there is nothing here
+                Ok(())
+            }
+            "transmute" => {
+                let [arg] = args else {
+                    return Err(MirEvalError::TypeError("trasmute arg is not provided"));
+                };
+                destination.write_from_interval(self, arg.interval)
+            }
+            "likely" | "unlikely" => {
+                let [arg] = args else {
+                    return Err(MirEvalError::TypeError("likely arg is not provided"));
+                };
+                destination.write_from_interval(self, arg.interval)
+            }
+            "const_eval_select" => {
+                let [tuple, const_fn, _] = args else {
+                    return Err(MirEvalError::TypeError("const_eval_select args are not provided"));
+                };
+                let mut args = vec![const_fn.clone()];
+                let TyKind::Tuple(_, fields) = tuple.ty.kind(Interner) else {
+                    return Err(MirEvalError::TypeError("const_eval_select arg[0] is not a tuple"));
+                };
+                let layout = self.layout(&tuple.ty)?;
+                for (i, field) in fields.iter(Interner).enumerate() {
+                    let field = field.assert_ty_ref(Interner).clone();
+                    let offset = layout.fields.offset(i).bytes_usize();
+                    let addr = tuple.interval.addr.offset(offset);
+                    args.push(IntervalAndTy::new(addr, field, self, locals)?);
+                }
+                self.exec_fn_trait(&args, destination, locals, span)
+            }
+            _ => not_supported!("unknown intrinsic {as_str}"),
+        }
+    }
+}
diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
index 37b27b39834..733f58e8f6b 100644
--- a/crates/hir-ty/src/mir/lower.rs
+++ b/crates/hir-ty/src/mir/lower.rs
@@ -1,14 +1,15 @@
 //! This module generates a polymorphic MIR from a hir body
 
-use std::{iter, mem, sync::Arc};
+use std::{fmt::Write, iter, mem, sync::Arc};
 
+use base_db::FileId;
 use chalk_ir::{BoundVar, ConstData, DebruijnIndex, TyKind};
 use hir_def::{
     body::Body,
     data::adt::{StructKind, VariantData},
     hir::{
-        Array, BindingAnnotation, BindingId, ExprId, LabelId, Literal, MatchArm, Pat, PatId,
-        RecordFieldPat, RecordLitField,
+        ArithOp, Array, BinaryOp, BindingAnnotation, BindingId, ExprId, LabelId, Literal, MatchArm,
+        Pat, PatId, RecordFieldPat, RecordLitField,
     },
     lang_item::{LangItem, LangItemTarget},
     path::Path,
@@ -18,6 +19,7 @@ use hir_def::{
 use hir_expand::name::Name;
 use la_arena::ArenaMap;
 use rustc_hash::FxHashMap;
+use syntax::TextRange;
 
 use crate::{
     consteval::ConstEvalError,
@@ -27,8 +29,9 @@ use crate::{
     inhabitedness::is_ty_uninhabited_from,
     layout::{layout_of_ty, LayoutError},
     mapping::ToChalk,
+    method_resolution::lookup_impl_const,
     static_lifetime,
-    utils::generics,
+    utils::{generics, ClosureSubst},
     Adjust, Adjustment, AutoBorrow, CallableDefId, TyBuilder, TyExt,
 };
 
@@ -62,14 +65,14 @@ struct MirLowerCtx<'a> {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum MirLowerError {
-    ConstEvalError(Box<ConstEvalError>),
+    ConstEvalError(String, Box<ConstEvalError>),
     LayoutError(LayoutError),
     IncompleteExpr,
     /// Trying to lower a trait function, instead of an implementation
     TraitFunctionDefinition(TraitId, Name),
     UnresolvedName(String),
     RecordLiteralWithoutPath,
-    UnresolvedMethod,
+    UnresolvedMethod(String),
     UnresolvedField,
     MissingFunctionDefinition,
     TypeMismatch(TypeMismatch),
@@ -88,6 +91,46 @@ pub enum MirLowerError {
     UnaccessableLocal,
 }
 
+impl MirLowerError {
+    pub fn pretty_print(
+        &self,
+        f: &mut String,
+        db: &dyn HirDatabase,
+        span_formatter: impl Fn(FileId, TextRange) -> String,
+    ) -> std::result::Result<(), std::fmt::Error> {
+        match self {
+            MirLowerError::ConstEvalError(name, e) => {
+                writeln!(f, "In evaluating constant {name}")?;
+                match &**e {
+                    ConstEvalError::MirLowerError(e) => e.pretty_print(f, db, span_formatter)?,
+                    ConstEvalError::MirEvalError(e) => e.pretty_print(f, db, span_formatter)?,
+                }
+            }
+            MirLowerError::LayoutError(_)
+            | MirLowerError::IncompleteExpr
+            | MirLowerError::UnaccessableLocal
+            | MirLowerError::TraitFunctionDefinition(_, _)
+            | MirLowerError::UnresolvedName(_)
+            | MirLowerError::RecordLiteralWithoutPath
+            | MirLowerError::UnresolvedMethod(_)
+            | MirLowerError::UnresolvedField
+            | MirLowerError::MissingFunctionDefinition
+            | MirLowerError::TypeMismatch(_)
+            | MirLowerError::TypeError(_)
+            | MirLowerError::NotSupported(_)
+            | MirLowerError::ContinueWithoutLoop
+            | MirLowerError::BreakWithoutLoop
+            | MirLowerError::Loop
+            | MirLowerError::ImplementationError(_)
+            | MirLowerError::LangItemNotFound(_)
+            | MirLowerError::MutatingRvalue
+            | MirLowerError::UnresolvedLabel
+            | MirLowerError::UnresolvedUpvar(_) => writeln!(f, "{:?}", self)?,
+        }
+        Ok(())
+    }
+}
+
 macro_rules! not_supported {
     ($x: expr) => {
         return Err(MirLowerError::NotSupported(format!($x)))
@@ -101,15 +144,6 @@ macro_rules! implementation_error {
     }};
 }
 
-impl From<ConstEvalError> for MirLowerError {
-    fn from(value: ConstEvalError) -> Self {
-        match value {
-            ConstEvalError::MirLowerError(e) => e,
-            _ => MirLowerError::ConstEvalError(Box::new(value)),
-        }
-    }
-}
-
 impl From<LayoutError> for MirLowerError {
     fn from(value: LayoutError) -> Self {
         MirLowerError::LayoutError(value)
@@ -177,7 +211,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         if !self.has_adjustments(expr_id) {
             match &self.body.exprs[expr_id] {
                 Expr::Literal(l) => {
-                    let ty = self.expr_ty(expr_id);
+                    let ty = self.expr_ty_without_adjust(expr_id);
                     return Ok(Some((self.lower_literal_to_operand(ty, l)?, current)));
                 }
                 _ => (),
@@ -282,7 +316,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         {
                             match assoc {
                                 hir_def::AssocItemId::ConstId(c) => {
-                                    self.lower_const(c, current, place, subst, expr_id.into())?;
+                                    self.lower_const(c, current, place, subst, expr_id.into(), self.expr_ty_without_adjust(expr_id))?;
                                     return Ok(Some(current))
                                 },
                                 hir_def::AssocItemId::FunctionId(_) => {
@@ -309,17 +343,20 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     }
                 };
                 match pr {
-                    ValueNs::LocalBinding(pat_id) => {
+                    ValueNs::LocalBinding(_) | ValueNs::StaticId(_) => {
+                        let Some((temp, current)) = self.lower_expr_as_place_without_adjust(current, expr_id, false)? else {
+                            return Ok(None);
+                        };
                         self.push_assignment(
                             current,
                             place,
-                            Operand::Copy(self.binding_local(pat_id)?.into()).into(),
+                            Operand::Copy(temp).into(),
                             expr_id.into(),
                         );
                         Ok(Some(current))
                     }
                     ValueNs::ConstId(const_id) => {
-                        self.lower_const(const_id, current, place, Substitution::empty(Interner), expr_id.into())?;
+                        self.lower_const(const_id, current, place, Substitution::empty(Interner), expr_id.into(), self.expr_ty_without_adjust(expr_id))?;
                         Ok(Some(current))
                     }
                     ValueNs::EnumVariantId(variant_id) => {
@@ -343,7 +380,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                             not_supported!("owner without generic def id");
                         };
                         let gen = generics(self.db.upcast(), def);
-                        let ty = self.expr_ty(expr_id);
+                        let ty = self.expr_ty_without_adjust(expr_id);
                         self.push_assignment(
                             current,
                             place,
@@ -388,12 +425,13 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 };
                 self.set_terminator(
                     current,
-                    Terminator::SwitchInt {
+                    TerminatorKind::SwitchInt {
                         discr,
                         targets: SwitchTargets::static_if(1, start_of_then, start_of_else),
                     },
+                    expr_id.into(),
                 );
-                Ok(self.merge_blocks(end_of_then, end_of_else))
+                Ok(self.merge_blocks(end_of_then, end_of_else, expr_id.into()))
             }
             Expr::Let { pat, expr } => {
                 let Some((cond_place, current)) = self.lower_expr_as_place(current, *expr, true)? else {
@@ -423,32 +461,32 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         MirSpan::Unknown,
                     )?;
                 }
-                Ok(self.merge_blocks(Some(then_target), else_target))
+                Ok(self.merge_blocks(Some(then_target), else_target, expr_id.into()))
             }
             Expr::Unsafe { id: _, statements, tail } => {
-                self.lower_block_to_place(statements, current, *tail, place)
+                self.lower_block_to_place(statements, current, *tail, place, expr_id.into())
             }
             Expr::Block { id: _, statements, tail, label } => {
                 if let Some(label) = label {
-                    self.lower_loop(current, place.clone(), Some(*label), |this, begin| {
-                        if let Some(block) = this.lower_block_to_place(statements, begin, *tail, place)? {
+                    self.lower_loop(current, place.clone(), Some(*label), expr_id.into(), |this, begin| {
+                        if let Some(block) = this.lower_block_to_place(statements, begin, *tail, place, expr_id.into())? {
                             let end = this.current_loop_end()?;
-                            this.set_goto(block, end);
+                            this.set_goto(block, end, expr_id.into());
                         }
                         Ok(())
                     })
                 } else {
-                    self.lower_block_to_place(statements, current, *tail, place)
+                    self.lower_block_to_place(statements, current, *tail, place, expr_id.into())
                 }
             }
-            Expr::Loop { body, label } => self.lower_loop(current, place, *label, |this, begin| {
+            Expr::Loop { body, label } => self.lower_loop(current, place, *label, expr_id.into(), |this, begin| {
                 if let Some((_, block)) = this.lower_expr_as_place(begin, *body, true)? {
-                    this.set_goto(block, begin);
+                    this.set_goto(block, begin, expr_id.into());
                 }
                 Ok(())
             }),
             Expr::While { condition, body, label } => {
-                self.lower_loop(current, place, *label, |this, begin| {
+                self.lower_loop(current, place, *label, expr_id.into(),|this, begin| {
                     let Some((discr, to_switch)) = this.lower_expr_to_some_operand(*condition, begin)? else {
                         return Ok(());
                     };
@@ -456,13 +494,14 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     let after_cond = this.new_basic_block();
                     this.set_terminator(
                         to_switch,
-                        Terminator::SwitchInt {
+                        TerminatorKind::SwitchInt {
                             discr,
                             targets: SwitchTargets::static_if(1, after_cond, end),
                         },
+                        expr_id.into(),
                     );
                     if let Some((_, block)) = this.lower_expr_as_place(after_cond, *body, true)? {
-                        this.set_goto(block, begin);
+                        this.set_goto(block, begin, expr_id.into());
                     }
                     Ok(())
                 })
@@ -478,12 +517,12 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 let into_iter_fn_op = Operand::const_zst(
                     TyKind::FnDef(
                         self.db.intern_callable_def(CallableDefId::FunctionId(into_iter_fn)).into(),
-                        Substitution::from1(Interner, self.expr_ty(iterable))
+                        Substitution::from1(Interner, self.expr_ty_without_adjust(iterable))
                     ).intern(Interner));
                 let iter_next_fn_op = Operand::const_zst(
                     TyKind::FnDef(
                         self.db.intern_callable_def(CallableDefId::FunctionId(iter_next_fn)).into(),
-                        Substitution::from1(Interner, self.expr_ty(iterable))
+                        Substitution::from1(Interner, self.expr_ty_without_adjust(iterable))
                     ).intern(Interner));
                 let &Some(iterator_ty) = &self.infer.type_of_for_iterator.get(&expr_id) else {
                     return Err(MirLowerError::TypeError("unknown for loop iterator type"));
@@ -494,13 +533,13 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 let iterator_place: Place = self.temp(iterator_ty.clone())?.into();
                 let option_item_place: Place = self.temp(option_item_ty.clone())?.into();
                 let ref_mut_iterator_place: Place = self.temp(ref_mut_iterator_ty)?.into();
-                let Some(current) = self.lower_call_and_args(into_iter_fn_op, Some(iterable).into_iter(), iterator_place.clone(), current, false)?
+                let Some(current) = self.lower_call_and_args(into_iter_fn_op, Some(iterable).into_iter(), iterator_place.clone(), current, false, expr_id.into())?
                 else {
                     return Ok(None);
                 };
                 self.push_assignment(current, ref_mut_iterator_place.clone(), Rvalue::Ref(BorrowKind::Mut { allow_two_phase_borrow: false }, iterator_place), expr_id.into());
-                self.lower_loop(current, place, label, |this, begin| {
-                    let Some(current) = this.lower_call(iter_next_fn_op, vec![Operand::Copy(ref_mut_iterator_place)], option_item_place.clone(), begin, false)?
+                self.lower_loop(current, place, label, expr_id.into(), |this, begin| {
+                    let Some(current) = this.lower_call(iter_next_fn_op, vec![Operand::Copy(ref_mut_iterator_place)], option_item_place.clone(), begin, false, expr_id.into())?
                     else {
                         return Ok(());
                     };
@@ -516,7 +555,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         AdtPatternShape::Tuple { args: &[pat], ellipsis: None },
                     )?;
                     if let Some((_, block)) = this.lower_expr_as_place(current, body, true)? {
-                        this.set_goto(block, begin);
+                        this.set_goto(block, begin, expr_id.into());
                     }
                     Ok(())
                 })
@@ -536,39 +575,36 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         place,
                         current,
                         self.is_uninhabited(expr_id),
+                        expr_id.into(),
                     );
                 }
                 let callee_ty = self.expr_ty_after_adjustments(*callee);
                 match &callee_ty.data(Interner).kind {
                     chalk_ir::TyKind::FnDef(..) => {
                         let func = Operand::from_bytes(vec![], callee_ty.clone());
-                        self.lower_call_and_args(func, args.iter().copied(), place, current, self.is_uninhabited(expr_id))
+                        self.lower_call_and_args(func, args.iter().copied(), place, current, self.is_uninhabited(expr_id), expr_id.into())
                     }
                     chalk_ir::TyKind::Function(_) => {
                         let Some((func, current)) = self.lower_expr_to_some_operand(*callee, current)? else {
                             return Ok(None);
                         };
-                        self.lower_call_and_args(func, args.iter().copied(), place, current, self.is_uninhabited(expr_id))
+                        self.lower_call_and_args(func, args.iter().copied(), place, current, self.is_uninhabited(expr_id), expr_id.into())
                     }
                     TyKind::Error => return Err(MirLowerError::MissingFunctionDefinition),
                     _ => return Err(MirLowerError::TypeError("function call on bad type")),
                 }
             }
-            Expr::MethodCall { receiver, args, .. } => {
+            Expr::MethodCall { receiver, args, method_name, .. } => {
                 let (func_id, generic_args) =
-                    self.infer.method_resolution(expr_id).ok_or(MirLowerError::UnresolvedMethod)?;
-                let ty = chalk_ir::TyKind::FnDef(
-                    CallableDefId::FunctionId(func_id).to_chalk(self.db),
-                    generic_args,
-                )
-                .intern(Interner);
-                let func = Operand::from_bytes(vec![], ty);
+                    self.infer.method_resolution(expr_id).ok_or_else(|| MirLowerError::UnresolvedMethod(format!("{}", method_name)))?;
+                let func = Operand::from_fn(self.db, func_id, generic_args);
                 self.lower_call_and_args(
                     func,
                     iter::once(*receiver).chain(args.iter().copied()),
                     place,
                     current,
                     self.is_uninhabited(expr_id),
+                    expr_id.into(),
                 )
             }
             Expr::Match { expr, arms } => {
@@ -591,7 +627,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         let next = self.new_basic_block();
                         let o = otherwise.get_or_insert_with(|| self.new_basic_block());
                         if let Some((discr, c)) = self.lower_expr_to_some_operand(guard, then)? {
-                            self.set_terminator(c, Terminator::SwitchInt { discr, targets: SwitchTargets::static_if(1, next, *o) });
+                            self.set_terminator(c, TerminatorKind::SwitchInt { discr, targets: SwitchTargets::static_if(1, next, *o) }, expr_id.into());
                         }
                         next
                     } else {
@@ -599,7 +635,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     };
                     if let Some(block) = self.lower_expr_to_place(*expr, place.clone(), then)? {
                         let r = end.get_or_insert_with(|| self.new_basic_block());
-                        self.set_goto(block, *r);
+                        self.set_goto(block, *r, expr_id.into());
                     }
                     match otherwise {
                         Some(o) => current = o,
@@ -611,18 +647,17 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     }
                 }
                 if self.is_unterminated(current) {
-                    self.set_terminator(current, Terminator::Unreachable);
+                    self.set_terminator(current, TerminatorKind::Unreachable, expr_id.into());
                 }
                 Ok(end)
             }
-            Expr::Continue { label } => match label {
-                Some(_) => not_supported!("continue with label"),
-                None => {
-                    let loop_data =
-                        self.current_loop_blocks.as_ref().ok_or(MirLowerError::ContinueWithoutLoop)?;
-                    self.set_goto(current, loop_data.begin);
-                    Ok(None)
-                }
+            Expr::Continue { label } => {
+                let loop_data = match label {
+                    Some(l) => self.labeled_loop_blocks.get(l).ok_or(MirLowerError::UnresolvedLabel)?,
+                    None => self.current_loop_blocks.as_ref().ok_or(MirLowerError::ContinueWithoutLoop)?,
+                };
+                self.set_goto(current, loop_data.begin, expr_id.into());
+                Ok(None)
             },
             &Expr::Break { expr, label } => {
                 if let Some(expr) = expr {
@@ -639,7 +674,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     Some(l) => self.labeled_loop_blocks.get(&l).ok_or(MirLowerError::UnresolvedLabel)?.end.expect("We always generate end for labeled loops"),
                     None => self.current_loop_end()?,
                 };
-                self.set_goto(current, end);
+                self.set_goto(current, end, expr_id.into());
                 Ok(None)
             }
             Expr::Return { expr } => {
@@ -650,7 +685,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         return Ok(None);
                     }
                 }
-                self.set_terminator(current, Terminator::Return);
+                self.set_terminator(current, TerminatorKind::Return, expr_id.into());
                 Ok(None)
             }
             Expr::Yield { .. } => not_supported!("yield"),
@@ -672,7 +707,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         Some(p) => MirLowerError::UnresolvedName(p.display(self.db).to_string()),
                         None => MirLowerError::RecordLiteralWithoutPath,
                     })?;
-                let subst = match self.expr_ty(expr_id).kind(Interner) {
+                let subst = match self.expr_ty_without_adjust(expr_id).kind(Interner) {
                     TyKind::Adt(_, s) => s.clone(),
                     _ => not_supported!("Non ADT record literal"),
                 };
@@ -757,7 +792,17 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 self.push_assignment(current, place, Rvalue::Ref(bk, p), expr_id.into());
                 Ok(Some(current))
             }
-            Expr::Box { .. } => not_supported!("box expression"),
+            Expr::Box { expr } => {
+                let ty = self.expr_ty_after_adjustments(*expr);
+                self.push_assignment(current, place.clone(), Rvalue::ShallowInitBoxWithAlloc(ty), expr_id.into());
+                let Some((operand, current)) = self.lower_expr_to_some_operand(*expr, current)? else {
+                    return Ok(None);
+                };
+                let mut p = place;
+                p.projection.push(ProjectionElem::Deref);
+                self.push_assignment(current, p, operand.into(), expr_id.into());
+                Ok(Some(current))
+            },
             Expr::Field { .. } | Expr::Index { .. } | Expr::UnaryOp { op: hir_def::hir::UnaryOp::Deref, .. } => {
                 let Some((p, current)) = self.lower_expr_as_place_without_adjust(current, expr_id, true)? else {
                     return Ok(None);
@@ -784,20 +829,63 @@ impl<'ctx> MirLowerCtx<'ctx> {
             },
             Expr::BinaryOp { lhs, rhs, op } => {
                 let op = op.ok_or(MirLowerError::IncompleteExpr)?;
-                if let hir_def::hir::BinaryOp::Assignment { op } = op {
-                    if op.is_some() {
-                        not_supported!("assignment with arith op (like +=)");
+                let is_builtin = {
+                    // Without adjust here is a hack. We assume that we know every possible adjustment
+                    // for binary operator, and use without adjust to simplify our conditions.
+                    let lhs_ty = self.expr_ty_without_adjust(*lhs);
+                    let rhs_ty = self.expr_ty_without_adjust(*rhs);
+                    let builtin_inequal_impls = matches!(
+                        op,
+                        BinaryOp::ArithOp(ArithOp::Shl | ArithOp::Shr) | BinaryOp::Assignment { op: Some(ArithOp::Shl | ArithOp::Shr) }
+                    );
+                    lhs_ty.as_builtin().is_some() && rhs_ty.as_builtin().is_some() && (lhs_ty == rhs_ty || builtin_inequal_impls)
+                };
+                if !is_builtin {
+                    if let Some((func_id, generic_args)) = self.infer.method_resolution(expr_id) {
+                        let func = Operand::from_fn(self.db, func_id, generic_args);
+                        return self.lower_call_and_args(
+                            func,
+                            [*lhs, *rhs].into_iter(),
+                            place,
+                            current,
+                            self.is_uninhabited(expr_id),
+                            expr_id.into(),
+                        );
                     }
-                    let Some((lhs_place, current)) =
+                }
+                if let hir_def::hir::BinaryOp::Assignment { op } = op {
+                    if let Some(op) = op {
+                        // last adjustment is `&mut` which we don't want it.
+                        let adjusts = self
+                            .infer
+                            .expr_adjustments
+                            .get(lhs)
+                            .and_then(|x| x.split_last())
+                            .map(|x| x.1)
+                            .ok_or(MirLowerError::TypeError("adjustment of binary op was missing"))?;
+                        let Some((lhs_place, current)) =
+                            self.lower_expr_as_place_with_adjust(current, *lhs, false, adjusts)?
+                        else {
+                            return Ok(None);
+                        };
+                        let Some((rhs_op, current)) = self.lower_expr_to_some_operand(*rhs, current)? else {
+                            return Ok(None);
+                        };
+                        let r_value = Rvalue::CheckedBinaryOp(op.into(), Operand::Copy(lhs_place.clone()), rhs_op);
+                        self.push_assignment(current, lhs_place, r_value, expr_id.into());
+                        return Ok(Some(current));
+                    } else {
+                        let Some((lhs_place, current)) =
                         self.lower_expr_as_place(current, *lhs, false)?
-                    else {
-                        return Ok(None);
-                    };
-                    let Some((rhs_op, current)) = self.lower_expr_to_some_operand(*rhs, current)? else {
-                        return Ok(None);
-                    };
-                    self.push_assignment(current, lhs_place, rhs_op.into(), expr_id.into());
-                    return Ok(Some(current));
+                        else {
+                            return Ok(None);
+                        };
+                        let Some((rhs_op, current)) = self.lower_expr_to_some_operand(*rhs, current)? else {
+                            return Ok(None);
+                        };
+                        self.push_assignment(current, lhs_place, rhs_op.into(), expr_id.into());
+                        return Ok(Some(current));
+                    }
                 }
                 let Some((lhs_op, current)) = self.lower_expr_to_some_operand(*lhs, current)? else {
                     return Ok(None);
@@ -826,7 +914,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 Ok(Some(current))
             }
             &Expr::Range { lhs, rhs, range_type: _ } => {
-                let ty = self.expr_ty(expr_id);
+                let ty = self.expr_ty_without_adjust(expr_id);
                 let Some((adt, subst)) = ty.as_adt() else {
                     return Err(MirLowerError::TypeError("Range type is not adt"));
                 };
@@ -869,7 +957,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 Ok(Some(current))
             },
             Expr::Closure { .. } => {
-                let ty = self.expr_ty(expr_id);
+                let ty = self.expr_ty_without_adjust(expr_id);
                 let TyKind::Closure(id, _) = ty.kind(Interner) else {
                     not_supported!("closure with non closure type");
                 };
@@ -893,7 +981,12 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     };
                     match &capture.kind {
                         CaptureKind::ByRef(bk) => {
-                            let tmp: Place = self.temp(capture.ty.clone())?.into();
+                            let placeholder_subst = match self.owner.as_generic_def_id() {
+                                Some(x) => TyBuilder::placeholder_subst(self.db, x),
+                                None => Substitution::empty(Interner),
+                            };
+                            let tmp_ty = capture.ty.clone().substitute(Interner, &placeholder_subst);
+                            let tmp: Place = self.temp(tmp_ty)?.into();
                             self.push_assignment(
                                 current,
                                 tmp.clone(),
@@ -928,7 +1021,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     return Ok(None);
                 };
                 let r = Rvalue::Aggregate(
-                    AggregateKind::Tuple(self.expr_ty(expr_id)),
+                    AggregateKind::Tuple(self.expr_ty_without_adjust(expr_id)),
                     values,
                 );
                 self.push_assignment(current, place, r, expr_id.into());
@@ -936,7 +1029,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
             }
             Expr::Array(l) => match l {
                 Array::ElementList { elements, .. } => {
-                    let elem_ty = match &self.expr_ty(expr_id).data(Interner).kind {
+                    let elem_ty = match &self.expr_ty_without_adjust(expr_id).data(Interner).kind {
                         TyKind::Array(ty, _) => ty.clone(),
                         _ => {
                             return Err(MirLowerError::TypeError(
@@ -968,7 +1061,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     let Some((init, current)) = self.lower_expr_to_some_operand(*initializer, current)? else {
                         return Ok(None);
                     };
-                    let len = match &self.expr_ty(expr_id).data(Interner).kind {
+                    let len = match &self.expr_ty_without_adjust(expr_id).data(Interner).kind {
                         TyKind::Array(_, len) => len.clone(),
                         _ => {
                             return Err(MirLowerError::TypeError(
@@ -982,7 +1075,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 },
             },
             Expr::Literal(l) => {
-                let ty = self.expr_ty(expr_id);
+                let ty = self.expr_ty_without_adjust(expr_id);
                 let op = self.lower_literal_to_operand(ty, l)?;
                 self.push_assignment(current, place, op.into(), expr_id.into());
                 Ok(Some(current))
@@ -1057,8 +1150,30 @@ impl<'ctx> MirLowerCtx<'ctx> {
         place: Place,
         subst: Substitution,
         span: MirSpan,
+        ty: Ty,
     ) -> Result<()> {
-        let c = self.db.const_eval(const_id, subst)?;
+        let c = if subst.len(Interner) != 0 {
+            // We can't evaluate constant with substitution now, as generics are not monomorphized in lowering.
+            intern_const_scalar(ConstScalar::UnevaluatedConst(const_id, subst), ty)
+        } else {
+            let (const_id, subst) = lookup_impl_const(
+                self.db,
+                self.db.trait_environment_for_body(self.owner),
+                const_id,
+                subst,
+            );
+            let name = self
+                .db
+                .const_data(const_id)
+                .name
+                .as_ref()
+                .and_then(|x| x.as_str())
+                .unwrap_or("_")
+                .to_owned();
+            self.db
+                .const_eval(const_id.into(), subst)
+                .map_err(|e| MirLowerError::ConstEvalError(name, Box::new(e)))?
+        };
         self.write_const_to_place(c, prev_block, place, span)
     }
 
@@ -1114,6 +1229,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         place: Place,
         mut current: BasicBlockId,
         is_uninhabited: bool,
+        span: MirSpan,
     ) -> Result<Option<BasicBlockId>> {
         let Some(args) = args
             .map(|arg| {
@@ -1128,7 +1244,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         else {
             return Ok(None);
         };
-        self.lower_call(func, args, place, current, is_uninhabited)
+        self.lower_call(func, args, place, current, is_uninhabited, span)
     }
 
     fn lower_call(
@@ -1138,11 +1254,12 @@ impl<'ctx> MirLowerCtx<'ctx> {
         place: Place,
         current: BasicBlockId,
         is_uninhabited: bool,
+        span: MirSpan,
     ) -> Result<Option<BasicBlockId>> {
         let b = if is_uninhabited { None } else { Some(self.new_basic_block()) };
         self.set_terminator(
             current,
-            Terminator::Call {
+            TerminatorKind::Call {
                 func,
                 args,
                 destination: place,
@@ -1150,6 +1267,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 cleanup: None,
                 from_hir_call: true,
             },
+            span,
         );
         Ok(b)
     }
@@ -1158,15 +1276,15 @@ impl<'ctx> MirLowerCtx<'ctx> {
         self.result.basic_blocks[source].terminator.is_none()
     }
 
-    fn set_terminator(&mut self, source: BasicBlockId, terminator: Terminator) {
-        self.result.basic_blocks[source].terminator = Some(terminator);
+    fn set_terminator(&mut self, source: BasicBlockId, terminator: TerminatorKind, span: MirSpan) {
+        self.result.basic_blocks[source].terminator = Some(Terminator { span, kind: terminator });
     }
 
-    fn set_goto(&mut self, source: BasicBlockId, target: BasicBlockId) {
-        self.set_terminator(source, Terminator::Goto { target });
+    fn set_goto(&mut self, source: BasicBlockId, target: BasicBlockId, span: MirSpan) {
+        self.set_terminator(source, TerminatorKind::Goto { target }, span);
     }
 
-    fn expr_ty(&self, e: ExprId) -> Ty {
+    fn expr_ty_without_adjust(&self, e: ExprId) -> Ty {
         self.infer[e].clone()
     }
 
@@ -1177,7 +1295,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 ty = Some(x.target.clone());
             }
         }
-        ty.unwrap_or_else(|| self.expr_ty(e))
+        ty.unwrap_or_else(|| self.expr_ty_without_adjust(e))
     }
 
     fn push_statement(&mut self, block: BasicBlockId, statement: Statement) {
@@ -1211,6 +1329,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         prev_block: BasicBlockId,
         place: Place,
         label: Option<LabelId>,
+        span: MirSpan,
         f: impl FnOnce(&mut MirLowerCtx<'_>, BasicBlockId) -> Result<()>,
     ) -> Result<Option<BasicBlockId>> {
         let begin = self.new_basic_block();
@@ -1228,7 +1347,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         } else {
             None
         };
-        self.set_goto(prev_block, begin);
+        self.set_goto(prev_block, begin, span);
         f(self, begin)?;
         let my = mem::replace(&mut self.current_loop_blocks, prev).ok_or(
             MirLowerError::ImplementationError("current_loop_blocks is corrupt".to_string()),
@@ -1247,14 +1366,15 @@ impl<'ctx> MirLowerCtx<'ctx> {
         &mut self,
         b1: Option<BasicBlockId>,
         b2: Option<BasicBlockId>,
+        span: MirSpan,
     ) -> Option<BasicBlockId> {
         match (b1, b2) {
             (None, None) => None,
             (None, Some(b)) | (Some(b), None) => Some(b),
             (Some(b1), Some(b2)) => {
                 let bm = self.new_basic_block();
-                self.set_goto(b1, bm);
-                self.set_goto(b2, bm);
+                self.set_goto(b1, bm, span);
+                self.set_goto(b2, bm, span);
                 Some(bm)
             }
         }
@@ -1332,6 +1452,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         mut current: BasicBlockId,
         tail: Option<ExprId>,
         place: Place,
+        span: MirSpan,
     ) -> Result<Option<Idx<BasicBlock>>> {
         for statement in statements.iter() {
             match statement {
@@ -1355,13 +1476,13 @@ impl<'ctx> MirLowerCtx<'ctx> {
                         match (else_block, else_branch) {
                             (None, _) => (),
                             (Some(else_block), None) => {
-                                self.set_terminator(else_block, Terminator::Unreachable);
+                                self.set_terminator(else_block, TerminatorKind::Unreachable, span);
                             }
                             (Some(else_block), Some(else_branch)) => {
                                 if let Some((_, b)) =
                                     self.lower_expr_as_place(else_block, *else_branch, true)?
                                 {
-                                    self.set_terminator(b, Terminator::Unreachable);
+                                    self.set_terminator(b, TerminatorKind::Unreachable, span);
                                 }
                             }
                         }
@@ -1438,7 +1559,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 BindingAnnotation::Unannotated,
             )?;
             if let Some(b) = r.1 {
-                self.set_terminator(b, Terminator::Unreachable);
+                self.set_terminator(b, TerminatorKind::Unreachable, param.into());
             }
             current = r.0;
         }
@@ -1456,6 +1577,18 @@ impl<'ctx> MirLowerCtx<'ctx> {
             }
         }
     }
+
+    fn const_eval_discriminant(&self, variant: EnumVariantId) -> Result<i128> {
+        let r = self.db.const_eval_discriminant(variant);
+        match r {
+            Ok(r) => Ok(r),
+            Err(e) => {
+                let data = self.db.enum_data(variant.parent);
+                let name = format!("{}::{}", data.name, data.variants[variant.local_id].name);
+                Err(MirLowerError::ConstEvalError(name, Box::new(e)))
+            }
+        }
+    }
 }
 
 fn cast_kind(source_ty: &Ty, target_ty: &Ty) -> Result<CastKind> {
@@ -1498,7 +1631,7 @@ pub fn mir_body_for_closure_query(
     // 0 is return local
     ctx.result.locals.alloc(Local { ty: infer[*root].clone() });
     ctx.result.locals.alloc(Local { ty: infer[expr].clone() });
-    let Some(sig) = substs.at(Interner, 0).assert_ty_ref(Interner).callable_sig(db) else {
+    let Some(sig) = ClosureSubst(substs).sig_ty().callable_sig(db) else {
         implementation_error!("closure has not callable sig");
     };
     let current = ctx.lower_params_and_bindings(
@@ -1506,7 +1639,7 @@ pub fn mir_body_for_closure_query(
         |_| true,
     )?;
     if let Some(b) = ctx.lower_expr_to_place(*root, return_slot().into(), current)? {
-        ctx.set_terminator(b, Terminator::Return);
+        ctx.set_terminator(b, TerminatorKind::Return, (*root).into());
     }
     let mut upvar_map: FxHashMap<LocalId, Vec<(&CapturedItem, usize)>> = FxHashMap::default();
     for (i, capture) in captures.iter().enumerate() {
@@ -1628,7 +1761,7 @@ pub fn lower_to_mir(
         ctx.lower_params_and_bindings([].into_iter(), binding_picker)?
     };
     if let Some(b) = ctx.lower_expr_to_place(root_expr, return_slot().into(), current)? {
-        ctx.set_terminator(b, Terminator::Return);
+        ctx.set_terminator(b, TerminatorKind::Return, root_expr.into());
     }
     Ok(ctx.result)
 }
diff --git a/crates/hir-ty/src/mir/lower/as_place.rs b/crates/hir-ty/src/mir/lower/as_place.rs
index a1574f55936..8d8870da0d4 100644
--- a/crates/hir-ty/src/mir/lower/as_place.rs
+++ b/crates/hir-ty/src/mir/lower/as_place.rs
@@ -1,7 +1,7 @@
 //! MIR lowering for places
 
 use super::*;
-use hir_def::FunctionId;
+use hir_def::{lang_item::lang_attr, FunctionId};
 use hir_expand::name;
 
 macro_rules! not_supported {
@@ -16,7 +16,7 @@ impl MirLowerCtx<'_> {
         expr_id: ExprId,
         prev_block: BasicBlockId,
     ) -> Result<Option<(Place, BasicBlockId)>> {
-        let ty = self.expr_ty(expr_id);
+        let ty = self.expr_ty_without_adjust(expr_id);
         let place = self.temp(ty)?;
         let Some(current) = self.lower_expr_to_place_without_adjust(expr_id, place.into(), prev_block)? else {
             return Ok(None);
@@ -30,8 +30,10 @@ impl MirLowerCtx<'_> {
         prev_block: BasicBlockId,
         adjustments: &[Adjustment],
     ) -> Result<Option<(Place, BasicBlockId)>> {
-        let ty =
-            adjustments.last().map(|x| x.target.clone()).unwrap_or_else(|| self.expr_ty(expr_id));
+        let ty = adjustments
+            .last()
+            .map(|x| x.target.clone())
+            .unwrap_or_else(|| self.expr_ty_without_adjust(expr_id));
         let place = self.temp(ty)?;
         let Some(current) = self.lower_expr_to_place_with_adjust(expr_id, place.into(), prev_block, adjustments)? else {
             return Ok(None);
@@ -80,7 +82,7 @@ impl MirLowerCtx<'_> {
                         r,
                         rest.last()
                             .map(|x| x.target.clone())
-                            .unwrap_or_else(|| self.expr_ty(expr_id)),
+                            .unwrap_or_else(|| self.expr_ty_without_adjust(expr_id)),
                         last.target.clone(),
                         expr_id.into(),
                         match od.0 {
@@ -135,17 +137,39 @@ impl MirLowerCtx<'_> {
                 };
                 match pr {
                     ValueNs::LocalBinding(pat_id) => {
-                        Ok(Some((self.result.binding_locals[pat_id].into(), current)))
+                        Ok(Some((self.binding_local(pat_id)?.into(), current)))
+                    }
+                    ValueNs::StaticId(s) => {
+                        let ty = self.expr_ty_without_adjust(expr_id);
+                        let ref_ty =
+                            TyKind::Ref(Mutability::Not, static_lifetime(), ty).intern(Interner);
+                        let mut temp: Place = self.temp(ref_ty)?.into();
+                        self.push_assignment(
+                            current,
+                            temp.clone(),
+                            Operand::Static(s).into(),
+                            expr_id.into(),
+                        );
+                        temp.projection.push(ProjectionElem::Deref);
+                        Ok(Some((temp, current)))
                     }
                     _ => try_rvalue(self),
                 }
             }
             Expr::UnaryOp { expr, op } => match op {
                 hir_def::hir::UnaryOp::Deref => {
-                    if !matches!(
-                        self.expr_ty(*expr).kind(Interner),
-                        TyKind::Ref(..) | TyKind::Raw(..)
-                    ) {
+                    let is_builtin = match self.expr_ty_without_adjust(*expr).kind(Interner) {
+                        TyKind::Ref(..) | TyKind::Raw(..) => true,
+                        TyKind::Adt(id, _) => {
+                            if let Some(lang_item) = lang_attr(self.db.upcast(), id.0) {
+                                lang_item == LangItem::OwnedBox
+                            } else {
+                                false
+                            }
+                        }
+                        _ => false,
+                    };
+                    if !is_builtin {
                         let Some((p, current)) = self.lower_expr_as_place(current, *expr, true)? else {
                             return Ok(None);
                         };
@@ -153,7 +177,7 @@ impl MirLowerCtx<'_> {
                             current,
                             p,
                             self.expr_ty_after_adjustments(*expr),
-                            self.expr_ty(expr_id),
+                            self.expr_ty_without_adjust(expr_id),
                             expr_id.into(),
                             'b: {
                                 if let Some((f, _)) = self.infer.method_resolution(expr_id) {
@@ -198,7 +222,7 @@ impl MirLowerCtx<'_> {
                     )
                 {
                     let Some(index_fn) = self.infer.method_resolution(expr_id) else {
-                        return Err(MirLowerError::UnresolvedMethod);
+                        return Err(MirLowerError::UnresolvedMethod("[overloaded index]".to_string()));
                     };
                     let Some((base_place, current)) = self.lower_expr_as_place(current, *base, true)? else {
                         return Ok(None);
@@ -210,7 +234,7 @@ impl MirLowerCtx<'_> {
                         current,
                         base_place,
                         base_ty,
-                        self.expr_ty(expr_id),
+                        self.expr_ty_without_adjust(expr_id),
                         index_operand,
                         expr_id.into(),
                         index_fn,
@@ -266,7 +290,7 @@ impl MirLowerCtx<'_> {
             )
             .intern(Interner),
         );
-        let Some(current) = self.lower_call(index_fn_op, vec![Operand::Copy(ref_place), index_operand], result.clone(), current, false)? else {
+        let Some(current) = self.lower_call(index_fn_op, vec![Operand::Copy(ref_place), index_operand], result.clone(), current, false, span)? else {
             return Ok(None);
         };
         result.projection.push(ProjectionElem::Deref);
@@ -313,7 +337,7 @@ impl MirLowerCtx<'_> {
             .intern(Interner),
         );
         let mut result: Place = self.temp(target_ty_ref)?.into();
-        let Some(current) = self.lower_call(deref_fn_op, vec![Operand::Copy(ref_place)], result.clone(), current, false)? else {
+        let Some(current) = self.lower_call(deref_fn_op, vec![Operand::Copy(ref_place)], result.clone(), current, false, span)? else {
             return Ok(None);
         };
         result.projection.push(ProjectionElem::Deref);
diff --git a/crates/hir-ty/src/mir/lower/pattern_matching.rs b/crates/hir-ty/src/mir/lower/pattern_matching.rs
index 86c3ce9eec9..97aa3b0f215 100644
--- a/crates/hir-ty/src/mir/lower/pattern_matching.rs
+++ b/crates/hir-ty/src/mir/lower/pattern_matching.rs
@@ -1,5 +1,7 @@
 //! MIR lowering for patterns
 
+use hir_def::resolver::HasResolver;
+
 use crate::utils::pattern_matching_dereference_count;
 
 use super::*;
@@ -72,7 +74,7 @@ impl MirLowerCtx<'_> {
                         *pat,
                         binding_mode,
                     )?;
-                    self.set_goto(next, then_target);
+                    self.set_goto(next, then_target, pattern.into());
                     match next_else {
                         Some(t) => {
                             current = t;
@@ -85,13 +87,13 @@ impl MirLowerCtx<'_> {
                 }
                 if !finished {
                     let ce = *current_else.get_or_insert_with(|| self.new_basic_block());
-                    self.set_goto(current, ce);
+                    self.set_goto(current, ce, pattern.into());
                 }
                 (then_target, current_else)
             }
             Pat::Record { args, .. } => {
                 let Some(variant) = self.infer.variant_resolution_for_pat(pattern) else {
-                    not_supported!("unresolved variant");
+                    not_supported!("unresolved variant for record");
                 };
                 self.pattern_matching_variant(
                     cond_ty,
@@ -106,11 +108,8 @@ impl MirLowerCtx<'_> {
             }
             Pat::Range { .. } => not_supported!("range pattern"),
             Pat::Slice { .. } => not_supported!("slice pattern"),
-            Pat::Path(_) => {
-                let Some(variant) = self.infer.variant_resolution_for_pat(pattern) else {
-                    not_supported!("unresolved variant");
-                };
-                self.pattern_matching_variant(
+            Pat::Path(p) => match self.infer.variant_resolution_for_pat(pattern) {
+                Some(variant) => self.pattern_matching_variant(
                     cond_ty,
                     binding_mode,
                     cond_place,
@@ -119,8 +118,60 @@ impl MirLowerCtx<'_> {
                     pattern.into(),
                     current_else,
                     AdtPatternShape::Unit,
-                )?
-            }
+                )?,
+                None => {
+                    let unresolved_name = || MirLowerError::unresolved_path(self.db, p);
+                    let resolver = self.owner.resolver(self.db.upcast());
+                    let pr = resolver
+                        .resolve_path_in_value_ns(self.db.upcast(), p)
+                        .ok_or_else(unresolved_name)?;
+                    match pr {
+                        ResolveValueResult::ValueNs(v) => match v {
+                            ValueNs::ConstId(c) => {
+                                let tmp: Place = self.temp(cond_ty.clone())?.into();
+                                let span = pattern.into();
+                                self.lower_const(
+                                    c,
+                                    current,
+                                    tmp.clone(),
+                                    Substitution::empty(Interner),
+                                    span,
+                                    cond_ty.clone(),
+                                )?;
+                                let tmp2: Place = self.temp(TyBuilder::bool())?.into();
+                                self.push_assignment(
+                                    current,
+                                    tmp2.clone(),
+                                    Rvalue::CheckedBinaryOp(
+                                        BinOp::Eq,
+                                        Operand::Copy(tmp),
+                                        Operand::Copy(cond_place),
+                                    ),
+                                    span,
+                                );
+                                let next = self.new_basic_block();
+                                let else_target =
+                                    current_else.unwrap_or_else(|| self.new_basic_block());
+                                self.set_terminator(
+                                    current,
+                                    TerminatorKind::SwitchInt {
+                                        discr: Operand::Copy(tmp2),
+                                        targets: SwitchTargets::static_if(1, next, else_target),
+                                    },
+                                    span,
+                                );
+                                (next, Some(else_target))
+                            }
+                            _ => not_supported!(
+                                "path in pattern position that is not const or variant"
+                            ),
+                        },
+                        ResolveValueResult::Partial(_, _) => {
+                            not_supported!("assoc const in patterns")
+                        }
+                    }
+                }
+            },
             Pat::Lit(l) => match &self.body.exprs[*l] {
                 Expr::Literal(l) => {
                     let c = self.lower_literal_to_operand(cond_ty, l)?;
@@ -218,10 +269,11 @@ impl MirLowerCtx<'_> {
         let discr = Operand::Copy(discr);
         self.set_terminator(
             current,
-            Terminator::SwitchInt {
+            TerminatorKind::SwitchInt {
                 discr,
                 targets: SwitchTargets::static_if(1, then_target, else_target),
             },
+            pattern.into(),
         );
         Ok((then_target, Some(else_target)))
     }
@@ -244,8 +296,7 @@ impl MirLowerCtx<'_> {
         };
         Ok(match variant {
             VariantId::EnumVariantId(v) => {
-                let e = self.db.const_eval_discriminant(v)? as u128;
-                let next = self.new_basic_block();
+                let e = self.const_eval_discriminant(v)? as u128;
                 let tmp = self.discr_temp_place();
                 self.push_assignment(
                     current,
@@ -253,13 +304,15 @@ impl MirLowerCtx<'_> {
                     Rvalue::Discriminant(cond_place.clone()),
                     span,
                 );
+                let next = self.new_basic_block();
                 let else_target = current_else.unwrap_or_else(|| self.new_basic_block());
                 self.set_terminator(
                     current,
-                    Terminator::SwitchInt {
+                    TerminatorKind::SwitchInt {
                         discr: Operand::Copy(tmp),
                         targets: SwitchTargets::static_if(e, next, else_target),
                     },
+                    span,
                 );
                 let enum_data = self.db.enum_data(v.parent);
                 self.pattern_matching_variant_fields(
diff --git a/crates/hir-ty/src/mir/pretty.rs b/crates/hir-ty/src/mir/pretty.rs
index a7dff396135..257860968c4 100644
--- a/crates/hir-ty/src/mir/pretty.rs
+++ b/crates/hir-ty/src/mir/pretty.rs
@@ -11,19 +11,52 @@ use la_arena::ArenaMap;
 
 use crate::{
     db::HirDatabase,
-    display::HirDisplay,
-    mir::{PlaceElem, ProjectionElem, StatementKind, Terminator},
+    display::{ClosureStyle, HirDisplay},
+    mir::{PlaceElem, ProjectionElem, StatementKind, TerminatorKind},
+    ClosureId,
 };
 
 use super::{
     AggregateKind, BasicBlockId, BorrowKind, LocalId, MirBody, Operand, Place, Rvalue, UnOp,
 };
 
+macro_rules! w {
+    ($dst:expr, $($arg:tt)*) => {
+        { let _ = write!($dst, $($arg)*); }
+    };
+}
+
+macro_rules! wln {
+    ($dst:expr) => {
+        { let _ = writeln!($dst); }
+    };
+    ($dst:expr, $($arg:tt)*) => {
+        { let _ = writeln!($dst, $($arg)*); }
+    };
+}
+
 impl MirBody {
     pub fn pretty_print(&self, db: &dyn HirDatabase) -> String {
         let hir_body = db.body(self.owner);
         let mut ctx = MirPrettyCtx::new(self, &hir_body, db);
-        ctx.for_body(ctx.body.owner);
+        ctx.for_body(|this| match ctx.body.owner {
+            hir_def::DefWithBodyId::FunctionId(id) => {
+                let data = db.function_data(id);
+                w!(this, "fn {}() ", data.name);
+            }
+            hir_def::DefWithBodyId::StaticId(id) => {
+                let data = db.static_data(id);
+                w!(this, "static {}: _ = ", data.name);
+            }
+            hir_def::DefWithBodyId::ConstId(id) => {
+                let data = db.const_data(id);
+                w!(this, "const {}: _ = ", data.name.as_ref().unwrap_or(&Name::missing()));
+            }
+            hir_def::DefWithBodyId::VariantId(id) => {
+                let data = db.enum_data(id.parent);
+                w!(this, "enum {} = ", data.name);
+            }
+        });
         ctx.result
     }
 
@@ -49,21 +82,6 @@ struct MirPrettyCtx<'a> {
     local_to_binding: ArenaMap<LocalId, BindingId>,
 }
 
-macro_rules! w {
-    ($dst:expr, $($arg:tt)*) => {
-        { let _ = write!($dst, $($arg)*); }
-    };
-}
-
-macro_rules! wln {
-    ($dst:expr) => {
-        { let _ = writeln!($dst); }
-    };
-    ($dst:expr, $($arg:tt)*) => {
-        { let _ = writeln!($dst, $($arg)*); }
-    };
-}
-
 impl Write for MirPrettyCtx<'_> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
         let mut it = s.split('\n'); // note: `.lines()` is wrong here
@@ -91,36 +109,40 @@ impl Display for LocalName {
 }
 
 impl<'a> MirPrettyCtx<'a> {
-    fn for_body(&mut self, name: impl Debug) {
-        wln!(self, "// {:?}", name);
+    fn for_body(&mut self, name: impl FnOnce(&mut MirPrettyCtx<'_>)) {
+        name(self);
         self.with_block(|this| {
             this.locals();
             wln!(this);
             this.blocks();
         });
         for &closure in &self.body.closures {
-            let body = match self.db.mir_body_for_closure(closure) {
-                Ok(x) => x,
-                Err(e) => {
-                    wln!(self, "// error in {closure:?}: {e:?}");
-                    continue;
-                }
-            };
-            let result = mem::take(&mut self.result);
-            let indent = mem::take(&mut self.indent);
-            let mut ctx = MirPrettyCtx {
-                body: &body,
-                local_to_binding: body.binding_locals.iter().map(|(x, y)| (*y, x)).collect(),
-                result,
-                indent,
-                ..*self
-            };
-            ctx.for_body(closure);
-            self.result = ctx.result;
-            self.indent = ctx.indent;
+            self.for_closure(closure);
         }
     }
 
+    fn for_closure(&mut self, closure: ClosureId) {
+        let body = match self.db.mir_body_for_closure(closure) {
+            Ok(x) => x,
+            Err(e) => {
+                wln!(self, "// error in {closure:?}: {e:?}");
+                return;
+            }
+        };
+        let result = mem::take(&mut self.result);
+        let indent = mem::take(&mut self.indent);
+        let mut ctx = MirPrettyCtx {
+            body: &body,
+            local_to_binding: body.binding_locals.iter().map(|(x, y)| (*y, x)).collect(),
+            result,
+            indent,
+            ..*self
+        };
+        ctx.for_body(|this| wln!(this, "// Closure: {:?}", closure));
+        self.result = ctx.result;
+        self.indent = ctx.indent;
+    }
+
     fn with_block(&mut self, f: impl FnOnce(&mut MirPrettyCtx<'_>)) {
         self.indent += "    ";
         wln!(self, "{{");
@@ -155,7 +177,7 @@ impl<'a> MirPrettyCtx<'a> {
 
     fn locals(&mut self) {
         for (id, local) in self.body.locals.iter() {
-            wln!(self, "let {}: {};", self.local_name(id), local.ty.display(self.db));
+            wln!(self, "let {}: {};", self.local_name(id), self.hir_display(&local.ty));
         }
     }
 
@@ -198,11 +220,11 @@ impl<'a> MirPrettyCtx<'a> {
                     }
                 }
                 match &block.terminator {
-                    Some(terminator) => match terminator {
-                        Terminator::Goto { target } => {
+                    Some(terminator) => match &terminator.kind {
+                        TerminatorKind::Goto { target } => {
                             wln!(this, "goto 'bb{};", u32::from(target.into_raw()))
                         }
-                        Terminator::SwitchInt { discr, targets } => {
+                        TerminatorKind::SwitchInt { discr, targets } => {
                             w!(this, "switch ");
                             this.operand(discr);
                             w!(this, " ");
@@ -213,7 +235,7 @@ impl<'a> MirPrettyCtx<'a> {
                                 wln!(this, "_ => {},", this.basic_block_id(targets.otherwise()));
                             });
                         }
-                        Terminator::Call { func, args, destination, target, .. } => {
+                        TerminatorKind::Call { func, args, destination, target, .. } => {
                             w!(this, "Call ");
                             this.with_block(|this| {
                                 w!(this, "func: ");
@@ -295,7 +317,8 @@ impl<'a> MirPrettyCtx<'a> {
                 // equally. Feel free to change it.
                 self.place(p);
             }
-            Operand::Constant(c) => w!(self, "Const({})", c.display(self.db)),
+            Operand::Constant(c) => w!(self, "Const({})", self.hir_display(c)),
+            Operand::Static(s) => w!(self, "Static({:?})", s),
         }
     }
 
@@ -349,7 +372,7 @@ impl<'a> MirPrettyCtx<'a> {
             Rvalue::Cast(ck, op, ty) => {
                 w!(self, "Cast({ck:?}, ");
                 self.operand(op);
-                w!(self, ", {})", ty.display(self.db));
+                w!(self, ", {})", self.hir_display(ty));
             }
             Rvalue::CheckedBinaryOp(b, o1, o2) => {
                 self.operand(o1);
@@ -369,6 +392,7 @@ impl<'a> MirPrettyCtx<'a> {
                 self.place(p);
                 w!(self, ")");
             }
+            Rvalue::ShallowInitBoxWithAlloc(_) => w!(self, "ShallowInitBoxWithAlloc"),
             Rvalue::ShallowInitBox(op, _) => {
                 w!(self, "ShallowInitBox(");
                 self.operand(op);
@@ -392,4 +416,8 @@ impl<'a> MirPrettyCtx<'a> {
             }
         }
     }
+
+    fn hir_display<T: HirDisplay>(&self, ty: &'a T) -> impl Display + 'a {
+        ty.display(self.db).with_closure_style(ClosureStyle::ClosureWithId)
+    }
 }
diff --git a/crates/hir-ty/src/utils.rs b/crates/hir-ty/src/utils.rs
index 3b2a726688d..aa40d084795 100644
--- a/crates/hir-ty/src/utils.rs
+++ b/crates/hir-ty/src/utils.rs
@@ -23,10 +23,11 @@ use hir_expand::name::Name;
 use intern::Interned;
 use rustc_hash::FxHashSet;
 use smallvec::{smallvec, SmallVec};
+use stdx::never;
 
 use crate::{
-    db::HirDatabase, ChalkTraitId, Interner, Substitution, TraitRef, TraitRefExt, Ty, TyExt,
-    WhereClause,
+    db::HirDatabase, ChalkTraitId, GenericArg, Interner, Substitution, TraitRef, TraitRefExt, Ty,
+    TyExt, WhereClause,
 };
 
 pub(crate) fn fn_traits(
@@ -176,6 +177,37 @@ pub(crate) fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics {
     Generics { def, params: db.generic_params(def), parent_generics }
 }
 
+/// It is a bit different from the rustc equivalent. Currently it stores:
+/// - 0: the function signature, encoded as a function pointer type
+/// - 1..n: generics of the parent
+///
+/// and it doesn't store the closure types and fields.
+///
+/// Codes should not assume this ordering, and should always use methods available
+/// on this struct for retriving, and `TyBuilder::substs_for_closure` for creating.
+pub(crate) struct ClosureSubst<'a>(pub(crate) &'a Substitution);
+
+impl<'a> ClosureSubst<'a> {
+    pub(crate) fn parent_subst(&self) -> &'a [GenericArg] {
+        match self.0.as_slice(Interner) {
+            [_, x @ ..] => x,
+            _ => {
+                never!("Closure missing parameter");
+                &[]
+            }
+        }
+    }
+
+    pub(crate) fn sig_ty(&self) -> &'a Ty {
+        match self.0.as_slice(Interner) {
+            [x, ..] => x.assert_ty_ref(Interner),
+            _ => {
+                unreachable!("Closure missing sig_ty parameter");
+            }
+        }
+    }
+}
+
 #[derive(Debug)]
 pub(crate) struct Generics {
     def: GenericDefId,
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index f7a14bf36ad..145506a89df 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -1856,11 +1856,21 @@ impl Function {
         def_map.fn_as_proc_macro(self.id).map(|id| Macro { id: id.into() })
     }
 
-    pub fn eval(self, db: &dyn HirDatabase) -> Result<(), MirEvalError> {
+    pub fn eval(
+        self,
+        db: &dyn HirDatabase,
+        span_formatter: impl Fn(FileId, TextRange) -> String,
+    ) -> Result<(), String> {
+        let converter = |e: MirEvalError| {
+            let mut r = String::new();
+            _ = e.pretty_print(&mut r, db, &span_formatter);
+            r
+        };
         let body = db
             .mir_body(self.id.into())
-            .map_err(|e| MirEvalError::MirLowerError(self.id.into(), e))?;
-        interpret_mir(db, &body, Substitution::empty(Interner), false)?;
+            .map_err(|e| MirEvalError::MirLowerError(self.id.into(), e))
+            .map_err(converter)?;
+        interpret_mir(db, &body, Substitution::empty(Interner), false).map_err(converter)?;
         Ok(())
     }
 }
@@ -2006,7 +2016,7 @@ impl Const {
     }
 
     pub fn render_eval(self, db: &dyn HirDatabase) -> Result<String, ConstEvalError> {
-        let c = db.const_eval(self.id, Substitution::empty(Interner))?;
+        let c = db.const_eval(self.id.into(), Substitution::empty(Interner))?;
         let r = format!("{}", HexifiedConst(c).display(db));
         // We want to see things like `<utf8-error>` and `<layout-error>` as they are probably bug in our
         // implementation, but there is no need to show things like `<enum-not-supported>` or `<ref-not-supported>` to
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index bbbf39ca15b..8e0aa9df147 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -30,7 +30,6 @@ pub struct HoverConfig {
     pub documentation: bool,
     pub keywords: bool,
     pub format: HoverDocFormat,
-    pub interpret_tests: bool,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
diff --git a/crates/ide/src/hover/render.rs b/crates/ide/src/hover/render.rs
index e5019b71595..8f8cdcce515 100644
--- a/crates/ide/src/hover/render.rs
+++ b/crates/ide/src/hover/render.rs
@@ -3,8 +3,7 @@ use std::fmt::Display;
 
 use either::Either;
 use hir::{
-    db::DefDatabase, Adt, AsAssocItem, AttributeTemplate, HasAttrs, HasSource, HirDisplay,
-    MirEvalError, Semantics, TypeInfo,
+    Adt, AsAssocItem, AttributeTemplate, HasAttrs, HasSource, HirDisplay, Semantics, TypeInfo,
 };
 use ide_db::{
     base_db::SourceDatabase,
@@ -435,19 +434,7 @@ pub(super) fn definition(
             ))
         }),
         Definition::Module(it) => label_and_docs(db, it),
-        Definition::Function(it) => label_and_layout_info_and_docs(db, it, |_| {
-            if !config.interpret_tests {
-                return None;
-            }
-            match it.eval(db) {
-                Ok(()) => Some("pass".into()),
-                Err(MirEvalError::MirLowerError(f, e)) => {
-                    let name = &db.function_data(f).name;
-                    Some(format!("error: fail to lower {name} due {e:?}"))
-                }
-                Err(e) => Some(format!("error: {e:?}")),
-            }
-        }),
+        Definition::Function(it) => label_and_docs(db, it),
         Definition::Adt(it) => label_and_layout_info_and_docs(db, it, |&it| {
             let layout = it.layout(db).ok()?;
             Some(format!("size = {}, align = {}", layout.size.bytes(), layout.align.abi.bytes()))
diff --git a/crates/ide/src/hover/tests.rs b/crates/ide/src/hover/tests.rs
index 24c39ab03d5..082e5372d42 100644
--- a/crates/ide/src/hover/tests.rs
+++ b/crates/ide/src/hover/tests.rs
@@ -9,7 +9,6 @@ const HOVER_BASE_CONFIG: HoverConfig = HoverConfig {
     documentation: true,
     format: HoverDocFormat::Markdown,
     keywords: true,
-    interpret_tests: false,
 };
 
 fn check_hover_no_result(ra_fixture: &str) {
diff --git a/crates/ide/src/inlay_hints/adjustment.rs b/crates/ide/src/inlay_hints/adjustment.rs
index d5be0c5b883..27e9ba3c36b 100644
--- a/crates/ide/src/inlay_hints/adjustment.rs
+++ b/crates/ide/src/inlay_hints/adjustment.rs
@@ -3,7 +3,10 @@
 //! let _: u32  = /* <never-to-any> */ loop {};
 //! let _: &u32 = /* &* */ &mut 0;
 //! ```
-use hir::{Adjust, Adjustment, AutoBorrow, HirDisplay, Mutability, PointerCast, Safety, Semantics};
+use hir::{
+    Adjust, Adjustment, AutoBorrow, HirDisplay, Mutability, OverloadedDeref, PointerCast, Safety,
+    Semantics,
+};
 use ide_db::RootDatabase;
 
 use stdx::never;
@@ -88,7 +91,13 @@ pub(super) fn hints(
             Adjust::NeverToAny if config.adjustment_hints == AdjustmentHints::Always => {
                 ("<never-to-any>", "never to any")
             }
-            Adjust::Deref(_) => ("*", "dereference"),
+            Adjust::Deref(None) => ("*", "dereference"),
+            Adjust::Deref(Some(OverloadedDeref(Mutability::Shared))) => {
+                ("*", "`Deref` dereference")
+            }
+            Adjust::Deref(Some(OverloadedDeref(Mutability::Mut))) => {
+                ("*", "`DerefMut` dereference")
+            }
             Adjust::Borrow(AutoBorrow::Ref(Mutability::Shared)) => ("&", "borrow"),
             Adjust::Borrow(AutoBorrow::Ref(Mutability::Mut)) => ("&mut ", "unique borrow"),
             Adjust::Borrow(AutoBorrow::RawPtr(Mutability::Shared)) => {
diff --git a/crates/ide/src/inlay_hints/chaining.rs b/crates/ide/src/inlay_hints/chaining.rs
index 069edaed665..d8c8401af77 100644
--- a/crates/ide/src/inlay_hints/chaining.rs
+++ b/crates/ide/src/inlay_hints/chaining.rs
@@ -444,7 +444,7 @@ fn main() {
                                         file_id: FileId(
                                             1,
                                         ),
-                                        range: 5768..5776,
+                                        range: 5769..5777,
                                     },
                                 ),
                                 tooltip: "",
@@ -457,7 +457,7 @@ fn main() {
                                         file_id: FileId(
                                             1,
                                         ),
-                                        range: 5800..5804,
+                                        range: 5801..5805,
                                     },
                                 ),
                                 tooltip: "",
@@ -478,7 +478,7 @@ fn main() {
                                         file_id: FileId(
                                             1,
                                         ),
-                                        range: 5768..5776,
+                                        range: 5769..5777,
                                     },
                                 ),
                                 tooltip: "",
@@ -491,7 +491,7 @@ fn main() {
                                         file_id: FileId(
                                             1,
                                         ),
-                                        range: 5800..5804,
+                                        range: 5801..5805,
                                     },
                                 ),
                                 tooltip: "",
@@ -512,7 +512,7 @@ fn main() {
                                         file_id: FileId(
                                             1,
                                         ),
-                                        range: 5768..5776,
+                                        range: 5769..5777,
                                     },
                                 ),
                                 tooltip: "",
@@ -525,7 +525,7 @@ fn main() {
                                         file_id: FileId(
                                             1,
                                         ),
-                                        range: 5800..5804,
+                                        range: 5801..5805,
                                     },
                                 ),
                                 tooltip: "",
diff --git a/crates/ide/src/interpret_function.rs b/crates/ide/src/interpret_function.rs
new file mode 100644
index 00000000000..d111f98955a
--- /dev/null
+++ b/crates/ide/src/interpret_function.rs
@@ -0,0 +1,49 @@
+use hir::Semantics;
+use ide_db::base_db::SourceDatabaseExt;
+use ide_db::RootDatabase;
+use ide_db::{base_db::FilePosition, LineIndexDatabase};
+use std::{fmt::Write, time::Instant};
+use syntax::TextRange;
+use syntax::{algo::find_node_at_offset, ast, AstNode};
+
+// Feature: Interpret Function
+//
+// |===
+// | Editor  | Action Name
+//
+// | VS Code | **rust-analyzer: Interpret Function**
+// |===
+pub(crate) fn interpret_function(db: &RootDatabase, position: FilePosition) -> String {
+    let start_time = Instant::now();
+    let mut result = find_and_interpret(db, position)
+        .unwrap_or_else(|| "Not inside a function body".to_string());
+    let duration = Instant::now() - start_time;
+    writeln!(result, "").unwrap();
+    writeln!(result, "----------------------").unwrap();
+    writeln!(result, "  Finished in {}s", duration.as_secs_f32()).unwrap();
+    result
+}
+
+fn find_and_interpret(db: &RootDatabase, position: FilePosition) -> Option<String> {
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(position.file_id);
+
+    let item = find_node_at_offset::<ast::Item>(source_file.syntax(), position.offset)?;
+    let def = match item {
+        ast::Item::Fn(it) => sema.to_def(&it)?,
+        _ => return None,
+    };
+    let span_formatter = |file_id, text_range: TextRange| {
+        let line_col = db.line_index(file_id).line_col(text_range.start());
+        let path = &db
+            .source_root(db.file_source_root(file_id))
+            .path_for_file(&file_id)
+            .map(|x| x.to_string());
+        let path = path.as_deref().unwrap_or("<unknown file>");
+        format!("file://{path}#{}:{}", line_col.line + 1, line_col.col)
+    };
+    match def.eval(db, span_formatter) {
+        Ok(_) => Some("pass".to_string()),
+        Err(e) => Some(e),
+    }
+}
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index d14cf83f0d7..3509dee0c96 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -56,6 +56,7 @@ mod typing;
 mod view_crate_graph;
 mod view_hir;
 mod view_mir;
+mod interpret_function;
 mod view_item_tree;
 mod shuffle_crate_graph;
 
@@ -317,6 +318,10 @@ impl Analysis {
         self.with_db(|db| view_mir::view_mir(db, position))
     }
 
+    pub fn interpret_function(&self, position: FilePosition) -> Cancellable<String> {
+        self.with_db(|db| interpret_function::interpret_function(db, position))
+    }
+
     pub fn view_item_tree(&self, file_id: FileId) -> Cancellable<String> {
         self.with_db(|db| view_item_tree::view_item_tree(db, file_id))
     }
diff --git a/crates/ide/src/static_index.rs b/crates/ide/src/static_index.rs
index 774b07775b9..7ce20e973bb 100644
--- a/crates/ide/src/static_index.rs
+++ b/crates/ide/src/static_index.rs
@@ -140,7 +140,6 @@ impl StaticIndex<'_> {
             documentation: true,
             keywords: true,
             format: crate::HoverDocFormat::Markdown,
-            interpret_tests: false,
         };
         let tokens = tokens.filter(|token| {
             matches!(
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index c24bdab78a9..f9288f01b53 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -574,6 +574,7 @@ pub struct LensConfig {
     // runnables
     pub run: bool,
     pub debug: bool,
+    pub interpret: bool,
 
     // implementations
     pub implementations: bool,
@@ -1423,6 +1424,9 @@ impl Config {
         LensConfig {
             run: self.data.lens_enable && self.data.lens_run_enable,
             debug: self.data.lens_enable && self.data.lens_debug_enable,
+            interpret: self.data.lens_enable
+                && self.data.lens_run_enable
+                && self.data.interpret_tests,
             implementations: self.data.lens_enable && self.data.lens_implementations_enable,
             method_refs: self.data.lens_enable && self.data.lens_references_method_enable,
             refs_adt: self.data.lens_enable && self.data.lens_references_adt_enable,
@@ -1481,7 +1485,6 @@ impl Config {
                 }
             },
             keywords: self.data.hover_documentation_keywords_enable,
-            interpret_tests: self.data.interpret_tests,
         }
     }
 
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 3c39f205e74..a5b9004d80f 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -163,6 +163,16 @@ pub(crate) fn handle_view_mir(
     Ok(res)
 }
 
+pub(crate) fn handle_interpret_function(
+    snap: GlobalStateSnapshot,
+    params: lsp_types::TextDocumentPositionParams,
+) -> Result<String> {
+    let _p = profile::span("handle_interpret_function");
+    let position = from_proto::file_position(&snap, params)?;
+    let res = snap.analysis.interpret_function(position)?;
+    Ok(res)
+}
+
 pub(crate) fn handle_view_file_text(
     snap: GlobalStateSnapshot,
     params: lsp_types::TextDocumentIdentifier,
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 75309466762..90c9b16ec2b 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -90,6 +90,14 @@ impl Request for ViewMir {
     const METHOD: &'static str = "rust-analyzer/viewMir";
 }
 
+pub enum InterpretFunction {}
+
+impl Request for InterpretFunction {
+    type Params = lsp_types::TextDocumentPositionParams;
+    type Result = String;
+    const METHOD: &'static str = "rust-analyzer/interpretFunction";
+}
+
 pub enum ViewFileText {}
 
 impl Request for ViewFileText {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 1c2b2627700..6f31c641222 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -665,6 +665,7 @@ impl GlobalState {
             .on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)
             .on::<lsp_ext::ViewHir>(handlers::handle_view_hir)
             .on::<lsp_ext::ViewMir>(handlers::handle_view_mir)
+            .on::<lsp_ext::InterpretFunction>(handlers::handle_interpret_function)
             .on::<lsp_ext::ViewFileText>(handlers::handle_view_file_text)
             .on::<lsp_ext::ViewCrateGraph>(handlers::handle_view_crate_graph)
             .on::<lsp_ext::ViewItemTree>(handlers::handle_view_item_tree)
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index b0b8d38cdc3..521db6b0ca9 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -1215,6 +1215,14 @@ pub(crate) fn code_lens(
                     data: None,
                 })
             }
+            if lens_config.interpret {
+                let command = command::interpret_single(&r);
+                acc.push(lsp_types::CodeLens {
+                    range: annotation_range,
+                    command: Some(command),
+                    data: None,
+                })
+            }
         }
         AnnotationKind::HasImpls { pos: file_range, data } => {
             if !client_commands_config.show_reference {
@@ -1359,6 +1367,15 @@ pub(crate) mod command {
         }
     }
 
+    pub(crate) fn interpret_single(_runnable: &lsp_ext::Runnable) -> lsp_types::Command {
+        lsp_types::Command {
+            title: "Interpret".into(),
+            command: "rust-analyzer.interpretFunction".into(),
+            // FIXME: use the `_runnable` here.
+            arguments: Some(vec![]),
+        }
+    }
+
     pub(crate) fn goto_location(
         snap: &GlobalStateSnapshot,
         nav: &NavigationTarget,
diff --git a/crates/test-utils/src/minicore.rs b/crates/test-utils/src/minicore.rs
index ca1dbf532c3..f403ef8ee03 100644
--- a/crates/test-utils/src/minicore.rs
+++ b/crates/test-utils/src/minicore.rs
@@ -11,6 +11,7 @@
 //!     add:
 //!     as_ref: sized
 //!     bool_impl: option, fn
+//!     cell: copy, drop
 //!     clone: sized
 //!     coerce_unsized: unsize
 //!     copy: clone
@@ -139,6 +140,52 @@ pub mod hash {
 }
 // endregion:hash
 
+// region:cell
+pub mod cell {
+    use crate::mem;
+
+    #[lang = "unsafe_cell"]
+    pub struct UnsafeCell<T: ?Sized> {
+        value: T,
+    }
+
+    impl<T> UnsafeCell<T> {
+        pub const fn new(value: T) -> UnsafeCell<T> {
+            UnsafeCell { value }
+        }
+
+        pub const fn get(&self) -> *mut T {
+            self as *const UnsafeCell<T> as *const T as *mut T
+        }
+    }
+
+    pub struct Cell<T: ?Sized> {
+        value: UnsafeCell<T>,
+    }
+
+    impl<T> Cell<T> {
+        pub const fn new(value: T) -> Cell<T> {
+            Cell { value: UnsafeCell::new(value) }
+        }
+
+        pub fn set(&self, val: T) {
+            let old = self.replace(val);
+            mem::drop(old);
+        }
+
+        pub fn replace(&self, val: T) -> T {
+            mem::replace(unsafe { &mut *self.value.get() }, val)
+        }
+    }
+
+    impl<T: Copy> Cell<T> {
+        pub fn get(&self) -> T {
+            unsafe { *self.value.get() }
+        }
+    }
+}
+// endregion:cell
+
 // region:clone
 pub mod clone {
     #[lang = "clone"]
@@ -220,6 +267,13 @@ pub mod mem {
     // endregion:manually_drop
 
     pub fn drop<T>(_x: T) {}
+    pub const fn replace<T>(dest: &mut T, src: T) -> T {
+        unsafe {
+            let result = *dest;
+            *dest = src;
+            result
+        }
+    }
 }
 // endregion:drop
 
@@ -710,6 +764,14 @@ pub mod option {
                 None => default,
             }
         }
+        // region:result
+        pub const fn ok_or<E>(self, err: E) -> Result<T, E> {
+            match self {
+                Some(v) => Ok(v),
+                None => Err(err),
+            }
+        }
+        // endregion:result
         // region:fn
         pub fn and_then<U, F>(self, f: F) -> Option<U>
         where
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index d748400b695..76080eca4e0 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: be2f663a78beb7bd
+lsp_ext.rs hash: 37ac44a0f507e05a
 
 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:
@@ -548,6 +548,18 @@ For debugging or when working on rust-analyzer itself.
 Returns a textual representation of the MIR of the function containing the cursor.
 For debugging or when working on rust-analyzer itself.
 
+## Interpret Function
+
+**Method:** `rust-analyzer/interpretFunction`
+
+**Request:** `TextDocumentPositionParams`
+
+**Response:** `string`
+
+Tries to evaluate the function using internal rust analyzer knowledge, without compiling
+the code. Currently evaluates the function under cursor, but will give a runnable in
+future. Highly experimental.
+
 ## View File Text
 
 **Method:** `rust-analyzer/viewFileText`
diff --git a/editors/code/package.json b/editors/code/package.json
index 79e2c62e823..d46c248cd49 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -120,6 +120,11 @@
                 "title": "View Mir",
                 "category": "rust-analyzer (debug command)"
             },
+            {
+                "command": "rust-analyzer.interpretFunction",
+                "title": "Interpret Function",
+                "category": "rust-analyzer (debug command)"
+            },
             {
                 "command": "rust-analyzer.viewFileText",
                 "title": "View File Text (as seen by the server)",
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 0d91548b9b3..2d5272d199d 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -422,8 +422,20 @@ export function syntaxTree(ctx: CtxInit): Cmd {
 function viewHirOrMir(ctx: CtxInit, xir: "hir" | "mir"): Cmd {
     const viewXir = xir === "hir" ? "viewHir" : "viewMir";
     const requestType = xir === "hir" ? ra.viewHir : ra.viewMir;
+    const uri = `rust-analyzer-${xir}://${viewXir}/${xir}.rs`;
+    const scheme = `rust-analyzer-${xir}`;
+    return viewFileUsingTextDocumentContentProvider(ctx, requestType, uri, scheme, true);
+}
+
+function viewFileUsingTextDocumentContentProvider(
+    ctx: CtxInit,
+    requestType: lc.RequestType<lc.TextDocumentPositionParams, string, void>,
+    uri: string,
+    scheme: string,
+    shouldUpdate: boolean
+): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
-        readonly uri = vscode.Uri.parse(`rust-analyzer-${xir}://${viewXir}/${xir}.rs`);
+        readonly uri = vscode.Uri.parse(uri);
         readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
         constructor() {
             vscode.workspace.onDidChangeTextDocument(
@@ -439,14 +451,14 @@ function viewHirOrMir(ctx: CtxInit, xir: "hir" | "mir"): Cmd {
         }
 
         private onDidChangeTextDocument(event: vscode.TextDocumentChangeEvent) {
-            if (isRustDocument(event.document)) {
+            if (isRustDocument(event.document) && shouldUpdate) {
                 // We need to order this after language server updates, but there's no API for that.
                 // Hence, good old sleep().
                 void sleep(10).then(() => this.eventEmitter.fire(this.uri));
             }
         }
         private onDidChangeActiveTextEditor(editor: vscode.TextEditor | undefined) {
-            if (editor && isRustEditor(editor)) {
+            if (editor && isRustEditor(editor) && shouldUpdate) {
                 this.eventEmitter.fire(this.uri);
             }
         }
@@ -473,9 +485,7 @@ function viewHirOrMir(ctx: CtxInit, xir: "hir" | "mir"): Cmd {
         }
     })();
 
-    ctx.pushExtCleanup(
-        vscode.workspace.registerTextDocumentContentProvider(`rust-analyzer-${xir}`, tdcp)
-    );
+    ctx.pushExtCleanup(vscode.workspace.registerTextDocumentContentProvider(scheme, tdcp));
 
     return async () => {
         const document = await vscode.workspace.openTextDocument(tdcp.uri);
@@ -501,6 +511,20 @@ export function viewMir(ctx: CtxInit): Cmd {
     return viewHirOrMir(ctx, "mir");
 }
 
+// Opens the virtual file that will show the MIR of the function containing the cursor position
+//
+// The contents of the file come from the `TextDocumentContentProvider`
+export function interpretFunction(ctx: CtxInit): Cmd {
+    const uri = `rust-analyzer-interpret-function://interpretFunction/result.log`;
+    return viewFileUsingTextDocumentContentProvider(
+        ctx,
+        ra.interpretFunction,
+        uri,
+        `rust-analyzer-interpret-function`,
+        false
+    );
+}
+
 export function viewFileText(ctx: CtxInit): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
         readonly uri = vscode.Uri.parse("rust-analyzer-file-text://viewFileText/file.rs");
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 952dbb3e88a..754d43618a4 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -64,6 +64,9 @@ export const viewHir = new lc.RequestType<lc.TextDocumentPositionParams, string,
 export const viewMir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(
     "rust-analyzer/viewMir"
 );
+export const interpretFunction = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(
+    "rust-analyzer/interpretFunction"
+);
 export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>(
     "rust-analyzer/viewItemTree"
 );
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 6c990f804b0..7ae8fa8ca28 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -159,6 +159,7 @@ function createCommands(): Record<string, CommandFactory> {
         syntaxTree: { enabled: commands.syntaxTree },
         viewHir: { enabled: commands.viewHir },
         viewMir: { enabled: commands.viewMir },
+        interpretFunction: { enabled: commands.interpretFunction },
         viewFileText: { enabled: commands.viewFileText },
         viewItemTree: { enabled: commands.viewItemTree },
         viewCrateGraph: { enabled: commands.viewCrateGraph },
-- 
cgit 1.4.1-3-g733a5


From a64626d99e656cd2b229d9e0dfcefb96e58dd9f2 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 2 May 2023 08:52:08 +0200
Subject: Highlight closure captures when cursor is on pipe

---
 crates/hir-ty/src/infer/closure.rs  |   7 +-
 crates/hir/src/lib.rs               |  24 +++++-
 crates/ide/src/highlight_related.rs | 158 +++++++++++++++++++++++-------------
 crates/rust-analyzer/src/config.rs  |   3 +
 crates/rust-analyzer/src/lsp_ext.rs |   2 +-
 crates/test-utils/src/lib.rs        |   2 +-
 docs/dev/lsp-extensions.md          |   2 +-
 docs/user/generated_config.adoc     |   5 ++
 editors/code/package.json           |   5 ++
 editors/code/src/lsp_ext.ts         |   9 +-
 10 files changed, 149 insertions(+), 68 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/hir-ty/src/infer/closure.rs b/crates/hir-ty/src/infer/closure.rs
index d3acbf7b404..2c3e54bf191 100644
--- a/crates/hir-ty/src/infer/closure.rs
+++ b/crates/hir-ty/src/infer/closure.rs
@@ -115,9 +115,10 @@ impl InferenceContext<'_> {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct HirPlace {
-    pub(crate) local: BindingId,
+    pub local: BindingId,
     pub(crate) projections: Vec<ProjectionElem<Infallible, Ty>>,
 }
+
 impl HirPlace {
     fn ty(&self, ctx: &mut InferenceContext<'_>) -> Ty {
         let mut ty = ctx.table.resolve_completely(ctx.result[self.local].clone());
@@ -161,6 +162,10 @@ pub struct CapturedItem {
 }
 
 impl CapturedItem {
+    pub fn local(&self) -> BindingId {
+        self.place.local
+    }
+
     pub fn display_kind(&self) -> &'static str {
         match self.kind {
             CaptureKind::ByRef(k) => match k {
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 145506a89df..f955b74d0e5 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -3209,11 +3209,11 @@ impl Closure {
         self.clone().as_ty().display(db).with_closure_style(ClosureStyle::ImplFn).to_string()
     }
 
-    pub fn captured_items(&self, db: &dyn HirDatabase) -> Vec<hir_ty::CapturedItem> {
+    pub fn captured_items(&self, db: &dyn HirDatabase) -> Vec<ClosureCapture> {
         let owner = db.lookup_intern_closure((self.id).into()).0;
         let infer = &db.infer(owner);
         let info = infer.closure_info(&self.id);
-        info.0.clone()
+        info.0.iter().cloned().map(|capture| ClosureCapture { owner, capture }).collect()
     }
 
     pub fn fn_trait(&self, db: &dyn HirDatabase) -> FnTrait {
@@ -3224,6 +3224,26 @@ impl Closure {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ClosureCapture {
+    owner: DefWithBodyId,
+    capture: hir_ty::CapturedItem,
+}
+
+impl ClosureCapture {
+    pub fn local(&self) -> Local {
+        Local { parent: self.owner, binding_id: self.capture.local() }
+    }
+
+    pub fn display_kind(&self) -> &'static str {
+        self.capture.display_kind()
+    }
+
+    pub fn display_place(&self, owner: ClosureId, db: &dyn HirDatabase) -> String {
+        self.capture.display_place(owner, db)
+    }
+}
+
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Type {
     env: Arc<TraitEnvironment>,
diff --git a/crates/ide/src/highlight_related.rs b/crates/ide/src/highlight_related.rs
index d88ffd25c40..b71bdf8c0f3 100644
--- a/crates/ide/src/highlight_related.rs
+++ b/crates/ide/src/highlight_related.rs
@@ -1,6 +1,6 @@
 use hir::Semantics;
 use ide_db::{
-    base_db::{FileId, FilePosition},
+    base_db::{FileId, FilePosition, FileRange},
     defs::{Definition, IdentClass},
     helpers::pick_best_token,
     search::{FileReference, ReferenceCategory, SearchScope},
@@ -30,6 +30,7 @@ pub struct HighlightRelatedConfig {
     pub references: bool,
     pub exit_points: bool,
     pub break_points: bool,
+    pub closure_captures: bool,
     pub yield_points: bool,
 }
 
@@ -53,11 +54,12 @@ pub(crate) fn highlight_related(
 
     let token = pick_best_token(syntax.token_at_offset(offset), |kind| match kind {
         T![?] => 4, // prefer `?` when the cursor is sandwiched like in `await$0?`
-        T![->] => 3,
+        T![->] | T![|] => 3,
         kind if kind.is_keyword() => 2,
         IDENT | INT_NUMBER => 1,
         _ => 0,
     })?;
+    // most if not all of these should be re-implemented with information seeded from hir
     match token.kind() {
         T![?] if config.exit_points && token.parent().and_then(ast::TryExpr::cast).is_some() => {
             highlight_exit_points(sema, token)
@@ -70,11 +72,64 @@ pub(crate) fn highlight_related(
         T![break] | T![loop] | T![while] | T![continue] if config.break_points => {
             highlight_break_points(token)
         }
+        T![|] if config.closure_captures => highlight_closure_captures(
+            sema,
+            token.parent_ancestors().nth(1).and_then(ast::ClosureExpr::cast)?,
+            file_id,
+        ),
+        T![move] if config.closure_captures => highlight_closure_captures(
+            sema,
+            token.parent().and_then(ast::ClosureExpr::cast)?,
+            file_id,
+        ),
         _ if config.references => highlight_references(sema, &syntax, token, file_id),
         _ => None,
     }
 }
 
+fn highlight_closure_captures(
+    sema: &Semantics<'_, RootDatabase>,
+    node: ast::ClosureExpr,
+    file_id: FileId,
+) -> Option<Vec<HighlightedRange>> {
+    let search_range = node.body()?.syntax().text_range();
+    let ty = &sema.type_of_expr(&node.into())?.original;
+    let c = ty.as_closure()?;
+    Some(
+        c.captured_items(sema.db)
+            .into_iter()
+            .map(|capture| capture.local())
+            .flat_map(|local| {
+                let usages = Definition::Local(local)
+                    .usages(sema)
+                    .set_scope(Some(SearchScope::file_range(FileRange {
+                        file_id,
+                        range: search_range,
+                    })))
+                    .include_self_refs()
+                    .all()
+                    .references
+                    .remove(&file_id)
+                    .into_iter()
+                    .flatten()
+                    .map(|FileReference { category, range, .. }| HighlightedRange {
+                        range,
+                        category,
+                    });
+                let category = local.is_mut(sema.db).then_some(ReferenceCategory::Write);
+                local
+                    .sources(sema.db)
+                    .into_iter()
+                    .map(|x| x.to_nav(sema.db))
+                    .filter(|decl| decl.file_id == file_id)
+                    .filter_map(|decl| decl.focus_range)
+                    .map(move |range| HighlightedRange { range, category })
+                    .chain(usages)
+            })
+            .collect(),
+    )
+}
+
 fn highlight_references(
     sema: &Semantics<'_, RootDatabase>,
     node: &SyntaxNode,
@@ -93,10 +148,7 @@ fn highlight_references(
                 .remove(&file_id)
         })
         .flatten()
-        .map(|FileReference { category: access, range, .. }| HighlightedRange {
-            range,
-            category: access,
-        });
+        .map(|FileReference { category, range, .. }| HighlightedRange { range, category });
     let mut res = FxHashSet::default();
     for &def in &defs {
         match def {
@@ -352,16 +404,17 @@ mod tests {
 
     use super::*;
 
+    const ENABLED_CONFIG: HighlightRelatedConfig = HighlightRelatedConfig {
+        break_points: true,
+        exit_points: true,
+        references: true,
+        closure_captures: true,
+        yield_points: true,
+    };
+
     #[track_caller]
     fn check(ra_fixture: &str) {
-        let config = HighlightRelatedConfig {
-            break_points: true,
-            exit_points: true,
-            references: true,
-            yield_points: true,
-        };
-
-        check_with_config(ra_fixture, config);
+        check_with_config(ra_fixture, ENABLED_CONFIG);
     }
 
     #[track_caller]
@@ -1086,12 +1139,7 @@ fn function(field: u32) {
 
     #[test]
     fn test_hl_disabled_ref_local() {
-        let config = HighlightRelatedConfig {
-            references: false,
-            break_points: true,
-            exit_points: true,
-            yield_points: true,
-        };
+        let config = HighlightRelatedConfig { references: false, ..ENABLED_CONFIG };
 
         check_with_config(
             r#"
@@ -1106,12 +1154,7 @@ fn foo() {
 
     #[test]
     fn test_hl_disabled_ref_local_preserved_break() {
-        let config = HighlightRelatedConfig {
-            references: false,
-            break_points: true,
-            exit_points: true,
-            yield_points: true,
-        };
+        let config = HighlightRelatedConfig { references: false, ..ENABLED_CONFIG };
 
         check_with_config(
             r#"
@@ -1146,12 +1189,7 @@ fn foo() {
 
     #[test]
     fn test_hl_disabled_ref_local_preserved_yield() {
-        let config = HighlightRelatedConfig {
-            references: false,
-            break_points: true,
-            exit_points: true,
-            yield_points: true,
-        };
+        let config = HighlightRelatedConfig { references: false, ..ENABLED_CONFIG };
 
         check_with_config(
             r#"
@@ -1182,12 +1220,7 @@ async fn foo() {
 
     #[test]
     fn test_hl_disabled_ref_local_preserved_exit() {
-        let config = HighlightRelatedConfig {
-            references: false,
-            break_points: true,
-            exit_points: true,
-            yield_points: true,
-        };
+        let config = HighlightRelatedConfig { references: false, ..ENABLED_CONFIG };
 
         check_with_config(
             r#"
@@ -1225,12 +1258,7 @@ fn foo() ->$0 i32 {
 
     #[test]
     fn test_hl_disabled_break() {
-        let config = HighlightRelatedConfig {
-            references: true,
-            break_points: false,
-            exit_points: true,
-            yield_points: true,
-        };
+        let config = HighlightRelatedConfig { break_points: false, ..ENABLED_CONFIG };
 
         check_with_config(
             r#"
@@ -1246,12 +1274,7 @@ fn foo() {
 
     #[test]
     fn test_hl_disabled_yield() {
-        let config = HighlightRelatedConfig {
-            references: true,
-            break_points: true,
-            exit_points: true,
-            yield_points: false,
-        };
+        let config = HighlightRelatedConfig { yield_points: false, ..ENABLED_CONFIG };
 
         check_with_config(
             r#"
@@ -1265,12 +1288,7 @@ async$0 fn foo() {
 
     #[test]
     fn test_hl_disabled_exit() {
-        let config = HighlightRelatedConfig {
-            references: true,
-            break_points: true,
-            exit_points: false,
-            yield_points: true,
-        };
+        let config = HighlightRelatedConfig { exit_points: false, ..ENABLED_CONFIG };
 
         check_with_config(
             r#"
@@ -1411,6 +1429,34 @@ impl Trait for () {
     type Output$0 = ();
       // ^^^^^^
 }
+"#,
+        );
+    }
+
+    #[test]
+    fn test_closure_capture_pipe() {
+        check(
+            r#"
+fn f() {
+    let x = 1;
+    //  ^
+    let c = $0|y| x + y;
+    //          ^ read
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn test_closure_capture_move() {
+        check(
+            r#"
+fn f() {
+    let x = 1;
+    //  ^
+    let c = move$0 |y| x + y;
+    //               ^ read
+}
 "#,
         );
     }
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index f9288f01b53..aa6beb6351a 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -281,6 +281,8 @@ config_data! {
 
         /// Enables highlighting of related references while the cursor is on `break`, `loop`, `while`, or `for` keywords.
         highlightRelated_breakPoints_enable: bool = "true",
+        /// Enables highlighting of all captures of a closure while the cursor is on the `|` or move keyword of a closure.
+        highlightRelated_closureCaptures_enable: bool = "true",
         /// Enables highlighting of all exit points while the cursor is on any `return`, `?`, `fn`, or return type arrow (`->`).
         highlightRelated_exitPoints_enable: bool = "true",
         /// Enables highlighting of related references while the cursor is on any identifier.
@@ -1554,6 +1556,7 @@ impl Config {
             break_points: self.data.highlightRelated_breakPoints_enable,
             exit_points: self.data.highlightRelated_exitPoints_enable,
             yield_points: self.data.highlightRelated_yieldPoints_enable,
+            closure_captures: self.data.highlightRelated_closureCaptures_enable,
         }
     }
 
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 90c9b16ec2b..625ffe0763c 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -434,7 +434,7 @@ pub enum HoverRequest {}
 impl Request for HoverRequest {
     type Params = HoverParams;
     type Result = Option<Hover>;
-    const METHOD: &'static str = "textDocument/hover";
+    const METHOD: &'static str = lsp_types::request::HoverRequest::METHOD;
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
diff --git a/crates/test-utils/src/lib.rs b/crates/test-utils/src/lib.rs
index 5abadaad629..fd3e68e2d2c 100644
--- a/crates/test-utils/src/lib.rs
+++ b/crates/test-utils/src/lib.rs
@@ -95,7 +95,7 @@ fn try_extract_range(text: &str) -> Option<(TextRange, String)> {
     Some((TextRange::new(start, end), text))
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 pub enum RangeOrOffset {
     Range(TextRange),
     Offset(TextSize),
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 76080eca4e0..42f58fee30e 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: 37ac44a0f507e05a
+lsp_ext.rs hash: 31ca513a249753ab
 
 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/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index e9b3d45a373..aad6969671c 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -352,6 +352,11 @@ Controls file watching implementation.
 --
 Enables highlighting of related references while the cursor is on `break`, `loop`, `while`, or `for` keywords.
 --
+[[rust-analyzer.highlightRelated.closureCaptures.enable]]rust-analyzer.highlightRelated.closureCaptures.enable (default: `true`)::
++
+--
+Enables highlighting of all captures of a closure while the cursor is on the `|` or move keyword of a closure.
+--
 [[rust-analyzer.highlightRelated.exitPoints.enable]]rust-analyzer.highlightRelated.exitPoints.enable (default: `true`)::
 +
 --
diff --git a/editors/code/package.json b/editors/code/package.json
index d46c248cd49..f36e34b6a1b 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -886,6 +886,11 @@
                     "default": true,
                     "type": "boolean"
                 },
+                "rust-analyzer.highlightRelated.closureCaptures.enable": {
+                    "markdownDescription": "Enables highlighting of all captures of a closure while the cursor is on the `|` or move keyword of a closure.",
+                    "default": true,
+                    "type": "boolean"
+                },
                 "rust-analyzer.highlightRelated.exitPoints.enable": {
                     "markdownDescription": "Enables highlighting of all exit points while the cursor is on any `return`, `?`, `fn`, or return type arrow (`->`).",
                     "default": true,
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 754d43618a4..82955acf25e 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -10,12 +10,9 @@ export const hover = new lc.RequestType<
     HoverParams,
     (lc.Hover & { actions: CommandLinkGroup[] }) | null,
     void
->("textDocument/hover");
-export type HoverParams = { position: lc.Position | lc.Range } & Omit<
-    lc.TextDocumentPositionParams,
-    "position"
-> &
-    lc.WorkDoneProgressParams;
+>(lc.HoverRequest.method);
+export type HoverParams = { position: lc.Position | lc.Range } & Omit<lc.HoverParams, "position">;
+
 export type CommandLink = {
     /**
      * A tooltip for the command, when represented in the UI.
-- 
cgit 1.4.1-3-g733a5


From 795a1cbe89bc2428937aec828963fe64a2c8d4d9 Mon Sep 17 00:00:00 2001
From: bruno-ortiz <brunortiz11@gmail.com>
Date: Fri, 25 Feb 2022 21:37:55 -0300
Subject: Creating rust dependencies tree view

---
 editors/code/package.json                 |  18 +++-
 editors/code/src/commands.ts              |  41 +++++++-
 editors/code/src/ctx.ts                   |  55 +++++++----
 editors/code/src/dependencies_provider.ts | 151 ++++++++++++++++++++++++++++++
 editors/code/src/main.ts                  | 102 ++++++++++----------
 editors/code/src/toolchain.ts             | 113 ++++++++++++++++++++++
 6 files changed, 410 insertions(+), 70 deletions(-)
 create mode 100644 editors/code/src/dependencies_provider.ts

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index f36e34b6a1b..5e2a1c69e94 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -284,6 +284,14 @@
                 "command": "rust-analyzer.clearFlycheck",
                 "title": "Clear flycheck diagnostics",
                 "category": "rust-analyzer"
+            },
+            {
+                "command": "rust-analyzer.openFile",
+                "title": "Open File"
+            },
+            {
+                "command": "rust-analyzer.revealDependency",
+                "title": "Reveal File"
             }
         ],
         "keybindings": [
@@ -1956,6 +1964,14 @@
                 }
             ]
         },
+        "views": {
+            "explorer": [
+                {
+                    "id": "rustDependencies",
+                    "name": "Rust Dependencies"
+                }
+            ]
+        },
         "jsonValidation": [
             {
                 "fileMatch": "rust-project.json",
@@ -1963,4 +1979,4 @@
             }
         ]
     }
-}
+}
\ No newline at end of file
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 2d5272d199d..e5aa06025b2 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -8,10 +8,11 @@ import { applySnippetWorkspaceEdit, applySnippetTextEdits } from "./snippets";
 import { spawnSync } from "child_process";
 import { RunnableQuickPick, selectRunnable, createTask, createArgs } from "./run";
 import { AstInspector } from "./ast_inspector";
-import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor } from "./util";
+import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor, RustEditor } from './util';
 import { startDebugSession, makeDebugConfig } from "./debug";
 import { LanguageClient } from "vscode-languageclient/node";
 import { LINKED_COMMANDS } from "./client";
+import { DependencyId } from './dependencies_provider';
 
 export * from "./ast_inspector";
 export * from "./run";
@@ -266,6 +267,44 @@ export function openCargoToml(ctx: CtxInit): Cmd {
     };
 }
 
+export function openFile(_ctx: CtxInit): Cmd {
+    return async (uri: vscode.Uri) => {
+        try {
+            await vscode.window.showTextDocument(uri);
+        } catch (err) {
+            await vscode.window.showErrorMessage(err.message);
+        }
+    };
+}
+
+export function revealDependency(ctx: CtxInit): Cmd {
+    return async (editor: RustEditor) => {
+        const rootPath = vscode.workspace.workspaceFolders![0].uri.fsPath;
+        const documentPath = editor.document.uri.fsPath;
+        if (documentPath.startsWith(rootPath)) return;
+        const dep = ctx.dependencies.getDependency(documentPath);
+        if (dep) {
+            await ctx.treeView.reveal(dep, { select: true, expand: true });
+        } else {
+            let documentPath = editor.document.uri.fsPath;
+            const parentChain: DependencyId[] = [{ id: documentPath.toLowerCase() }];
+            do {
+                documentPath = path.dirname(documentPath);
+                parentChain.push({ id: documentPath.toLowerCase() });
+            }
+            while (!ctx.dependencies.contains(documentPath));
+            parentChain.reverse();
+            for (const idx in parentChain) {
+                await ctx.treeView.reveal(parentChain[idx], { select: true, expand: true });
+            }
+        }
+    };
+}
+
+export async function execRevealDependency(e: RustEditor): Promise<void> {
+    await vscode.commands.executeCommand('rust-analyzer.revealDependency', e);
+}
+
 export function ssr(ctx: CtxInit): Cmd {
     return async () => {
         const editor = vscode.window.activeTextEditor;
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 567b9216bc1..e6829ac4b9e 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -3,8 +3,8 @@ import * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 import * as path from "path";
 
-import { Config, prepareVSCodeConfig } from "./config";
-import { createClient } from "./client";
+import {Config, prepareVSCodeConfig} from './config';
+import {createClient} from './client';
 import {
     executeDiscoverProject,
     isRustDocument,
@@ -12,11 +12,13 @@ import {
     LazyOutputChannel,
     log,
     RustEditor,
-} from "./util";
-import { ServerStatusParams } from "./lsp_ext";
-import { PersistentState } from "./persistent_state";
-import { bootstrap } from "./bootstrap";
-import { ExecOptions } from "child_process";
+} from './util';
+import {ServerStatusParams} from './lsp_ext';
+import {Dependency, DependencyFile, RustDependenciesProvider, DependencyId} from './dependencies_provider';
+import {execRevealDependency} from './commands';
+import {PersistentState} from "./persistent_state";
+import {bootstrap} from "./bootstrap";
+import {ExecOptions} from "child_process";
 
 // We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
 // only those are in use. We use "Empty" to represent these scenarios
@@ -25,12 +27,12 @@ import { ExecOptions } from "child_process";
 export type Workspace =
     | { kind: "Empty" }
     | {
-          kind: "Workspace Folder";
-      }
+    kind: "Workspace Folder";
+}
     | {
-          kind: "Detached Files";
-          files: vscode.TextDocument[];
-      };
+    kind: "Detached Files";
+    files: vscode.TextDocument[];
+};
 
 export function fetchWorkspace(): Workspace {
     const folders = (vscode.workspace.workspaceFolders || []).filter(
@@ -42,12 +44,12 @@ export function fetchWorkspace(): Workspace {
 
     return folders.length === 0
         ? rustDocuments.length === 0
-            ? { kind: "Empty" }
+            ? {kind: "Empty"}
             : {
-                  kind: "Detached Files",
-                  files: rustDocuments,
-              }
-        : { kind: "Workspace Folder" };
+                kind: "Detached Files",
+                files: rustDocuments,
+            }
+        : {kind: "Workspace Folder"};
 }
 
 export async function discoverWorkspace(
@@ -84,6 +86,8 @@ export class Ctx {
     private commandFactories: Record<string, CommandFactory>;
     private commandDisposables: Disposable[];
     private unlinkedFiles: vscode.Uri[];
+    readonly dependencies: RustDependenciesProvider;
+    readonly treeView: vscode.TreeView<Dependency | DependencyFile | DependencyId>;
 
     get client() {
         return this._client;
@@ -92,7 +96,9 @@ export class Ctx {
     constructor(
         readonly extCtx: vscode.ExtensionContext,
         commandFactories: Record<string, CommandFactory>,
-        workspace: Workspace
+        workspace: Workspace,
+        dependencies: RustDependenciesProvider,
+        treeView: vscode.TreeView<Dependency | DependencyFile | DependencyId>
     ) {
         extCtx.subscriptions.push(this);
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
@@ -101,6 +107,8 @@ export class Ctx {
         this.commandDisposables = [];
         this.commandFactories = commandFactories;
         this.unlinkedFiles = [];
+        this.dependencies = dependencies;
+        this.treeView = treeView;
 
         this.state = new PersistentState(extCtx.globalState);
         this.config = new Config(extCtx);
@@ -109,6 +117,13 @@ export class Ctx {
         this.setServerStatus({
             health: "stopped",
         });
+        vscode.window.onDidChangeActiveTextEditor(e => {
+            if (e && isRustEditor(e)) {
+                execRevealDependency(e).catch(reason => {
+                    void vscode.window.showErrorMessage(`Dependency error: ${reason}`);
+                });
+            }
+        });
     }
 
     dispose() {
@@ -174,7 +189,7 @@ export class Ctx {
             const newEnv = Object.assign({}, process.env, this.config.serverExtraEnv);
             const run: lc.Executable = {
                 command: this._serverPath,
-                options: { env: newEnv },
+                options: {env: newEnv},
             };
             const serverOptions = {
                 run,
@@ -348,6 +363,7 @@ export class Ctx {
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
                 statusBar.command = "rust-analyzer.stopServer";
+                this.dependencies.refresh();
                 break;
             case "warning":
                 if (status.message) {
@@ -410,4 +426,5 @@ export class Ctx {
 export interface Disposable {
     dispose(): void;
 }
+
 export type Cmd = (...args: any[]) => unknown;
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
new file mode 100644
index 00000000000..0f2e5e5ea07
--- /dev/null
+++ b/editors/code/src/dependencies_provider.ts
@@ -0,0 +1,151 @@
+import * as vscode from 'vscode';
+import * as fspath from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { activeToolchain, Cargo, Crate, getRustcVersion } from './toolchain';
+
+const debugOutput = vscode.window.createOutputChannel("Debug");
+
+export class RustDependenciesProvider implements vscode.TreeDataProvider<Dependency | DependencyFile>{
+  cargo: Cargo;
+  dependenciesMap: { [id: string]: Dependency | DependencyFile };
+
+  constructor(
+    private readonly workspaceRoot: string,
+  ) {
+    this.cargo = new Cargo(this.workspaceRoot || '.', debugOutput);
+    this.dependenciesMap = {};
+  }
+
+  private _onDidChangeTreeData: vscode.EventEmitter<Dependency | DependencyFile | undefined | null | void> = new vscode.EventEmitter<Dependency | undefined | null | void>();
+
+  readonly onDidChangeTreeData: vscode.Event<Dependency | DependencyFile | undefined | null | void> = this._onDidChangeTreeData.event;
+
+
+  getDependency(filePath: string): Dependency | DependencyFile | undefined {
+    return this.dependenciesMap[filePath.toLowerCase()];
+  }
+
+  contains(filePath: string): boolean {
+    return filePath.toLowerCase() in this.dependenciesMap;
+  }
+
+  refresh(): void {
+    this._onDidChangeTreeData.fire();
+  }
+
+  getParent?(element: Dependency | DependencyFile): vscode.ProviderResult<Dependency | DependencyFile> {
+    if (element instanceof Dependency) return undefined;
+    return element.parent;
+  }
+
+  getTreeItem(element: Dependency | DependencyFile): vscode.TreeItem | Thenable<vscode.TreeItem> {
+    if (element.id! in this.dependenciesMap) return this.dependenciesMap[element.id!];
+    return element;
+  }
+
+  getChildren(element?: Dependency | DependencyFile): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
+    return new Promise((resolve, _reject) => {
+      if (!this.workspaceRoot) {
+        void vscode.window.showInformationMessage('No dependency in empty workspace');
+        return Promise.resolve([]);
+      }
+
+      if (element) {
+        const files = fs.readdirSync(element.dependencyPath).map(fileName => {
+          const filePath = fspath.join(element.dependencyPath, fileName);
+          const collapsibleState = fs.lstatSync(filePath).isDirectory() ?
+            vscode.TreeItemCollapsibleState.Collapsed :
+            vscode.TreeItemCollapsibleState.None;
+          const dep = new DependencyFile(
+            fileName,
+            filePath,
+            element,
+            collapsibleState
+          );
+          this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
+          return dep;
+        });
+        return resolve(
+          files
+        );
+      } else {
+        return resolve(this.getRootDependencies());
+      }
+    });
+  }
+
+  private async getRootDependencies(): Promise<Dependency[]> {
+    const registryDir = fspath.join(os.homedir(), '.cargo', 'registry', 'src');
+    const basePath = fspath.join(registryDir, fs.readdirSync(registryDir)[0]);
+    const deps = await this.getDepsInCartoTree(basePath);
+    const stdlib = await this.getStdLib();
+    return [stdlib].concat(deps);
+  }
+
+  private async getStdLib(): Promise<Dependency> {
+    const toolchain = await activeToolchain();
+    const rustVersion = await getRustcVersion(os.homedir());
+    const stdlibPath = fspath.join(os.homedir(), '.rustup', 'toolchains', toolchain, 'lib', 'rustlib', 'src', 'rust', 'library');
+    return new Dependency(
+      "stdlib",
+      rustVersion,
+      stdlibPath,
+      vscode.TreeItemCollapsibleState.Collapsed
+    );
+  }
+
+  private async getDepsInCartoTree(basePath: string): Promise<Dependency[]> {
+    const crates: Crate[] = await this.cargo.crates();
+    const toDep = (moduleName: string, version: string): Dependency => {
+      const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
+      return new Dependency(
+        moduleName,
+        version,
+        cratePath,
+        vscode.TreeItemCollapsibleState.Collapsed
+      );
+    };
+
+    const deps = crates.map(crate => {
+      const dep = toDep(crate.name, crate.version);
+      this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
+      return dep;
+    });
+    return deps;
+  }
+}
+
+
+export class Dependency extends vscode.TreeItem {
+  constructor(
+    public readonly label: string,
+    private version: string,
+    readonly dependencyPath: string,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState
+  ) {
+    super(label, collapsibleState);
+    this.tooltip = `${this.label}-${this.version}`;
+    this.description = this.version;
+    this.resourceUri = vscode.Uri.file(dependencyPath);
+  }
+}
+
+export class DependencyFile extends vscode.TreeItem {
+
+  constructor(
+    readonly label: string,
+    readonly dependencyPath: string,
+    readonly parent: Dependency | DependencyFile,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState
+  ) {
+    super(vscode.Uri.file(dependencyPath), collapsibleState);
+    const isDir = fs.lstatSync(this.dependencyPath).isDirectory();
+    this.id = this.dependencyPath.toLowerCase();
+    if (!isDir) {
+      this.command = { command: 'rust-analyzer.openFile', title: "Open File", arguments: [vscode.Uri.file(this.dependencyPath)], };
+    }
+  }
+}
+
+export type DependencyId = { id: string };
\ No newline at end of file
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 7ae8fa8ca28..62b2e7a2771 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -2,10 +2,10 @@ import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
 
 import * as commands from "./commands";
-import { CommandFactory, Ctx, fetchWorkspace } from "./ctx";
+import {CommandFactory, Ctx, fetchWorkspace} from "./ctx";
 import * as diagnostics from "./diagnostics";
-import { activateTaskProvider } from "./tasks";
-import { setContextValue } from "./util";
+import {activateTaskProvider} from "./tasks";
+import {setContextValue} from "./util";
 
 const RUST_PROJECT_CONTEXT_NAME = "inRustProject";
 
@@ -24,11 +24,12 @@ export async function activate(
         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);
     }
 
     const ctx = new Ctx(context, createCommands(), fetchWorkspace());
@@ -118,7 +119,7 @@ function createCommands(): Record<string, CommandFactory> {
     return {
         onEnter: {
             enabled: commands.onEnter,
-            disabled: (_) => () => vscode.commands.executeCommand("default:type", { text: "\n" }),
+            disabled: (_) => () => vscode.commands.executeCommand("default:type", {text: "\n"}),
         },
         restartServer: {
             enabled: (ctx) => async () => {
@@ -144,51 +145,54 @@ function createCommands(): Record<string, CommandFactory> {
                     health: "stopped",
                 });
             },
-            disabled: (_) => async () => {},
+            disabled: (_) => async () => {
+            },
         },
 
-        analyzerStatus: { enabled: commands.analyzerStatus },
-        memoryUsage: { enabled: commands.memoryUsage },
-        shuffleCrateGraph: { enabled: commands.shuffleCrateGraph },
-        reloadWorkspace: { enabled: commands.reloadWorkspace },
-        rebuildProcMacros: { enabled: commands.rebuildProcMacros },
-        addProject: { enabled: commands.addProject },
-        matchingBrace: { enabled: commands.matchingBrace },
-        joinLines: { enabled: commands.joinLines },
-        parentModule: { enabled: commands.parentModule },
-        syntaxTree: { enabled: commands.syntaxTree },
-        viewHir: { enabled: commands.viewHir },
-        viewMir: { enabled: commands.viewMir },
+        analyzerStatus: {enabled: commands.analyzerStatus},
+        memoryUsage: {enabled: commands.memoryUsage},
+        shuffleCrateGraph: {enabled: commands.shuffleCrateGraph},
+        reloadWorkspace: {enabled: commands.reloadWorkspace},
+        rebuildProcMacros: {enabled: commands.rebuildProcMacros},
+        addProject: {enabled: commands.addProject},
+        matchingBrace: {enabled: commands.matchingBrace},
+        joinLines: {enabled: commands.joinLines},
+        parentModule: {enabled: commands.parentModule},
+        syntaxTree: {enabled: commands.syntaxTree},
+        viewHir: {enabled: commands.viewHir},
+        viewMir: {enabled: commands.viewMir},
         interpretFunction: { enabled: commands.interpretFunction },
-        viewFileText: { enabled: commands.viewFileText },
-        viewItemTree: { enabled: commands.viewItemTree },
-        viewCrateGraph: { enabled: commands.viewCrateGraph },
-        viewFullCrateGraph: { enabled: commands.viewFullCrateGraph },
-        expandMacro: { enabled: commands.expandMacro },
-        run: { enabled: commands.run },
-        copyRunCommandLine: { enabled: commands.copyRunCommandLine },
-        debug: { enabled: commands.debug },
-        newDebugConfig: { enabled: commands.newDebugConfig },
-        openDocs: { enabled: commands.openDocs },
-        openCargoToml: { enabled: commands.openCargoToml },
-        peekTests: { enabled: commands.peekTests },
-        moveItemUp: { enabled: commands.moveItemUp },
-        moveItemDown: { enabled: commands.moveItemDown },
-        cancelFlycheck: { enabled: commands.cancelFlycheck },
-        clearFlycheck: { enabled: commands.clearFlycheck },
-        runFlycheck: { enabled: commands.runFlycheck },
-        ssr: { enabled: commands.ssr },
-        serverVersion: { enabled: commands.serverVersion },
+        viewFileText: {enabled: commands.viewFileText},
+        viewItemTree: {enabled: commands.viewItemTree},
+        viewCrateGraph: {enabled: commands.viewCrateGraph},
+        viewFullCrateGraph: {enabled: commands.viewFullCrateGraph},
+        expandMacro: {enabled: commands.expandMacro},
+        run: {enabled: commands.run},
+        copyRunCommandLine: {enabled: commands.copyRunCommandLine},
+        debug: {enabled: commands.debug},
+        newDebugConfig: {enabled: commands.newDebugConfig},
+        openDocs: {enabled: commands.openDocs},
+        openCargoToml: {enabled: commands.openCargoToml},
+        peekTests: {enabled: commands.peekTests},
+        moveItemUp: {enabled: commands.moveItemUp},
+        moveItemDown: {enabled: commands.moveItemDown},
+        cancelFlycheck: {enabled: commands.cancelFlycheck},
+        clearFlycheck: {enabled: commands.clearFlycheck},
+        runFlycheck: {enabled: commands.runFlycheck},
+        ssr: {enabled: commands.ssr},
+        serverVersion: {enabled: commands.serverVersion},
         // Internal commands which are invoked by the server.
-        applyActionGroup: { enabled: commands.applyActionGroup },
-        applySnippetWorkspaceEdit: { enabled: commands.applySnippetWorkspaceEditCommand },
-        debugSingle: { enabled: commands.debugSingle },
-        gotoLocation: { enabled: commands.gotoLocation },
-        linkToCommand: { enabled: commands.linkToCommand },
-        resolveCodeAction: { enabled: commands.resolveCodeAction },
-        runSingle: { enabled: commands.runSingle },
-        showReferences: { enabled: commands.showReferences },
-        triggerParameterHints: { enabled: commands.triggerParameterHints },
-        openLogs: { enabled: commands.openLogs },
+        applyActionGroup: {enabled: commands.applyActionGroup},
+        applySnippetWorkspaceEdit: {enabled: commands.applySnippetWorkspaceEditCommand},
+        debugSingle: {enabled: commands.debugSingle},
+        gotoLocation: {enabled: commands.gotoLocation},
+        linkToCommand: {enabled: commands.linkToCommand},
+        resolveCodeAction: {enabled: commands.resolveCodeAction},
+        runSingle: {enabled: commands.runSingle},
+        showReferences: {enabled: commands.showReferences},
+        triggerParameterHints: {enabled: commands.triggerParameterHints},
+        openLogs: {enabled: commands.openLogs},
+        openFile: {enabled: commands.openFile},
+        revealDependency: {enabled: commands.revealDependency}
     };
 }
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 917a1d6b099..6f37451edd2 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -5,6 +5,15 @@ import * as readline from "readline";
 import * as vscode from "vscode";
 import { execute, log, memoizeAsync } from "./util";
 
+
+const TREE_LINE_PATTERN = new RegExp(/(.+)\sv(\d+\.\d+\.\d+)(?:\s\((.+)\))?/);
+const TOOLCHAIN_PATTERN = new RegExp(/(.*)\s\(.*\)/);
+
+export interface Crate {
+    name: string;
+    version: string;
+}
+
 interface CompilationArtifact {
     fileName: string;
     name: string;
@@ -96,6 +105,43 @@ export class Cargo {
         return artifacts[0].fileName;
     }
 
+    async crates(): Promise<Crate[]> {
+        const pathToCargo = await cargoPath();
+        return await new Promise((resolve, reject) => {
+            const crates: Crate[] = [];
+
+            const cargo = cp.spawn(pathToCargo, ['tree', '--prefix', 'none'], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd: this.rootFolder
+            });
+            const rl = readline.createInterface({ input: cargo.stdout });
+            rl.on('line', line => {
+                const match = line.match(TREE_LINE_PATTERN);
+                if (match) {
+                    const name = match[1];
+                    const version = match[2];
+                    const extraInfo = match[3];
+                    // ignore duplicates '(*)' and path dependencies
+                    if (this.shouldIgnore(extraInfo)) {
+                        return;
+                    }
+                    crates.push({ name, version });
+                }
+            });
+            cargo.on('exit', (exitCode, _) => {
+                if (exitCode === 0)
+                    resolve(crates);
+                else
+                    reject(new Error(`exit code: ${exitCode}.`));
+            });
+
+        });
+    }
+
+    private shouldIgnore(extraInfo: string): boolean {
+        return extraInfo !== undefined && (extraInfo === '*' || path.isAbsolute(extraInfo));
+    }
+
     private async runCargo(
         cargoArgs: string[],
         onStdoutJson: (obj: any) => void,
@@ -127,6 +173,58 @@ export class Cargo {
     }
 }
 
+export async function activeToolchain(): Promise<string> {
+    const pathToRustup = await rustupPath();
+    return await new Promise((resolve, reject) => {
+        const execution = cp.spawn(pathToRustup, ['show', 'active-toolchain'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            cwd: os.homedir()
+        });
+        const rl = readline.createInterface({ input: execution.stdout });
+
+        let currToolchain: string | undefined = undefined;
+        rl.on('line', line => {
+            const match = line.match(TOOLCHAIN_PATTERN);
+            if (match) {
+                currToolchain = match[1];
+            }
+        });
+        execution.on('exit', (exitCode, _) => {
+            if (exitCode === 0 && currToolchain)
+                resolve(currToolchain);
+            else
+                reject(new Error(`exit code: ${exitCode}.`));
+        });
+
+    });
+}
+
+export async function rustVersion(): Promise<string> {
+    const pathToRustup = await rustupPath();
+    return await new Promise((resolve, reject) => {
+        const execution = cp.spawn(pathToRustup, ['show', 'active-toolchain'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            cwd: os.homedir()
+        });
+        const rl = readline.createInterface({ input: execution.stdout });
+
+        let currToolchain: string | undefined = undefined;
+        rl.on('line', line => {
+            const match = line.match(TOOLCHAIN_PATTERN);
+            if (match) {
+                currToolchain = match[1];
+            }
+        });
+        execution.on('exit', (exitCode, _) => {
+            if (exitCode === 1 && currToolchain)
+                resolve(currToolchain);
+            else
+                reject(new Error(`exit code: ${exitCode}.`));
+        });
+
+    });
+}
+
 /** Mirrors `project_model::sysroot::discover_sysroot_dir()` implementation*/
 export async function getSysroot(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
@@ -145,11 +243,26 @@ export async function getRustcId(dir: string): Promise<string> {
     return rx.exec(data)![1];
 }
 
+export async function getRustcVersion(dir: string): Promise<string> {
+    const rustcPath = await getPathForExecutable("rustc");
+
+    // do not memoize the result because the toolchain may change between runs
+    const data = await execute(`${rustcPath} -V`, { cwd: dir });
+    const rx = /(\d\.\d+\.\d+)/;
+
+    return rx.exec(data)![1];
+}
+
 /** Mirrors `toolchain::cargo()` implementation */
 export function cargoPath(): Promise<string> {
     return getPathForExecutable("cargo");
 }
 
+/** Mirrors `toolchain::cargo()` implementation */
+export function rustupPath(): Promise<string> {
+    return getPathForExecutable("rustup");
+}
+
 /** Mirrors `toolchain::get_path_for_executable()` implementation */
 export const getPathForExecutable = memoizeAsync(
     // We apply caching to decrease file-system interactions
-- 
cgit 1.4.1-3-g733a5


From 68aa20bb8add41a2996c857235f554e11cde71aa Mon Sep 17 00:00:00 2001
From: bruno-ortiz <brunortiz11@gmail.com>
Date: Fri, 25 Feb 2022 21:53:47 -0300
Subject: fixing stblib loading

---
 editors/code/src/dependencies_provider.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 0f2e5e5ea07..1b9ab897350 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -80,6 +80,7 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
     const basePath = fspath.join(registryDir, fs.readdirSync(registryDir)[0]);
     const deps = await this.getDepsInCartoTree(basePath);
     const stdlib = await this.getStdLib();
+    this.dependenciesMap[stdlib.dependencyPath.toLowerCase()] = stdlib;
     return [stdlib].concat(deps);
   }
 
@@ -87,12 +88,14 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
     const toolchain = await activeToolchain();
     const rustVersion = await getRustcVersion(os.homedir());
     const stdlibPath = fspath.join(os.homedir(), '.rustup', 'toolchains', toolchain, 'lib', 'rustlib', 'src', 'rust', 'library');
-    return new Dependency(
+    const stdlib = new Dependency(
       "stdlib",
       rustVersion,
       stdlibPath,
       vscode.TreeItemCollapsibleState.Collapsed
     );
+
+    return stdlib;
   }
 
   private async getDepsInCartoTree(basePath: string): Promise<Dependency[]> {
-- 
cgit 1.4.1-3-g733a5


From 77a4bfd34f2d251482aca8e8da10634f34552e3b Mon Sep 17 00:00:00 2001
From: bruno-ortiz <brunortiz11@gmail.com>
Date: Fri, 25 Feb 2022 22:37:09 -0300
Subject: fixing linting problemas

---
 editors/code/src/dependencies_provider.ts | 262 +++++++++++++++---------------
 1 file changed, 131 insertions(+), 131 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 1b9ab897350..2df5ef61111 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -7,148 +7,148 @@ import { activeToolchain, Cargo, Crate, getRustcVersion } from './toolchain';
 const debugOutput = vscode.window.createOutputChannel("Debug");
 
 export class RustDependenciesProvider implements vscode.TreeDataProvider<Dependency | DependencyFile>{
-  cargo: Cargo;
-  dependenciesMap: { [id: string]: Dependency | DependencyFile };
-
-  constructor(
-    private readonly workspaceRoot: string,
-  ) {
-    this.cargo = new Cargo(this.workspaceRoot || '.', debugOutput);
-    this.dependenciesMap = {};
-  }
-
-  private _onDidChangeTreeData: vscode.EventEmitter<Dependency | DependencyFile | undefined | null | void> = new vscode.EventEmitter<Dependency | undefined | null | void>();
-
-  readonly onDidChangeTreeData: vscode.Event<Dependency | DependencyFile | undefined | null | void> = this._onDidChangeTreeData.event;
-
-
-  getDependency(filePath: string): Dependency | DependencyFile | undefined {
-    return this.dependenciesMap[filePath.toLowerCase()];
-  }
-
-  contains(filePath: string): boolean {
-    return filePath.toLowerCase() in this.dependenciesMap;
-  }
-
-  refresh(): void {
-    this._onDidChangeTreeData.fire();
-  }
-
-  getParent?(element: Dependency | DependencyFile): vscode.ProviderResult<Dependency | DependencyFile> {
-    if (element instanceof Dependency) return undefined;
-    return element.parent;
-  }
-
-  getTreeItem(element: Dependency | DependencyFile): vscode.TreeItem | Thenable<vscode.TreeItem> {
-    if (element.id! in this.dependenciesMap) return this.dependenciesMap[element.id!];
-    return element;
-  }
-
-  getChildren(element?: Dependency | DependencyFile): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
-    return new Promise((resolve, _reject) => {
-      if (!this.workspaceRoot) {
-        void vscode.window.showInformationMessage('No dependency in empty workspace');
-        return Promise.resolve([]);
-      }
-
-      if (element) {
-        const files = fs.readdirSync(element.dependencyPath).map(fileName => {
-          const filePath = fspath.join(element.dependencyPath, fileName);
-          const collapsibleState = fs.lstatSync(filePath).isDirectory() ?
-            vscode.TreeItemCollapsibleState.Collapsed :
-            vscode.TreeItemCollapsibleState.None;
-          const dep = new DependencyFile(
-            fileName,
-            filePath,
-            element,
-            collapsibleState
-          );
-          this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
-          return dep;
+    cargo: Cargo;
+    dependenciesMap: { [id: string]: Dependency | DependencyFile };
+
+    constructor(
+        private readonly workspaceRoot: string,
+    ) {
+        this.cargo = new Cargo(this.workspaceRoot || '.', debugOutput);
+        this.dependenciesMap = {};
+    }
+
+    private _onDidChangeTreeData: vscode.EventEmitter<Dependency | DependencyFile | undefined | null | void> = new vscode.EventEmitter<Dependency | undefined | null | void>();
+
+    readonly onDidChangeTreeData: vscode.Event<Dependency | DependencyFile | undefined | null | void> = this._onDidChangeTreeData.event;
+
+
+    getDependency(filePath: string): Dependency | DependencyFile | undefined {
+        return this.dependenciesMap[filePath.toLowerCase()];
+    }
+
+    contains(filePath: string): boolean {
+        return filePath.toLowerCase() in this.dependenciesMap;
+    }
+
+    refresh(): void {
+        this._onDidChangeTreeData.fire();
+    }
+
+    getParent?(element: Dependency | DependencyFile): vscode.ProviderResult<Dependency | DependencyFile> {
+        if (element instanceof Dependency) return undefined;
+        return element.parent;
+    }
+
+    getTreeItem(element: Dependency | DependencyFile): vscode.TreeItem | Thenable<vscode.TreeItem> {
+        if (element.id! in this.dependenciesMap) return this.dependenciesMap[element.id!];
+        return element;
+    }
+
+    getChildren(element?: Dependency | DependencyFile): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
+        return new Promise((resolve, _reject) => {
+            if (!this.workspaceRoot) {
+                void vscode.window.showInformationMessage('No dependency in empty workspace');
+                return Promise.resolve([]);
+            }
+
+            if (element) {
+                const files = fs.readdirSync(element.dependencyPath).map(fileName => {
+                    const filePath = fspath.join(element.dependencyPath, fileName);
+                    const collapsibleState = fs.lstatSync(filePath).isDirectory() ?
+                        vscode.TreeItemCollapsibleState.Collapsed :
+                        vscode.TreeItemCollapsibleState.None;
+                    const dep = new DependencyFile(
+                        fileName,
+                        filePath,
+                        element,
+                        collapsibleState
+                    );
+                    this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
+                    return dep;
+                });
+                return resolve(
+                    files
+                );
+            } else {
+                return resolve(this.getRootDependencies());
+            }
         });
-        return resolve(
-          files
+    }
+
+    private async getRootDependencies(): Promise<Dependency[]> {
+        const registryDir = fspath.join(os.homedir(), '.cargo', 'registry', 'src');
+        const basePath = fspath.join(registryDir, fs.readdirSync(registryDir)[0]);
+        const deps = await this.getDepsInCartoTree(basePath);
+        const stdlib = await this.getStdLib();
+        this.dependenciesMap[stdlib.dependencyPath.toLowerCase()] = stdlib;
+        return [stdlib].concat(deps);
+    }
+
+    private async getStdLib(): Promise<Dependency> {
+        const toolchain = await activeToolchain();
+        const rustVersion = await getRustcVersion(os.homedir());
+        const stdlibPath = fspath.join(os.homedir(), '.rustup', 'toolchains', toolchain, 'lib', 'rustlib', 'src', 'rust', 'library');
+        const stdlib = new Dependency(
+            "stdlib",
+            rustVersion,
+            stdlibPath,
+            vscode.TreeItemCollapsibleState.Collapsed
         );
-      } else {
-        return resolve(this.getRootDependencies());
-      }
-    });
-  }
-
-  private async getRootDependencies(): Promise<Dependency[]> {
-    const registryDir = fspath.join(os.homedir(), '.cargo', 'registry', 'src');
-    const basePath = fspath.join(registryDir, fs.readdirSync(registryDir)[0]);
-    const deps = await this.getDepsInCartoTree(basePath);
-    const stdlib = await this.getStdLib();
-    this.dependenciesMap[stdlib.dependencyPath.toLowerCase()] = stdlib;
-    return [stdlib].concat(deps);
-  }
-
-  private async getStdLib(): Promise<Dependency> {
-    const toolchain = await activeToolchain();
-    const rustVersion = await getRustcVersion(os.homedir());
-    const stdlibPath = fspath.join(os.homedir(), '.rustup', 'toolchains', toolchain, 'lib', 'rustlib', 'src', 'rust', 'library');
-    const stdlib = new Dependency(
-      "stdlib",
-      rustVersion,
-      stdlibPath,
-      vscode.TreeItemCollapsibleState.Collapsed
-    );
-
-    return stdlib;
-  }
-
-  private async getDepsInCartoTree(basePath: string): Promise<Dependency[]> {
-    const crates: Crate[] = await this.cargo.crates();
-    const toDep = (moduleName: string, version: string): Dependency => {
-      const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
-      return new Dependency(
-        moduleName,
-        version,
-        cratePath,
-        vscode.TreeItemCollapsibleState.Collapsed
-      );
-    };
-
-    const deps = crates.map(crate => {
-      const dep = toDep(crate.name, crate.version);
-      this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
-      return dep;
-    });
-    return deps;
-  }
+
+        return stdlib;
+    }
+
+    private async getDepsInCartoTree(basePath: string): Promise<Dependency[]> {
+        const crates: Crate[] = await this.cargo.crates();
+        const toDep = (moduleName: string, version: string): Dependency => {
+            const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
+            return new Dependency(
+                moduleName,
+                version,
+                cratePath,
+                vscode.TreeItemCollapsibleState.Collapsed
+            );
+        };
+
+        const deps = crates.map(crate => {
+            const dep = toDep(crate.name, crate.version);
+            this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
+            return dep;
+        });
+        return deps;
+    }
 }
 
 
 export class Dependency extends vscode.TreeItem {
-  constructor(
-    public readonly label: string,
-    private version: string,
-    readonly dependencyPath: string,
-    public readonly collapsibleState: vscode.TreeItemCollapsibleState
-  ) {
-    super(label, collapsibleState);
-    this.tooltip = `${this.label}-${this.version}`;
-    this.description = this.version;
-    this.resourceUri = vscode.Uri.file(dependencyPath);
-  }
+    constructor(
+        public readonly label: string,
+        private version: string,
+        readonly dependencyPath: string,
+        public readonly collapsibleState: vscode.TreeItemCollapsibleState
+    ) {
+        super(label, collapsibleState);
+        this.tooltip = `${this.label}-${this.version}`;
+        this.description = this.version;
+        this.resourceUri = vscode.Uri.file(dependencyPath);
+    }
 }
 
 export class DependencyFile extends vscode.TreeItem {
 
-  constructor(
-    readonly label: string,
-    readonly dependencyPath: string,
-    readonly parent: Dependency | DependencyFile,
-    public readonly collapsibleState: vscode.TreeItemCollapsibleState
-  ) {
-    super(vscode.Uri.file(dependencyPath), collapsibleState);
-    const isDir = fs.lstatSync(this.dependencyPath).isDirectory();
-    this.id = this.dependencyPath.toLowerCase();
-    if (!isDir) {
-      this.command = { command: 'rust-analyzer.openFile', title: "Open File", arguments: [vscode.Uri.file(this.dependencyPath)], };
+    constructor(
+        readonly label: string,
+        readonly dependencyPath: string,
+        readonly parent: Dependency | DependencyFile,
+        public readonly collapsibleState: vscode.TreeItemCollapsibleState
+    ) {
+        super(vscode.Uri.file(dependencyPath), collapsibleState);
+        const isDir = fs.lstatSync(this.dependencyPath).isDirectory();
+        this.id = this.dependencyPath.toLowerCase();
+        if (!isDir) {
+            this.command = { command: 'rust-analyzer.openFile', title: "Open File", arguments: [vscode.Uri.file(this.dependencyPath)], };
+        }
     }
-  }
 }
 
 export type DependencyId = { id: string };
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 364308d1dc653199dd786486f4eed0d456a95330 Mon Sep 17 00:00:00 2001
From: bruno-ortiz <brunortiz11@gmail.com>
Date: Sat, 26 Feb 2022 11:17:10 -0300
Subject: removing unused function

---
 editors/code/src/toolchain.ts | 26 --------------------------
 1 file changed, 26 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 6f37451edd2..75e0ed1d125 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -199,32 +199,6 @@ export async function activeToolchain(): Promise<string> {
     });
 }
 
-export async function rustVersion(): Promise<string> {
-    const pathToRustup = await rustupPath();
-    return await new Promise((resolve, reject) => {
-        const execution = cp.spawn(pathToRustup, ['show', 'active-toolchain'], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            cwd: os.homedir()
-        });
-        const rl = readline.createInterface({ input: execution.stdout });
-
-        let currToolchain: string | undefined = undefined;
-        rl.on('line', line => {
-            const match = line.match(TOOLCHAIN_PATTERN);
-            if (match) {
-                currToolchain = match[1];
-            }
-        });
-        execution.on('exit', (exitCode, _) => {
-            if (exitCode === 1 && currToolchain)
-                resolve(currToolchain);
-            else
-                reject(new Error(`exit code: ${exitCode}.`));
-        });
-
-    });
-}
-
 /** Mirrors `project_model::sysroot::discover_sysroot_dir()` implementation*/
 export async function getSysroot(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
-- 
cgit 1.4.1-3-g733a5


From 76432d39cb01423ca3c3add391218269d95c46a4 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 17 Jul 2022 17:38:56 +0200
Subject: Reformat VSCode client code

---
 editors/code/src/commands.ts              |  9 ++--
 editors/code/src/ctx.ts                   | 24 +++++----
 editors/code/src/dependencies_provider.ts | 84 ++++++++++++++++++-------------
 editors/code/src/toolchain.ts             | 37 ++++++--------
 4 files changed, 82 insertions(+), 72 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index e5aa06025b2..c8b54970a5f 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -8,11 +8,11 @@ import { applySnippetWorkspaceEdit, applySnippetTextEdits } from "./snippets";
 import { spawnSync } from "child_process";
 import { RunnableQuickPick, selectRunnable, createTask, createArgs } from "./run";
 import { AstInspector } from "./ast_inspector";
-import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor, RustEditor } from './util';
+import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor, RustEditor } from "./util";
 import { startDebugSession, makeDebugConfig } from "./debug";
 import { LanguageClient } from "vscode-languageclient/node";
 import { LINKED_COMMANDS } from "./client";
-import { DependencyId } from './dependencies_provider';
+import { DependencyId } from "./dependencies_provider";
 
 export * from "./ast_inspector";
 export * from "./run";
@@ -291,8 +291,7 @@ export function revealDependency(ctx: CtxInit): Cmd {
             do {
                 documentPath = path.dirname(documentPath);
                 parentChain.push({ id: documentPath.toLowerCase() });
-            }
-            while (!ctx.dependencies.contains(documentPath));
+            } while (!ctx.dependencies.contains(documentPath));
             parentChain.reverse();
             for (const idx in parentChain) {
                 await ctx.treeView.reveal(parentChain[idx], { select: true, expand: true });
@@ -302,7 +301,7 @@ export function revealDependency(ctx: CtxInit): Cmd {
 }
 
 export async function execRevealDependency(e: RustEditor): Promise<void> {
-    await vscode.commands.executeCommand('rust-analyzer.revealDependency', e);
+    await vscode.commands.executeCommand("rust-analyzer.revealDependency", e);
 }
 
 export function ssr(ctx: CtxInit): Cmd {
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index e6829ac4b9e..feb39198c22 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -3,8 +3,8 @@ import * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 import * as path from "path";
 
-import {Config, prepareVSCodeConfig} from './config';
-import {createClient} from './client';
+import {Config, prepareVSCodeConfig} from "./config";
+import {createClient} from "./client";
 import {
     executeDiscoverProject,
     isRustDocument,
@@ -12,10 +12,15 @@ import {
     LazyOutputChannel,
     log,
     RustEditor,
-} from './util';
-import {ServerStatusParams} from './lsp_ext';
-import {Dependency, DependencyFile, RustDependenciesProvider, DependencyId} from './dependencies_provider';
-import {execRevealDependency} from './commands';
+} from "./util";
+import {ServerStatusParams} from "./lsp_ext";
+import {
+    Dependency,
+    DependencyFile,
+    RustDependenciesProvider,
+    DependencyId,
+} from "./dependencies_provider";
+import {execRevealDependency} from "./commands";
 import {PersistentState} from "./persistent_state";
 import {bootstrap} from "./bootstrap";
 import {ExecOptions} from "child_process";
@@ -113,13 +118,14 @@ export class Ctx {
         this.state = new PersistentState(extCtx.globalState);
         this.config = new Config(extCtx);
 
-        this.updateCommands("disable");
+        this.updateCommands("disable"
+        );
         this.setServerStatus({
             health: "stopped",
         });
-        vscode.window.onDidChangeActiveTextEditor(e => {
+        vscode.window.onDidChangeActiveTextEditor((e) => {
             if (e && isRustEditor(e)) {
-                execRevealDependency(e).catch(reason => {
+                execRevealDependency(e).catch((reason) => {
                     void vscode.window.showErrorMessage(`Dependency error: ${reason}`);
                 });
             }
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 2df5ef61111..b8b33a9be6a 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -1,26 +1,29 @@
-import * as vscode from 'vscode';
-import * as fspath from 'path';
-import * as fs from 'fs';
-import * as os from 'os';
-import { activeToolchain, Cargo, Crate, getRustcVersion } from './toolchain';
+import * as vscode from "vscode";
+import * as fspath from "path";
+import * as fs from "fs";
+import * as os from "os";
+import { activeToolchain, Cargo, Crate, getRustcVersion } from "./toolchain";
 
 const debugOutput = vscode.window.createOutputChannel("Debug");
 
-export class RustDependenciesProvider implements vscode.TreeDataProvider<Dependency | DependencyFile>{
+export class RustDependenciesProvider
+    implements vscode.TreeDataProvider<Dependency | DependencyFile>
+{
     cargo: Cargo;
     dependenciesMap: { [id: string]: Dependency | DependencyFile };
 
-    constructor(
-        private readonly workspaceRoot: string,
-    ) {
-        this.cargo = new Cargo(this.workspaceRoot || '.', debugOutput);
+    constructor(private readonly workspaceRoot: string) {
+        this.cargo = new Cargo(this.workspaceRoot || ".", debugOutput);
         this.dependenciesMap = {};
     }
 
-    private _onDidChangeTreeData: vscode.EventEmitter<Dependency | DependencyFile | undefined | null | void> = new vscode.EventEmitter<Dependency | undefined | null | void>();
-
-    readonly onDidChangeTreeData: vscode.Event<Dependency | DependencyFile | undefined | null | void> = this._onDidChangeTreeData.event;
+    private _onDidChangeTreeData: vscode.EventEmitter<
+        Dependency | DependencyFile | undefined | null | void
+    > = new vscode.EventEmitter<Dependency | undefined | null | void>();
 
+    readonly onDidChangeTreeData: vscode.Event<
+        Dependency | DependencyFile | undefined | null | void
+    > = this._onDidChangeTreeData.event;
 
     getDependency(filePath: string): Dependency | DependencyFile | undefined {
         return this.dependenciesMap[filePath.toLowerCase()];
@@ -34,7 +37,9 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
         this._onDidChangeTreeData.fire();
     }
 
-    getParent?(element: Dependency | DependencyFile): vscode.ProviderResult<Dependency | DependencyFile> {
+    getParent?(
+        element: Dependency | DependencyFile
+    ): vscode.ProviderResult<Dependency | DependencyFile> {
         if (element instanceof Dependency) return undefined;
         return element.parent;
     }
@@ -44,31 +49,26 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
         return element;
     }
 
-    getChildren(element?: Dependency | DependencyFile): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
+    getChildren(
+        element?: Dependency | DependencyFile
+    ): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
         return new Promise((resolve, _reject) => {
             if (!this.workspaceRoot) {
-                void vscode.window.showInformationMessage('No dependency in empty workspace');
+                void vscode.window.showInformationMessage("No dependency in empty workspace");
                 return Promise.resolve([]);
             }
 
             if (element) {
-                const files = fs.readdirSync(element.dependencyPath).map(fileName => {
+                const files = fs.readdirSync(element.dependencyPath).map((fileName) => {
                     const filePath = fspath.join(element.dependencyPath, fileName);
-                    const collapsibleState = fs.lstatSync(filePath).isDirectory() ?
-                        vscode.TreeItemCollapsibleState.Collapsed :
-                        vscode.TreeItemCollapsibleState.None;
-                    const dep = new DependencyFile(
-                        fileName,
-                        filePath,
-                        element,
-                        collapsibleState
-                    );
+                    const collapsibleState = fs.lstatSync(filePath).isDirectory()
+                        ? vscode.TreeItemCollapsibleState.Collapsed
+                        : vscode.TreeItemCollapsibleState.None;
+                    const dep = new DependencyFile(fileName, filePath, element, collapsibleState);
                     this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
                     return dep;
                 });
-                return resolve(
-                    files
-                );
+                return resolve(files);
             } else {
                 return resolve(this.getRootDependencies());
             }
@@ -76,7 +76,7 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
     }
 
     private async getRootDependencies(): Promise<Dependency[]> {
-        const registryDir = fspath.join(os.homedir(), '.cargo', 'registry', 'src');
+        const registryDir = fspath.join(os.homedir(), ".cargo", "registry", "src");
         const basePath = fspath.join(registryDir, fs.readdirSync(registryDir)[0]);
         const deps = await this.getDepsInCartoTree(basePath);
         const stdlib = await this.getStdLib();
@@ -87,7 +87,17 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
     private async getStdLib(): Promise<Dependency> {
         const toolchain = await activeToolchain();
         const rustVersion = await getRustcVersion(os.homedir());
-        const stdlibPath = fspath.join(os.homedir(), '.rustup', 'toolchains', toolchain, 'lib', 'rustlib', 'src', 'rust', 'library');
+        const stdlibPath = fspath.join(
+            os.homedir(),
+            ".rustup",
+            "toolchains",
+            toolchain,
+            "lib",
+            "rustlib",
+            "src",
+            "rust",
+            "library"
+        );
         const stdlib = new Dependency(
             "stdlib",
             rustVersion,
@@ -110,7 +120,7 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
             );
         };
 
-        const deps = crates.map(crate => {
+        const deps = crates.map((crate) => {
             const dep = toDep(crate.name, crate.version);
             this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
             return dep;
@@ -119,7 +129,6 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
     }
 }
 
-
 export class Dependency extends vscode.TreeItem {
     constructor(
         public readonly label: string,
@@ -135,7 +144,6 @@ export class Dependency extends vscode.TreeItem {
 }
 
 export class DependencyFile extends vscode.TreeItem {
-
     constructor(
         readonly label: string,
         readonly dependencyPath: string,
@@ -146,9 +154,13 @@ export class DependencyFile extends vscode.TreeItem {
         const isDir = fs.lstatSync(this.dependencyPath).isDirectory();
         this.id = this.dependencyPath.toLowerCase();
         if (!isDir) {
-            this.command = { command: 'rust-analyzer.openFile', title: "Open File", arguments: [vscode.Uri.file(this.dependencyPath)], };
+            this.command = {
+                command: "rust-analyzer.openFile",
+                title: "Open File",
+                arguments: [vscode.Uri.file(this.dependencyPath)],
+            };
         }
     }
 }
 
-export type DependencyId = { id: string };
\ No newline at end of file
+export type DependencyId = { id: string };
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 75e0ed1d125..c068cfc3118 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -5,7 +5,6 @@ import * as readline from "readline";
 import * as vscode from "vscode";
 import { execute, log, memoizeAsync } from "./util";
 
-
 const TREE_LINE_PATTERN = new RegExp(/(.+)\sv(\d+\.\d+\.\d+)(?:\s\((.+)\))?/);
 const TOOLCHAIN_PATTERN = new RegExp(/(.*)\s\(.*\)/);
 
@@ -110,12 +109,12 @@ export class Cargo {
         return await new Promise((resolve, reject) => {
             const crates: Crate[] = [];
 
-            const cargo = cp.spawn(pathToCargo, ['tree', '--prefix', 'none'], {
-                stdio: ['ignore', 'pipe', 'pipe'],
-                cwd: this.rootFolder
+            const cargo = cp.spawn(pathToCargo, ["tree", "--prefix", "none"], {
+                stdio: ["ignore", "pipe", "pipe"],
+                cwd: this.rootFolder,
             });
             const rl = readline.createInterface({ input: cargo.stdout });
-            rl.on('line', line => {
+            rl.on("line", (line) => {
                 const match = line.match(TREE_LINE_PATTERN);
                 if (match) {
                     const name = match[1];
@@ -128,18 +127,15 @@ export class Cargo {
                     crates.push({ name, version });
                 }
             });
-            cargo.on('exit', (exitCode, _) => {
-                if (exitCode === 0)
-                    resolve(crates);
-                else
-                    reject(new Error(`exit code: ${exitCode}.`));
+            cargo.on("exit", (exitCode, _) => {
+                if (exitCode === 0) resolve(crates);
+                else reject(new Error(`exit code: ${exitCode}.`));
             });
-
         });
     }
 
     private shouldIgnore(extraInfo: string): boolean {
-        return extraInfo !== undefined && (extraInfo === '*' || path.isAbsolute(extraInfo));
+        return extraInfo !== undefined && (extraInfo === "*" || path.isAbsolute(extraInfo));
     }
 
     private async runCargo(
@@ -176,26 +172,23 @@ export class Cargo {
 export async function activeToolchain(): Promise<string> {
     const pathToRustup = await rustupPath();
     return await new Promise((resolve, reject) => {
-        const execution = cp.spawn(pathToRustup, ['show', 'active-toolchain'], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            cwd: os.homedir()
+        const execution = cp.spawn(pathToRustup, ["show", "active-toolchain"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            cwd: os.homedir(),
         });
         const rl = readline.createInterface({ input: execution.stdout });
 
         let currToolchain: string | undefined = undefined;
-        rl.on('line', line => {
+        rl.on("line", (line) => {
             const match = line.match(TOOLCHAIN_PATTERN);
             if (match) {
                 currToolchain = match[1];
             }
         });
-        execution.on('exit', (exitCode, _) => {
-            if (exitCode === 0 && currToolchain)
-                resolve(currToolchain);
-            else
-                reject(new Error(`exit code: ${exitCode}.`));
+        execution.on("exit", (exitCode, _) => {
+            if (exitCode === 0 && currToolchain) resolve(currToolchain);
+            else reject(new Error(`exit code: ${exitCode}.`));
         });
-
     });
 }
 
-- 
cgit 1.4.1-3-g733a5


From 16cba19ff3324c4703bf861b96af97bc622e1d6a Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 17 Jul 2022 17:45:43 +0200
Subject: Remove unnecessary openFile command

---
 editors/code/package.json                 |  6 +-----
 editors/code/src/commands.ts              | 10 ----------
 editors/code/src/dependencies_provider.ts |  2 +-
 editors/code/src/main.ts                  |  1 -
 4 files changed, 2 insertions(+), 17 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index 5e2a1c69e94..0efc191d748 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -285,10 +285,6 @@
                 "title": "Clear flycheck diagnostics",
                 "category": "rust-analyzer"
             },
-            {
-                "command": "rust-analyzer.openFile",
-                "title": "Open File"
-            },
             {
                 "command": "rust-analyzer.revealDependency",
                 "title": "Reveal File"
@@ -1979,4 +1975,4 @@
             }
         ]
     }
-}
\ No newline at end of file
+}
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index c8b54970a5f..70eeab897c9 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -267,16 +267,6 @@ export function openCargoToml(ctx: CtxInit): Cmd {
     };
 }
 
-export function openFile(_ctx: CtxInit): Cmd {
-    return async (uri: vscode.Uri) => {
-        try {
-            await vscode.window.showTextDocument(uri);
-        } catch (err) {
-            await vscode.window.showErrorMessage(err.message);
-        }
-    };
-}
-
 export function revealDependency(ctx: CtxInit): Cmd {
     return async (editor: RustEditor) => {
         const rootPath = vscode.workspace.workspaceFolders![0].uri.fsPath;
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index b8b33a9be6a..777cb0d33a7 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -155,7 +155,7 @@ export class DependencyFile extends vscode.TreeItem {
         this.id = this.dependencyPath.toLowerCase();
         if (!isDir) {
             this.command = {
-                command: "rust-analyzer.openFile",
+                command: "vscode.open",
                 title: "Open File",
                 arguments: [vscode.Uri.file(this.dependencyPath)],
             };
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 62b2e7a2771..774600f6c39 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -192,7 +192,6 @@ function createCommands(): Record<string, CommandFactory> {
         showReferences: {enabled: commands.showReferences},
         triggerParameterHints: {enabled: commands.triggerParameterHints},
         openLogs: {enabled: commands.openLogs},
-        openFile: {enabled: commands.openFile},
         revealDependency: {enabled: commands.revealDependency}
     };
 }
-- 
cgit 1.4.1-3-g733a5


From 1201b156d839ac5b5cc7bca1ea1c1f0cf6fbf6a9 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 17 Jul 2022 18:05:55 +0200
Subject: WIP: Add lsp-ext scaffold

---
 crates/rust-analyzer/src/lsp_ext.rs       | 15 +++++++++++++++
 crates/rust-analyzer/src/main_loop.rs     |  1 +
 editors/code/src/dependencies_provider.ts |  9 ++++++++-
 editors/code/src/lsp_ext.ts               | 16 ++++++++++++++++
 4 files changed, 40 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 625ffe0763c..420118ad68b 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -27,6 +27,21 @@ pub struct AnalyzerStatusParams {
     pub text_document: Option<TextDocumentIdentifier>,
 }
 
+pub enum FetchDependencyGraph {}
+
+impl Request for FetchDependencyGraph {
+    type Params = FetchDependencyGraphParams;
+    type Result = FetchDependencyGraphResult;
+    const METHOD: &'static str = "rust-analyzer/fetchDependencyGraph";
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct FetchDependencyGraphParams {}
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct FetchDependencyGraphResult {}
+
 pub enum MemoryUsage {}
 
 impl Request for MemoryUsage {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index dc0ea0b17e0..72fc1f1e250 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -655,6 +655,7 @@ impl GlobalState {
             .on_sync_mut::<lsp_ext::ReloadWorkspace>(handlers::handle_workspace_reload)
             .on_sync_mut::<lsp_ext::RebuildProcMacros>(handlers::handle_proc_macros_rebuild)
             .on_sync_mut::<lsp_ext::MemoryUsage>(handlers::handle_memory_usage)
+            .on_sync_mut::<lsp_ext::FetchDependencyGraph>(handlers::fetch_dependency_graph)
             .on_sync_mut::<lsp_ext::ShuffleCrateGraph>(handlers::handle_shuffle_crate_graph)
             .on_sync::<lsp_ext::JoinLines>(handlers::handle_join_lines)
             .on_sync::<lsp_ext::OnEnter>(handlers::handle_on_enter)
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 777cb0d33a7..48d51523e86 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -3,6 +3,9 @@ import * as fspath from "path";
 import * as fs from "fs";
 import * as os from "os";
 import { activeToolchain, Cargo, Crate, getRustcVersion } from "./toolchain";
+import { Ctx } from "./ctx";
+import { setFlagsFromString } from "v8";
+import * as ra from "./lsp_ext";
 
 const debugOutput = vscode.window.createOutputChannel("Debug");
 
@@ -11,10 +14,12 @@ export class RustDependenciesProvider
 {
     cargo: Cargo;
     dependenciesMap: { [id: string]: Dependency | DependencyFile };
+    ctx: Ctx;
 
-    constructor(private readonly workspaceRoot: string) {
+    constructor(private readonly workspaceRoot: string, ctx: Ctx) {
         this.cargo = new Cargo(this.workspaceRoot || ".", debugOutput);
         this.dependenciesMap = {};
+        this.ctx = ctx;
     }
 
     private _onDidChangeTreeData: vscode.EventEmitter<
@@ -76,6 +81,8 @@ export class RustDependenciesProvider
     }
 
     private async getRootDependencies(): Promise<Dependency[]> {
+        const crates = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
+
         const registryDir = fspath.join(os.homedir(), ".cargo", "registry", "src");
         const basePath = fspath.join(registryDir, fs.readdirSync(registryDir)[0]);
         const deps = await this.getDepsInCartoTree(basePath);
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 82955acf25e..1a887b37201 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -70,6 +70,22 @@ export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>
 
 export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };
 
+export interface FetchDependencyGraphParams {}
+
+export interface FetchDependencyGraphResult {
+    crates: {
+        name: string;
+        version: string;
+        path: string;
+    }[];
+}
+
+export const fetchDependencyGraph = new lc.RequestType<
+    FetchDependencyGraphParams,
+    FetchDependencyGraphResult,
+    void
+>("rust-analyzer/fetchDependencyGraph");
+
 export type ExpandMacroParams = {
     textDocument: lc.TextDocumentIdentifier;
     position: lc.Position;
-- 
cgit 1.4.1-3-g733a5


From 09e0a00d3648eb4080d16f07c6dae73f7c73c431 Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Sun, 2 Apr 2023 21:58:20 -0300
Subject: fetching dependencies from the server

---
 crates/ide/src/fetch_crates.rs            | 59 +++++++++++++++++++++++
 crates/ide/src/lib.rs                     |  6 +++
 crates/rust-analyzer/src/handlers.rs      | 23 ++++++++-
 crates/rust-analyzer/src/lsp_ext.rs       | 13 +++++-
 crates/rust-analyzer/src/main_loop.rs     |  2 +-
 editors/code/src/commands.ts              |  8 ++--
 editors/code/src/ctx.ts                   | 48 +++++++++++++------
 editors/code/src/dependencies_provider.ts | 77 ++++++++-----------------------
 editors/code/src/toolchain.ts             | 75 +-----------------------------
 9 files changed, 155 insertions(+), 156 deletions(-)
 create mode 100644 crates/ide/src/fetch_crates.rs

(limited to 'editors/code/src')

diff --git a/crates/ide/src/fetch_crates.rs b/crates/ide/src/fetch_crates.rs
new file mode 100644
index 00000000000..c0bc4103c2f
--- /dev/null
+++ b/crates/ide/src/fetch_crates.rs
@@ -0,0 +1,59 @@
+use ide_db::{
+    base_db::{CrateOrigin, SourceDatabase, SourceDatabaseExt},
+    RootDatabase,
+};
+
+#[derive(Debug)]
+pub struct CrateInfo {
+    pub name: String,
+    pub version: String,
+    pub path: String,
+}
+
+pub(crate) fn fetch_crates(db: &RootDatabase) -> Vec<CrateInfo> {
+    let crate_graph = db.crate_graph();
+    crate_graph
+        .iter()
+        .map(|crate_id| &crate_graph[crate_id])
+        .filter(|&data| !matches!(data.origin, CrateOrigin::Local { .. }))
+        .map(|data| {
+            let crate_name = crate_name(data);
+            let version = data.version.clone().unwrap_or_else(|| "".to_owned());
+            let crate_path = crate_path(db, data, &crate_name);
+
+            CrateInfo { name: crate_name, version, path: crate_path }
+        })
+        .collect()
+}
+
+fn crate_name(data: &ide_db::base_db::CrateData) -> String {
+    data.display_name
+        .clone()
+        .map(|it| it.canonical_name().to_owned())
+        .unwrap_or("unknown".to_string())
+}
+
+fn crate_path(db: &RootDatabase, data: &ide_db::base_db::CrateData, crate_name: &str) -> String {
+    let source_root_id = db.file_source_root(data.root_file_id);
+    let source_root = db.source_root(source_root_id);
+    let source_root_path = source_root.path_for_file(&data.root_file_id);
+    match source_root_path.cloned() {
+        Some(mut root_path) => {
+            let mut crate_path = "".to_string();
+            while let Some(vfs_path) = root_path.parent() {
+                match vfs_path.name_and_extension() {
+                    Some((name, _)) => {
+                        if name.starts_with(crate_name) {
+                            crate_path = vfs_path.to_string();
+                            break;
+                        }
+                    }
+                    None => break,
+                }
+                root_path = vfs_path;
+            }
+            crate_path
+        }
+        None => "".to_owned(),
+    }
+}
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index e3900fa0d63..96adb11dcde 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -59,10 +59,12 @@ mod view_mir;
 mod interpret_function;
 mod view_item_tree;
 mod shuffle_crate_graph;
+mod fetch_crates;
 
 use std::sync::Arc;
 
 use cfg::CfgOptions;
+use fetch_crates::CrateInfo;
 use ide_db::{
     base_db::{
         salsa::{self, ParallelDatabase},
@@ -331,6 +333,10 @@ impl Analysis {
         self.with_db(|db| view_crate_graph::view_crate_graph(db, full))
     }
 
+    pub fn fetch_crates(&self) -> Cancellable<Vec<CrateInfo>> {
+        self.with_db(|db| fetch_crates::fetch_crates(db))
+    }
+
     pub fn expand_macro(&self, position: FilePosition) -> Cancellable<Option<ExpandedMacro>> {
         self.with_db(|db| expand_macro::expand_macro(db, position))
     }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index a00d0fba7c4..2324490e53b 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -6,7 +6,13 @@ use ide::AssistResolveStrategy;
 use lsp_types::{Diagnostic, DiagnosticTag, NumberOrString};
 use vfs::FileId;
 
-use crate::{global_state::GlobalStateSnapshot, to_proto, Result};
+use crate::{
+    global_state::GlobalStateSnapshot, to_proto, Result,
+    lsp_ext::{
+        CrateInfoResult, FetchDependencyGraphResult, FetchDependencyGraphParams,
+    },
+};
+
 
 pub(crate) mod request;
 pub(crate) mod notification;
@@ -31,7 +37,7 @@ pub(crate) fn publish_diagnostics(
                     "https://rust-analyzer.github.io/manual.html#{}",
                     d.code.as_str()
                 ))
-                .unwrap(),
+                    .unwrap(),
             }),
             source: Some("rust-analyzer".to_string()),
             message: d.message,
@@ -42,3 +48,16 @@ pub(crate) fn publish_diagnostics(
         .collect();
     Ok(diagnostics)
 }
+
+pub(crate) fn fetch_dependency_graph(
+    state: GlobalStateSnapshot,
+    _params: FetchDependencyGraphParams,
+) -> Result<FetchDependencyGraphResult> {
+    let crates = state.analysis.fetch_crates()?;
+    Ok(FetchDependencyGraphResult {
+        crates: crates
+            .into_iter()
+            .map(|it| CrateInfoResult { name: it.name, version: it.version, path: it.path })
+            .collect(),
+    })
+}
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 420118ad68b..18511da4683 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -27,6 +27,13 @@ pub struct AnalyzerStatusParams {
     pub text_document: Option<TextDocumentIdentifier>,
 }
 
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CrateInfoResult {
+    pub name: String,
+    pub version: String,
+    pub path: String,
+}
 pub enum FetchDependencyGraph {}
 
 impl Request for FetchDependencyGraph {
@@ -38,9 +45,12 @@ impl Request for FetchDependencyGraph {
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct FetchDependencyGraphParams {}
+
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct FetchDependencyGraphResult {}
+pub struct FetchDependencyGraphResult {
+    pub crates: Vec<CrateInfoResult>,
+}
 
 pub enum MemoryUsage {}
 
@@ -374,6 +384,7 @@ impl Request for CodeActionRequest {
 }
 
 pub enum CodeActionResolveRequest {}
+
 impl Request for CodeActionResolveRequest {
     type Params = CodeAction;
     type Result = CodeAction;
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 72fc1f1e250..7a81a18f4af 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -655,12 +655,12 @@ impl GlobalState {
             .on_sync_mut::<lsp_ext::ReloadWorkspace>(handlers::handle_workspace_reload)
             .on_sync_mut::<lsp_ext::RebuildProcMacros>(handlers::handle_proc_macros_rebuild)
             .on_sync_mut::<lsp_ext::MemoryUsage>(handlers::handle_memory_usage)
-            .on_sync_mut::<lsp_ext::FetchDependencyGraph>(handlers::fetch_dependency_graph)
             .on_sync_mut::<lsp_ext::ShuffleCrateGraph>(handlers::handle_shuffle_crate_graph)
             .on_sync::<lsp_ext::JoinLines>(handlers::handle_join_lines)
             .on_sync::<lsp_ext::OnEnter>(handlers::handle_on_enter)
             .on_sync::<lsp_types::request::SelectionRangeRequest>(handlers::handle_selection_range)
             .on_sync::<lsp_ext::MatchingBrace>(handlers::handle_matching_brace)
+            .on::<lsp_ext::FetchDependencyGraph>(handlers::fetch_dependency_graph)
             .on::<lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status)
             .on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)
             .on::<lsp_ext::ViewHir>(handlers::handle_view_hir)
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 70eeab897c9..7fe32754c90 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -272,19 +272,19 @@ export function revealDependency(ctx: CtxInit): Cmd {
         const rootPath = vscode.workspace.workspaceFolders![0].uri.fsPath;
         const documentPath = editor.document.uri.fsPath;
         if (documentPath.startsWith(rootPath)) return;
-        const dep = ctx.dependencies.getDependency(documentPath);
+        const dep = ctx.dependencies?.getDependency(documentPath);
         if (dep) {
-            await ctx.treeView.reveal(dep, { select: true, expand: true });
+            await ctx.treeView?.reveal(dep, { select: true, expand: true });
         } else {
             let documentPath = editor.document.uri.fsPath;
             const parentChain: DependencyId[] = [{ id: documentPath.toLowerCase() }];
             do {
                 documentPath = path.dirname(documentPath);
                 parentChain.push({ id: documentPath.toLowerCase() });
-            } while (!ctx.dependencies.contains(documentPath));
+            } while (!ctx.dependencies?.contains(documentPath));
             parentChain.reverse();
             for (const idx in parentChain) {
-                await ctx.treeView.reveal(parentChain[idx], { select: true, expand: true });
+                await ctx.treeView?.reveal(parentChain[idx], { select: true, expand: true });
             }
         }
     };
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index feb39198c22..d62716c26db 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -91,19 +91,25 @@ export class Ctx {
     private commandFactories: Record<string, CommandFactory>;
     private commandDisposables: Disposable[];
     private unlinkedFiles: vscode.Uri[];
-    readonly dependencies: RustDependenciesProvider;
-    readonly treeView: vscode.TreeView<Dependency | DependencyFile | DependencyId>;
+    private _dependencies: RustDependenciesProvider | undefined;
+    private _treeView: vscode.TreeView<Dependency | DependencyFile | DependencyId> | undefined;
 
     get client() {
         return this._client;
     }
 
+    get treeView() {
+        return this._treeView;
+    }
+
+    get dependencies() {
+        return this._dependencies;
+    }
+
     constructor(
         readonly extCtx: vscode.ExtensionContext,
         commandFactories: Record<string, CommandFactory>,
         workspace: Workspace,
-        dependencies: RustDependenciesProvider,
-        treeView: vscode.TreeView<Dependency | DependencyFile | DependencyId>
     ) {
         extCtx.subscriptions.push(this);
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
@@ -112,9 +118,6 @@ export class Ctx {
         this.commandDisposables = [];
         this.commandFactories = commandFactories;
         this.unlinkedFiles = [];
-        this.dependencies = dependencies;
-        this.treeView = treeView;
-
         this.state = new PersistentState(extCtx.globalState);
         this.config = new Config(extCtx);
 
@@ -123,13 +126,6 @@ export class Ctx {
         this.setServerStatus({
             health: "stopped",
         });
-        vscode.window.onDidChangeActiveTextEditor((e) => {
-            if (e && isRustEditor(e)) {
-                execRevealDependency(e).catch((reason) => {
-                    void vscode.window.showErrorMessage(`Dependency error: ${reason}`);
-                });
-            }
-        });
     }
 
     dispose() {
@@ -267,6 +263,28 @@ export class Ctx {
         }
         await client.start();
         this.updateCommands();
+        this.prepareTreeDependenciesView(client);
+    }
+
+    private prepareTreeDependenciesView(client: lc.LanguageClient) {
+        const ctxInit: CtxInit = {
+            ...this,
+            client: client
+        };
+        const rootPath = vscode.workspace.workspaceFolders![0].uri.fsPath;
+        this._dependencies = new RustDependenciesProvider(rootPath, ctxInit);
+        this._treeView = vscode.window.createTreeView("rustDependencies", {
+            treeDataProvider: this._dependencies,
+            showCollapseAll: true,
+        });
+
+        vscode.window.onDidChangeActiveTextEditor((e) => {
+            if (e && isRustEditor(e)) {
+                execRevealDependency(e).catch((reason) => {
+                    void vscode.window.showErrorMessage(`Dependency error: ${reason}`);
+                });
+            }
+        });
     }
 
     async restart() {
@@ -369,7 +387,7 @@ export class Ctx {
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
                 statusBar.command = "rust-analyzer.stopServer";
-                this.dependencies.refresh();
+                this.dependencies?.refresh();
                 break;
             case "warning":
                 if (status.message) {
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 48d51523e86..195f41417dd 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -1,23 +1,16 @@
 import * as vscode from "vscode";
 import * as fspath from "path";
 import * as fs from "fs";
-import * as os from "os";
-import { activeToolchain, Cargo, Crate, getRustcVersion } from "./toolchain";
-import { Ctx } from "./ctx";
-import { setFlagsFromString } from "v8";
+import { CtxInit } from "./ctx";
 import * as ra from "./lsp_ext";
-
-const debugOutput = vscode.window.createOutputChannel("Debug");
+import { FetchDependencyGraphResult } from "./lsp_ext";
 
 export class RustDependenciesProvider
-    implements vscode.TreeDataProvider<Dependency | DependencyFile>
-{
-    cargo: Cargo;
+    implements vscode.TreeDataProvider<Dependency | DependencyFile> {
     dependenciesMap: { [id: string]: Dependency | DependencyFile };
-    ctx: Ctx;
+    ctx: CtxInit;
 
-    constructor(private readonly workspaceRoot: string, ctx: Ctx) {
-        this.cargo = new Cargo(this.workspaceRoot || ".", debugOutput);
+    constructor(private readonly workspaceRoot: string, ctx: CtxInit) {
         this.dependenciesMap = {};
         this.ctx = ctx;
     }
@@ -62,7 +55,6 @@ export class RustDependenciesProvider
                 void vscode.window.showInformationMessage("No dependency in empty workspace");
                 return Promise.resolve([]);
             }
-
             if (element) {
                 const files = fs.readdirSync(element.dependencyPath).map((fileName) => {
                     const filePath = fspath.join(element.dependencyPath, fileName);
@@ -81,59 +73,26 @@ export class RustDependenciesProvider
     }
 
     private async getRootDependencies(): Promise<Dependency[]> {
-        const crates = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
-
-        const registryDir = fspath.join(os.homedir(), ".cargo", "registry", "src");
-        const basePath = fspath.join(registryDir, fs.readdirSync(registryDir)[0]);
-        const deps = await this.getDepsInCartoTree(basePath);
-        const stdlib = await this.getStdLib();
-        this.dependenciesMap[stdlib.dependencyPath.toLowerCase()] = stdlib;
-        return [stdlib].concat(deps);
-    }
-
-    private async getStdLib(): Promise<Dependency> {
-        const toolchain = await activeToolchain();
-        const rustVersion = await getRustcVersion(os.homedir());
-        const stdlibPath = fspath.join(
-            os.homedir(),
-            ".rustup",
-            "toolchains",
-            toolchain,
-            "lib",
-            "rustlib",
-            "src",
-            "rust",
-            "library"
-        );
-        const stdlib = new Dependency(
-            "stdlib",
-            rustVersion,
-            stdlibPath,
-            vscode.TreeItemCollapsibleState.Collapsed
-        );
-
-        return stdlib;
-    }
-
-    private async getDepsInCartoTree(basePath: string): Promise<Dependency[]> {
-        const crates: Crate[] = await this.cargo.crates();
-        const toDep = (moduleName: string, version: string): Dependency => {
-            const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
-            return new Dependency(
-                moduleName,
-                version,
-                cratePath,
-                vscode.TreeItemCollapsibleState.Collapsed
-            );
-        };
+        const dependenciesResult: FetchDependencyGraphResult = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
+        const crates = dependenciesResult.crates;
 
         const deps = crates.map((crate) => {
-            const dep = toDep(crate.name, crate.version);
+            const dep = this.toDep(crate.name, crate.version, crate.path);
             this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
             return dep;
         });
         return deps;
     }
+
+    private toDep(moduleName: string, version: string, path: string): Dependency {
+        // const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
+        return new Dependency(
+            moduleName,
+            version,
+            path,
+            vscode.TreeItemCollapsibleState.Collapsed
+        );
+    }
 }
 
 export class Dependency extends vscode.TreeItem {
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index c068cfc3118..771f6bcba45 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -5,14 +5,8 @@ import * as readline from "readline";
 import * as vscode from "vscode";
 import { execute, log, memoizeAsync } from "./util";
 
-const TREE_LINE_PATTERN = new RegExp(/(.+)\sv(\d+\.\d+\.\d+)(?:\s\((.+)\))?/);
 const TOOLCHAIN_PATTERN = new RegExp(/(.*)\s\(.*\)/);
 
-export interface Crate {
-    name: string;
-    version: string;
-}
-
 interface CompilationArtifact {
     fileName: string;
     name: string;
@@ -30,7 +24,7 @@ export class Cargo {
         readonly rootFolder: string,
         readonly output: vscode.OutputChannel,
         readonly env: Record<string, string>
-    ) {}
+    ) { }
 
     // Made public for testing purposes
     static artifactSpec(args: readonly string[]): ArtifactSpec {
@@ -104,40 +98,6 @@ export class Cargo {
         return artifacts[0].fileName;
     }
 
-    async crates(): Promise<Crate[]> {
-        const pathToCargo = await cargoPath();
-        return await new Promise((resolve, reject) => {
-            const crates: Crate[] = [];
-
-            const cargo = cp.spawn(pathToCargo, ["tree", "--prefix", "none"], {
-                stdio: ["ignore", "pipe", "pipe"],
-                cwd: this.rootFolder,
-            });
-            const rl = readline.createInterface({ input: cargo.stdout });
-            rl.on("line", (line) => {
-                const match = line.match(TREE_LINE_PATTERN);
-                if (match) {
-                    const name = match[1];
-                    const version = match[2];
-                    const extraInfo = match[3];
-                    // ignore duplicates '(*)' and path dependencies
-                    if (this.shouldIgnore(extraInfo)) {
-                        return;
-                    }
-                    crates.push({ name, version });
-                }
-            });
-            cargo.on("exit", (exitCode, _) => {
-                if (exitCode === 0) resolve(crates);
-                else reject(new Error(`exit code: ${exitCode}.`));
-            });
-        });
-    }
-
-    private shouldIgnore(extraInfo: string): boolean {
-        return extraInfo !== undefined && (extraInfo === "*" || path.isAbsolute(extraInfo));
-    }
-
     private async runCargo(
         cargoArgs: string[],
         onStdoutJson: (obj: any) => void,
@@ -169,29 +129,6 @@ export class Cargo {
     }
 }
 
-export async function activeToolchain(): Promise<string> {
-    const pathToRustup = await rustupPath();
-    return await new Promise((resolve, reject) => {
-        const execution = cp.spawn(pathToRustup, ["show", "active-toolchain"], {
-            stdio: ["ignore", "pipe", "pipe"],
-            cwd: os.homedir(),
-        });
-        const rl = readline.createInterface({ input: execution.stdout });
-
-        let currToolchain: string | undefined = undefined;
-        rl.on("line", (line) => {
-            const match = line.match(TOOLCHAIN_PATTERN);
-            if (match) {
-                currToolchain = match[1];
-            }
-        });
-        execution.on("exit", (exitCode, _) => {
-            if (exitCode === 0 && currToolchain) resolve(currToolchain);
-            else reject(new Error(`exit code: ${exitCode}.`));
-        });
-    });
-}
-
 /** Mirrors `project_model::sysroot::discover_sysroot_dir()` implementation*/
 export async function getSysroot(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
@@ -210,16 +147,6 @@ export async function getRustcId(dir: string): Promise<string> {
     return rx.exec(data)![1];
 }
 
-export async function getRustcVersion(dir: string): Promise<string> {
-    const rustcPath = await getPathForExecutable("rustc");
-
-    // do not memoize the result because the toolchain may change between runs
-    const data = await execute(`${rustcPath} -V`, { cwd: dir });
-    const rx = /(\d\.\d+\.\d+)/;
-
-    return rx.exec(data)![1];
-}
-
 /** Mirrors `toolchain::cargo()` implementation */
 export function cargoPath(): Promise<string> {
     return getPathForExecutable("cargo");
-- 
cgit 1.4.1-3-g733a5


From d01fc6405b45ed0fafd68f0f874068ed404ab976 Mon Sep 17 00:00:00 2001
From: bruno-ortiz <brunortiz11@gmail.com>
Date: Fri, 25 Feb 2022 21:37:55 -0300
Subject: Creating rust dependencies tree view

---
 editors/code/package.json     | 10 ++++-
 editors/code/src/commands.ts  |  2 +-
 editors/code/src/ctx.ts       | 10 +++--
 editors/code/src/toolchain.ts | 99 +++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 115 insertions(+), 6 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index 0efc191d748..b009e381ec9 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -285,6 +285,14 @@
                 "title": "Clear flycheck diagnostics",
                 "category": "rust-analyzer"
             },
+            {
+                "command": "rust-analyzer.revealDependency",
+                "title": "Reveal File"
+            },
+            {
+                "command": "rust-analyzer.openFile",
+                "title": "Open File"
+            },
             {
                 "command": "rust-analyzer.revealDependency",
                 "title": "Reveal File"
@@ -1975,4 +1983,4 @@
             }
         ]
     }
-}
+}
\ No newline at end of file
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 7fe32754c90..fb6778b687f 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -8,7 +8,7 @@ import { applySnippetWorkspaceEdit, applySnippetTextEdits } from "./snippets";
 import { spawnSync } from "child_process";
 import { RunnableQuickPick, selectRunnable, createTask, createArgs } from "./run";
 import { AstInspector } from "./ast_inspector";
-import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor, RustEditor } from "./util";
+import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor, RustEditor } from './util';
 import { startDebugSession, makeDebugConfig } from "./debug";
 import { LanguageClient } from "vscode-languageclient/node";
 import { LINKED_COMMANDS } from "./client";
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index d62716c26db..ce70dfd2f66 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -3,8 +3,8 @@ import * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 import * as path from "path";
 
-import {Config, prepareVSCodeConfig} from "./config";
-import {createClient} from "./client";
+import {Config, prepareVSCodeConfig} from './config';
+import {createClient} from './client';
 import {
     executeDiscoverProject,
     isRustDocument,
@@ -12,8 +12,10 @@ import {
     LazyOutputChannel,
     log,
     RustEditor,
-} from "./util";
-import {ServerStatusParams} from "./lsp_ext";
+} from './util';
+import {ServerStatusParams} from './lsp_ext';
+import { Dependency, DependencyFile, RustDependenciesProvider, DependencyId } from './dependencies_provider';
+import { execRevealDependency } from './commands';
 import {
     Dependency,
     DependencyFile,
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 771f6bcba45..6b40cb678c3 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -98,6 +98,43 @@ export class Cargo {
         return artifacts[0].fileName;
     }
 
+    async crates(): Promise<Crate[]> {
+        const pathToCargo = await cargoPath();
+        return await new Promise((resolve, reject) => {
+            const crates: Crate[] = [];
+
+            const cargo = cp.spawn(pathToCargo, ['tree', '--prefix', 'none'], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd: this.rootFolder
+            });
+            const rl = readline.createInterface({ input: cargo.stdout });
+            rl.on('line', line => {
+                const match = line.match(TREE_LINE_PATTERN);
+                if (match) {
+                    const name = match[1];
+                    const version = match[2];
+                    const extraInfo = match[3];
+                    // ignore duplicates '(*)' and path dependencies
+                    if (this.shouldIgnore(extraInfo)) {
+                        return;
+                    }
+                    crates.push({ name, version });
+                }
+            });
+            cargo.on('exit', (exitCode, _) => {
+                if (exitCode === 0)
+                    resolve(crates);
+                else
+                    reject(new Error(`exit code: ${exitCode}.`));
+            });
+
+        });
+    }
+
+    private shouldIgnore(extraInfo: string): boolean {
+        return extraInfo !== undefined && (extraInfo === '*' || path.isAbsolute(extraInfo));
+    }
+
     private async runCargo(
         cargoArgs: string[],
         onStdoutJson: (obj: any) => void,
@@ -129,6 +166,58 @@ export class Cargo {
     }
 }
 
+export async function activeToolchain(): Promise<string> {
+    const pathToRustup = await rustupPath();
+    return await new Promise((resolve, reject) => {
+        const execution = cp.spawn(pathToRustup, ['show', 'active-toolchain'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            cwd: os.homedir()
+        });
+        const rl = readline.createInterface({ input: execution.stdout });
+
+        let currToolchain: string | undefined = undefined;
+        rl.on('line', line => {
+            const match = line.match(TOOLCHAIN_PATTERN);
+            if (match) {
+                currToolchain = match[1];
+            }
+        });
+        execution.on('exit', (exitCode, _) => {
+            if (exitCode === 0 && currToolchain)
+                resolve(currToolchain);
+            else
+                reject(new Error(`exit code: ${exitCode}.`));
+        });
+
+    });
+}
+
+export async function rustVersion(): Promise<string> {
+    const pathToRustup = await rustupPath();
+    return await new Promise((resolve, reject) => {
+        const execution = cp.spawn(pathToRustup, ['show', 'active-toolchain'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            cwd: os.homedir()
+        });
+        const rl = readline.createInterface({ input: execution.stdout });
+
+        let currToolchain: string | undefined = undefined;
+        rl.on('line', line => {
+            const match = line.match(TOOLCHAIN_PATTERN);
+            if (match) {
+                currToolchain = match[1];
+            }
+        });
+        execution.on('exit', (exitCode, _) => {
+            if (exitCode === 1 && currToolchain)
+                resolve(currToolchain);
+            else
+                reject(new Error(`exit code: ${exitCode}.`));
+        });
+
+    });
+}
+
 /** Mirrors `project_model::sysroot::discover_sysroot_dir()` implementation*/
 export async function getSysroot(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
@@ -147,6 +236,16 @@ export async function getRustcId(dir: string): Promise<string> {
     return rx.exec(data)![1];
 }
 
+export async function getRustcVersion(dir: string): Promise<string> {
+    const rustcPath = await getPathForExecutable("rustc");
+
+    // do not memoize the result because the toolchain may change between runs
+    const data = await execute(`${rustcPath} -V`, { cwd: dir });
+    const rx = /(\d\.\d+\.\d+)/;
+
+    return rx.exec(data)![1];
+}
+
 /** Mirrors `toolchain::cargo()` implementation */
 export function cargoPath(): Promise<string> {
     return getPathForExecutable("cargo");
-- 
cgit 1.4.1-3-g733a5


From f8215dd42695e8f0b9e02f65986c6dc6933aab0a Mon Sep 17 00:00:00 2001
From: bruno-ortiz <brunortiz11@gmail.com>
Date: Fri, 25 Feb 2022 21:53:47 -0300
Subject: fixing stblib loading

---
 editors/code/src/dependencies_provider.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 195f41417dd..cee9d17584a 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -79,7 +79,8 @@ export class RustDependenciesProvider
         const deps = crates.map((crate) => {
             const dep = this.toDep(crate.name, crate.version, crate.path);
             this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
-            return dep;
+            this.dependenciesMap[stdlib.dependencyPath.toLowerCase()] = stdlib;
+    return dep;
         });
         return deps;
     }
-- 
cgit 1.4.1-3-g733a5


From ee54c6558dff4307922eae4793850596bb35bcfc Mon Sep 17 00:00:00 2001
From: bruno-ortiz <brunortiz11@gmail.com>
Date: Fri, 25 Feb 2022 22:37:09 -0300
Subject: fixing linting problemas

---
 editors/code/src/dependencies_provider.ts | 66 +++++++++++++++++--------------
 1 file changed, 36 insertions(+), 30 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index cee9d17584a..028a2573cc2 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -5,13 +5,15 @@ import { CtxInit } from "./ctx";
 import * as ra from "./lsp_ext";
 import { FetchDependencyGraphResult } from "./lsp_ext";
 
-export class RustDependenciesProvider
-    implements vscode.TreeDataProvider<Dependency | DependencyFile> {
-    dependenciesMap: { [id: string]: Dependency | DependencyFile };
-    ctx: CtxInit;
 
-    constructor(private readonly workspaceRoot: string, ctx: CtxInit) {
-        this.dependenciesMap = {};
+
+export class RustDependenciesProvider implements vscode.TreeDataProvider<Dependency | DependencyFile>{
+
+    dependenciesMap: { [id: string]: Dependency | DependencyFile };ctx: CtxInit;
+
+    constructor(
+        private readonly workspaceRoot: string,ctx: CtxInit) {
+    this.dependenciesMap = {};
         this.ctx = ctx;
     }
 
@@ -47,25 +49,31 @@ export class RustDependenciesProvider
         return element;
     }
 
-    getChildren(
-        element?: Dependency | DependencyFile
-    ): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
+    getChildren(element?: Dependency | DependencyFile): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
         return new Promise((resolve, _reject) => {
             if (!this.workspaceRoot) {
                 void vscode.window.showInformationMessage("No dependency in empty workspace");
                 return Promise.resolve([]);
             }
+
             if (element) {
                 const files = fs.readdirSync(element.dependencyPath).map((fileName) => {
                     const filePath = fspath.join(element.dependencyPath, fileName);
                     const collapsibleState = fs.lstatSync(filePath).isDirectory()
                         ? vscode.TreeItemCollapsibleState.Collapsed
-                        : vscode.TreeItemCollapsibleState.None;
-                    const dep = new DependencyFile(fileName, filePath, element, collapsibleState);
+                        :vscode.TreeItemCollapsibleState.None;
+                    const dep = new DependencyFile(
+                        fileName,
+                        filePath,
+                        element,
+                        collapsibleState);
+
                     this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
                     return dep;
                 });
-                return resolve(files);
+                return resolve(
+                    files
+                );
             } else {
                 return resolve(this.getRootDependencies());
             }
@@ -75,25 +83,24 @@ export class RustDependenciesProvider
     private async getRootDependencies(): Promise<Dependency[]> {
         const dependenciesResult: FetchDependencyGraphResult = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
         const crates = dependenciesResult.crates;
-
         const deps = crates.map((crate) => {
-            const dep = this.toDep(crate.name, crate.version, crate.path);
+        const dep = this.toDep(crate.name, crate.version, crate.path);
             this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
-            this.dependenciesMap[stdlib.dependencyPath.toLowerCase()] = stdlib;
-    return dep;
+        this.dependenciesMap[stdlib.dependencyPath.toLowerCase()] = stdlib;
+        return dep;
         });
         return deps;
     }
 
-    private toDep(moduleName: string, version: string, path: string): Dependency {
-        // const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
-        return new Dependency(
-            moduleName,
-            version,
-            path,
-            vscode.TreeItemCollapsibleState.Collapsed
-        );
-    }
+    private toDep(moduleName: string, version: string, path: string): Dependency  {
+            //const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
+            return new Dependency(
+                moduleName,
+                version,
+                path,
+                vscode.TreeItemCollapsibleState.Collapsed
+            );
+        }
 }
 
 export class Dependency extends vscode.TreeItem {
@@ -111,6 +118,7 @@ export class Dependency extends vscode.TreeItem {
 }
 
 export class DependencyFile extends vscode.TreeItem {
+
     constructor(
         readonly label: string,
         readonly dependencyPath: string,
@@ -121,13 +129,11 @@ export class DependencyFile extends vscode.TreeItem {
         const isDir = fs.lstatSync(this.dependencyPath).isDirectory();
         this.id = this.dependencyPath.toLowerCase();
         if (!isDir) {
-            this.command = {
-                command: "vscode.open",
+            this.command = { command: "vscode.open",
                 title: "Open File",
                 arguments: [vscode.Uri.file(this.dependencyPath)],
-            };
-        }
-    }
+        };
+    }}
 }
 
 export type DependencyId = { id: string };
-- 
cgit 1.4.1-3-g733a5


From d1721b11e923df58489578b48fbc15105e960aa4 Mon Sep 17 00:00:00 2001
From: bruno-ortiz <brunortiz11@gmail.com>
Date: Sat, 26 Feb 2022 11:17:10 -0300
Subject: removing unused function

---
 editors/code/src/toolchain.ts | 26 --------------------------
 1 file changed, 26 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 6b40cb678c3..5fc5d0ddbdf 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -192,32 +192,6 @@ export async function activeToolchain(): Promise<string> {
     });
 }
 
-export async function rustVersion(): Promise<string> {
-    const pathToRustup = await rustupPath();
-    return await new Promise((resolve, reject) => {
-        const execution = cp.spawn(pathToRustup, ['show', 'active-toolchain'], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            cwd: os.homedir()
-        });
-        const rl = readline.createInterface({ input: execution.stdout });
-
-        let currToolchain: string | undefined = undefined;
-        rl.on('line', line => {
-            const match = line.match(TOOLCHAIN_PATTERN);
-            if (match) {
-                currToolchain = match[1];
-            }
-        });
-        execution.on('exit', (exitCode, _) => {
-            if (exitCode === 1 && currToolchain)
-                resolve(currToolchain);
-            else
-                reject(new Error(`exit code: ${exitCode}.`));
-        });
-
-    });
-}
-
 /** Mirrors `project_model::sysroot::discover_sysroot_dir()` implementation*/
 export async function getSysroot(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
-- 
cgit 1.4.1-3-g733a5


From af999f152bcec9a0fb9c792bbb14eba093ddeec8 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 17 Jul 2022 17:38:56 +0200
Subject: Reformat VSCode client code

---
 editors/code/src/commands.ts              |  2 +-
 editors/code/src/ctx.ts                   | 17 +++++++++------
 editors/code/src/dependencies_provider.ts | 22 ++++++++-----------
 editors/code/src/toolchain.ts             | 36 +++++++++++++------------------
 4 files changed, 36 insertions(+), 41 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index fb6778b687f..7fe32754c90 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -8,7 +8,7 @@ import { applySnippetWorkspaceEdit, applySnippetTextEdits } from "./snippets";
 import { spawnSync } from "child_process";
 import { RunnableQuickPick, selectRunnable, createTask, createArgs } from "./run";
 import { AstInspector } from "./ast_inspector";
-import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor, RustEditor } from './util';
+import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor, RustEditor } from "./util";
 import { startDebugSession, makeDebugConfig } from "./debug";
 import { LanguageClient } from "vscode-languageclient/node";
 import { LINKED_COMMANDS } from "./client";
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index ce70dfd2f66..ea42b249ff9 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -3,8 +3,8 @@ import * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 import * as path from "path";
 
-import {Config, prepareVSCodeConfig} from './config';
-import {createClient} from './client';
+import {Config, prepareVSCodeConfig} from "./config";
+import {createClient} from "./client";
 import {
     executeDiscoverProject,
     isRustDocument,
@@ -12,10 +12,15 @@ import {
     LazyOutputChannel,
     log,
     RustEditor,
-} from './util';
-import {ServerStatusParams} from './lsp_ext';
-import { Dependency, DependencyFile, RustDependenciesProvider, DependencyId } from './dependencies_provider';
-import { execRevealDependency } from './commands';
+} from "./util";
+import {ServerStatusParams} from "./lsp_ext";
+import {
+    Dependency,
+    DependencyFile,
+    RustDependenciesProvider,
+    DependencyId,
+} from "./dependencies_provider";
+import { execRevealDependency } from "./commands";
 import {
     Dependency,
     DependencyFile,
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 028a2573cc2..18a96be1248 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -7,7 +7,9 @@ import { FetchDependencyGraphResult } from "./lsp_ext";
 
 
 
-export class RustDependenciesProvider implements vscode.TreeDataProvider<Dependency | DependencyFile>{
+export class RustDependenciesProvider
+    implements vscode.TreeDataProvider<Dependency | DependencyFile>
+{
 
     dependenciesMap: { [id: string]: Dependency | DependencyFile };ctx: CtxInit;
 
@@ -49,7 +51,9 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
         return element;
     }
 
-    getChildren(element?: Dependency | DependencyFile): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
+    getChildren(
+        element?: Dependency | DependencyFile
+    ): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
         return new Promise((resolve, _reject) => {
             if (!this.workspaceRoot) {
                 void vscode.window.showInformationMessage("No dependency in empty workspace");
@@ -61,19 +65,12 @@ export class RustDependenciesProvider implements vscode.TreeDataProvider<Depende
                     const filePath = fspath.join(element.dependencyPath, fileName);
                     const collapsibleState = fs.lstatSync(filePath).isDirectory()
                         ? vscode.TreeItemCollapsibleState.Collapsed
-                        :vscode.TreeItemCollapsibleState.None;
-                    const dep = new DependencyFile(
-                        fileName,
-                        filePath,
-                        element,
-                        collapsibleState);
-
+                        : vscode.TreeItemCollapsibleState.None;
+                    const dep = new DependencyFile(fileName, filePath, element, collapsibleState);
                     this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
                     return dep;
                 });
-                return resolve(
-                    files
-                );
+                return resolve(files);
             } else {
                 return resolve(this.getRootDependencies());
             }
@@ -118,7 +115,6 @@ export class Dependency extends vscode.TreeItem {
 }
 
 export class DependencyFile extends vscode.TreeItem {
-
     constructor(
         readonly label: string,
         readonly dependencyPath: string,
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 5fc5d0ddbdf..2d23e8c35ed 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -103,12 +103,12 @@ export class Cargo {
         return await new Promise((resolve, reject) => {
             const crates: Crate[] = [];
 
-            const cargo = cp.spawn(pathToCargo, ['tree', '--prefix', 'none'], {
-                stdio: ['ignore', 'pipe', 'pipe'],
-                cwd: this.rootFolder
+            const cargo = cp.spawn(pathToCargo, ["tree", "--prefix", "none"], {
+                stdio: ["ignore", "pipe", "pipe"],
+                cwd: this.rootFolder,
             });
             const rl = readline.createInterface({ input: cargo.stdout });
-            rl.on('line', line => {
+            rl.on("line", (line) => {
                 const match = line.match(TREE_LINE_PATTERN);
                 if (match) {
                     const name = match[1];
@@ -121,18 +121,15 @@ export class Cargo {
                     crates.push({ name, version });
                 }
             });
-            cargo.on('exit', (exitCode, _) => {
-                if (exitCode === 0)
-                    resolve(crates);
-                else
-                    reject(new Error(`exit code: ${exitCode}.`));
+            cargo.on("exit", (exitCode, _) => {
+                if (exitCode === 0) resolve(crates);
+                else reject(new Error(`exit code: ${exitCode}.`));
             });
-
         });
     }
 
     private shouldIgnore(extraInfo: string): boolean {
-        return extraInfo !== undefined && (extraInfo === '*' || path.isAbsolute(extraInfo));
+        return extraInfo !== undefined && (extraInfo === "*" || path.isAbsolute(extraInfo));
     }
 
     private async runCargo(
@@ -169,26 +166,23 @@ export class Cargo {
 export async function activeToolchain(): Promise<string> {
     const pathToRustup = await rustupPath();
     return await new Promise((resolve, reject) => {
-        const execution = cp.spawn(pathToRustup, ['show', 'active-toolchain'], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            cwd: os.homedir()
+        const execution = cp.spawn(pathToRustup, ["show", "active-toolchain"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            cwd: os.homedir(),
         });
         const rl = readline.createInterface({ input: execution.stdout });
 
         let currToolchain: string | undefined = undefined;
-        rl.on('line', line => {
+        rl.on("line", (line) => {
             const match = line.match(TOOLCHAIN_PATTERN);
             if (match) {
                 currToolchain = match[1];
             }
         });
-        execution.on('exit', (exitCode, _) => {
-            if (exitCode === 0 && currToolchain)
-                resolve(currToolchain);
-            else
-                reject(new Error(`exit code: ${exitCode}.`));
+        execution.on("exit", (exitCode, _) => {
+            if (exitCode === 0 && currToolchain) resolve(currToolchain);
+            else reject(new Error(`exit code: ${exitCode}.`));
         });
-
     });
 }
 
-- 
cgit 1.4.1-3-g733a5


From 299382dacd53a4a19728d9e125cd490b1077c985 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Sun, 17 Jul 2022 18:05:55 +0200
Subject: WIP: Add lsp-ext scaffold

---
 crates/rust-analyzer/src/main_loop.rs     |  1 +
 editors/code/src/dependencies_provider.ts | 10 +++++++---
 editors/code/src/lsp_ext.ts               | 16 ++++++++++++++++
 3 files changed, 24 insertions(+), 3 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 7a81a18f4af..5d3aca29b53 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -655,6 +655,7 @@ impl GlobalState {
             .on_sync_mut::<lsp_ext::ReloadWorkspace>(handlers::handle_workspace_reload)
             .on_sync_mut::<lsp_ext::RebuildProcMacros>(handlers::handle_proc_macros_rebuild)
             .on_sync_mut::<lsp_ext::MemoryUsage>(handlers::handle_memory_usage)
+            .on_sync_mut::<lsp_ext::FetchDependencyGraph>(handlers::fetch_dependency_graph)
             .on_sync_mut::<lsp_ext::ShuffleCrateGraph>(handlers::handle_shuffle_crate_graph)
             .on_sync::<lsp_ext::JoinLines>(handlers::handle_join_lines)
             .on_sync::<lsp_ext::OnEnter>(handlers::handle_on_enter)
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 18a96be1248..f2838af6e06 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -4,6 +4,9 @@ import * as fs from "fs";
 import { CtxInit } from "./ctx";
 import * as ra from "./lsp_ext";
 import { FetchDependencyGraphResult } from "./lsp_ext";
+import { Ctx } from "./ctx";
+import { setFlagsFromString } from "v8";
+import * as ra from "./lsp_ext";
 
 
 
@@ -13,9 +16,8 @@ export class RustDependenciesProvider
 
     dependenciesMap: { [id: string]: Dependency | DependencyFile };ctx: CtxInit;
 
-    constructor(
-        private readonly workspaceRoot: string,ctx: CtxInit) {
-    this.dependenciesMap = {};
+    constructor(private readonly workspaceRoot: string,ctx: CtxInit) {
+        this.dependenciesMap = {};
         this.ctx = ctx;
     }
 
@@ -78,6 +80,8 @@ export class RustDependenciesProvider
     }
 
     private async getRootDependencies(): Promise<Dependency[]> {
+        const crates = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
+
         const dependenciesResult: FetchDependencyGraphResult = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
         const crates = dependenciesResult.crates;
         const deps = crates.map((crate) => {
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 1a887b37201..f066a1c6548 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -86,6 +86,22 @@ export const fetchDependencyGraph = new lc.RequestType<
     void
 >("rust-analyzer/fetchDependencyGraph");
 
+export interface FetchDependencyGraphParams {}
+
+export interface FetchDependencyGraphResult {
+    crates: {
+        name: string;
+        version: string;
+        path: string;
+    }[];
+}
+
+export const fetchDependencyGraph = new lc.RequestType<
+    FetchDependencyGraphParams,
+    FetchDependencyGraphResult,
+    void
+>("rust-analyzer/fetchDependencyGraph");
+
 export type ExpandMacroParams = {
     textDocument: lc.TextDocumentIdentifier;
     position: lc.Position;
-- 
cgit 1.4.1-3-g733a5


From fc57339fdf2566a7e149918a37d31ffd6c664e7b Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Sun, 2 Apr 2023 22:06:15 -0300
Subject: removing unused code

---
 editors/code/src/toolchain.ts | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 2d23e8c35ed..8c2e55bcc26 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -3,9 +3,7 @@ import * as os from "os";
 import * as path from "path";
 import * as readline from "readline";
 import * as vscode from "vscode";
-import { execute, log, memoizeAsync } from "./util";
-
-const TOOLCHAIN_PATTERN = new RegExp(/(.*)\s\(.*\)/);
+import {execute, log, memoizeAsync} from "./util";
 
 interface CompilationArtifact {
     fileName: string;
@@ -24,7 +22,7 @@ export class Cargo {
         readonly rootFolder: string,
         readonly output: vscode.OutputChannel,
         readonly env: Record<string, string>
-    ) { }
+    ) {}
 
     // Made public for testing purposes
     static artifactSpec(args: readonly string[]): ArtifactSpec {
@@ -44,7 +42,7 @@ export class Cargo {
             }
         }
 
-        const result: ArtifactSpec = { cargoArgs: cargoArgs };
+        const result: ArtifactSpec = {cargoArgs: cargoArgs};
         if (cargoArgs[0] === "test" || cargoArgs[0] === "bench") {
             // for instance, `crates\rust-analyzer\tests\heavy_tests\main.rs` tests
             // produce 2 artifacts: {"kind": "bin"} and {"kind": "test"}
@@ -149,7 +147,7 @@ export class Cargo {
 
             cargo.stderr.on("data", (chunk) => onStderrString(chunk.toString()));
 
-            const rl = readline.createInterface({ input: cargo.stdout });
+            const rl = readline.createInterface({input: cargo.stdout});
             rl.on("line", (line) => {
                 const message = JSON.parse(line);
                 onStdoutJson(message);
@@ -191,14 +189,14 @@ export async function getSysroot(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
 
     // do not memoize the result because the toolchain may change between runs
-    return await execute(`${rustcPath} --print sysroot`, { cwd: dir });
+    return await execute(`${rustcPath} --print sysroot`, {cwd: dir});
 }
 
 export async function getRustcId(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
 
     // do not memoize the result because the toolchain may change between runs
-    const data = await execute(`${rustcPath} -V -v`, { cwd: dir });
+    const data = await execute(`${rustcPath} -V -v`, {cwd: dir});
     const rx = /commit-hash:\s(.*)$/m;
 
     return rx.exec(data)![1];
@@ -219,11 +217,6 @@ export function cargoPath(): Promise<string> {
     return getPathForExecutable("cargo");
 }
 
-/** Mirrors `toolchain::cargo()` implementation */
-export function rustupPath(): Promise<string> {
-    return getPathForExecutable("rustup");
-}
-
 /** Mirrors `toolchain::get_path_for_executable()` implementation */
 export const getPathForExecutable = memoizeAsync(
     // We apply caching to decrease file-system interactions
-- 
cgit 1.4.1-3-g733a5


From 061940dad905e1a439b1eaead3342276294c4a4c Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Sun, 2 Apr 2023 22:37:07 -0300
Subject: running prettier

---
 editors/code/src/ctx.ts                   |  43 ++++++-------
 editors/code/src/dependencies_provider.ts |  22 +++----
 editors/code/src/main.ts                  | 102 +++++++++++++++---------------
 editors/code/src/toolchain.ts             |  10 +--
 4 files changed, 86 insertions(+), 91 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index ea42b249ff9..69347522b86 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -3,8 +3,8 @@ import * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 import * as path from "path";
 
-import {Config, prepareVSCodeConfig} from "./config";
-import {createClient} from "./client";
+import { Config, prepareVSCodeConfig } from "./config";
+import { createClient } from "./client";
 import {
     executeDiscoverProject,
     isRustDocument,
@@ -13,7 +13,7 @@ import {
     log,
     RustEditor,
 } from "./util";
-import {ServerStatusParams} from "./lsp_ext";
+import { ServerStatusParams } from "./lsp_ext";
 import {
     Dependency,
     DependencyFile,
@@ -27,10 +27,10 @@ import {
     RustDependenciesProvider,
     DependencyId,
 } from "./dependencies_provider";
-import {execRevealDependency} from "./commands";
-import {PersistentState} from "./persistent_state";
-import {bootstrap} from "./bootstrap";
-import {ExecOptions} from "child_process";
+import { execRevealDependency } from "./commands";
+import { PersistentState } from "./persistent_state";
+import { bootstrap } from "./bootstrap";
+import { ExecOptions } from "child_process";
 
 // We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
 // only those are in use. We use "Empty" to represent these scenarios
@@ -39,12 +39,12 @@ import {ExecOptions} from "child_process";
 export type Workspace =
     | { kind: "Empty" }
     | {
-    kind: "Workspace Folder";
-}
+          kind: "Workspace Folder";
+      }
     | {
-    kind: "Detached Files";
-    files: vscode.TextDocument[];
-};
+          kind: "Detached Files";
+          files: vscode.TextDocument[];
+      };
 
 export function fetchWorkspace(): Workspace {
     const folders = (vscode.workspace.workspaceFolders || []).filter(
@@ -56,12 +56,12 @@ export function fetchWorkspace(): Workspace {
 
     return folders.length === 0
         ? rustDocuments.length === 0
-            ? {kind: "Empty"}
+            ? { kind: "Empty" }
             : {
-                kind: "Detached Files",
-                files: rustDocuments,
-            }
-        : {kind: "Workspace Folder"};
+                  kind: "Detached Files",
+                  files: rustDocuments,
+              }
+        : { kind: "Workspace Folder" };
 }
 
 export async function discoverWorkspace(
@@ -116,7 +116,7 @@ export class Ctx {
     constructor(
         readonly extCtx: vscode.ExtensionContext,
         commandFactories: Record<string, CommandFactory>,
-        workspace: Workspace,
+        workspace: Workspace
     ) {
         extCtx.subscriptions.push(this);
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
@@ -128,8 +128,7 @@ export class Ctx {
         this.state = new PersistentState(extCtx.globalState);
         this.config = new Config(extCtx);
 
-        this.updateCommands("disable"
-        );
+        this.updateCommands("disable");
         this.setServerStatus({
             health: "stopped",
         });
@@ -198,7 +197,7 @@ export class Ctx {
             const newEnv = Object.assign({}, process.env, this.config.serverExtraEnv);
             const run: lc.Executable = {
                 command: this._serverPath,
-                options: {env: newEnv},
+                options: { env: newEnv },
             };
             const serverOptions = {
                 run,
@@ -276,7 +275,7 @@ export class Ctx {
     private prepareTreeDependenciesView(client: lc.LanguageClient) {
         const ctxInit: CtxInit = {
             ...this,
-            client: client
+            client: client,
         };
         const rootPath = vscode.workspace.workspaceFolders![0].uri.fsPath;
         this._dependencies = new RustDependenciesProvider(rootPath, ctxInit);
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index f2838af6e06..3713250b8fc 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -13,8 +13,8 @@ import * as ra from "./lsp_ext";
 export class RustDependenciesProvider
     implements vscode.TreeDataProvider<Dependency | DependencyFile>
 {
-
-    dependenciesMap: { [id: string]: Dependency | DependencyFile };ctx: CtxInit;
+    dependenciesMap: { [id: string]: Dependency | DependencyFile };
+    ctx: CtxInit;
 
     constructor(private readonly workspaceRoot: string,ctx: CtxInit) {
         this.dependenciesMap = {};
@@ -82,7 +82,10 @@ export class RustDependenciesProvider
     private async getRootDependencies(): Promise<Dependency[]> {
         const crates = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
 
-        const dependenciesResult: FetchDependencyGraphResult = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
+        const dependenciesResult: FetchDependencyGraphResult = await this.ctx.client.sendRequest(
+            ra.fetchDependencyGraph,
+            {}
+        );
         const crates = dependenciesResult.crates;
         const deps = crates.map((crate) => {
         const dep = this.toDep(crate.name, crate.version, crate.path);
@@ -93,15 +96,10 @@ export class RustDependenciesProvider
         return deps;
     }
 
-    private toDep(moduleName: string, version: string, path: string): Dependency  {
-            //const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
-            return new Dependency(
-                moduleName,
-                version,
-                path,
-                vscode.TreeItemCollapsibleState.Collapsed
-            );
-        }
+    private toDep(moduleName: string, version: string, path: string): Dependency {
+        // const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
+        return new Dependency(moduleName, version, path, vscode.TreeItemCollapsibleState.Collapsed);
+    }
 }
 
 export class Dependency extends vscode.TreeItem {
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 774600f6c39..be9bc9d363c 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -2,10 +2,10 @@ import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
 
 import * as commands from "./commands";
-import {CommandFactory, Ctx, fetchWorkspace} from "./ctx";
+import { CommandFactory, Ctx, fetchWorkspace } from "./ctx";
 import * as diagnostics from "./diagnostics";
-import {activateTaskProvider} from "./tasks";
-import {setContextValue} from "./util";
+import { activateTaskProvider } from "./tasks";
+import { setContextValue } from "./util";
 
 const RUST_PROJECT_CONTEXT_NAME = "inRustProject";
 
@@ -24,12 +24,11 @@ export async function activate(
         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);
     }
 
     const ctx = new Ctx(context, createCommands(), fetchWorkspace());
@@ -119,7 +118,7 @@ function createCommands(): Record<string, CommandFactory> {
     return {
         onEnter: {
             enabled: commands.onEnter,
-            disabled: (_) => () => vscode.commands.executeCommand("default:type", {text: "\n"}),
+            disabled: (_) => () => vscode.commands.executeCommand("default:type", { text: "\n" }),
         },
         restartServer: {
             enabled: (ctx) => async () => {
@@ -145,53 +144,52 @@ function createCommands(): Record<string, CommandFactory> {
                     health: "stopped",
                 });
             },
-            disabled: (_) => async () => {
-            },
+            disabled: (_) => async () => {},
         },
 
-        analyzerStatus: {enabled: commands.analyzerStatus},
-        memoryUsage: {enabled: commands.memoryUsage},
-        shuffleCrateGraph: {enabled: commands.shuffleCrateGraph},
-        reloadWorkspace: {enabled: commands.reloadWorkspace},
-        rebuildProcMacros: {enabled: commands.rebuildProcMacros},
-        addProject: {enabled: commands.addProject},
-        matchingBrace: {enabled: commands.matchingBrace},
-        joinLines: {enabled: commands.joinLines},
-        parentModule: {enabled: commands.parentModule},
-        syntaxTree: {enabled: commands.syntaxTree},
-        viewHir: {enabled: commands.viewHir},
-        viewMir: {enabled: commands.viewMir},
+        analyzerStatus: { enabled: commands.analyzerStatus },
+        memoryUsage: { enabled: commands.memoryUsage },
+        shuffleCrateGraph: { enabled: commands.shuffleCrateGraph },
+        reloadWorkspace: { enabled: commands.reloadWorkspace },
+        rebuildProcMacros: { enabled: commands.rebuildProcMacros },
+        addProject: { enabled: commands.addProject },
+        matchingBrace: { enabled: commands.matchingBrace },
+        joinLines: { enabled: commands.joinLines },
+        parentModule: { enabled: commands.parentModule },
+        syntaxTree: { enabled: commands.syntaxTree },
+        viewHir: { enabled: commands.viewHir },
+        viewMir: { enabled: commands.viewMir },
         interpretFunction: { enabled: commands.interpretFunction },
-        viewFileText: {enabled: commands.viewFileText},
-        viewItemTree: {enabled: commands.viewItemTree},
-        viewCrateGraph: {enabled: commands.viewCrateGraph},
-        viewFullCrateGraph: {enabled: commands.viewFullCrateGraph},
-        expandMacro: {enabled: commands.expandMacro},
-        run: {enabled: commands.run},
-        copyRunCommandLine: {enabled: commands.copyRunCommandLine},
-        debug: {enabled: commands.debug},
-        newDebugConfig: {enabled: commands.newDebugConfig},
-        openDocs: {enabled: commands.openDocs},
-        openCargoToml: {enabled: commands.openCargoToml},
-        peekTests: {enabled: commands.peekTests},
-        moveItemUp: {enabled: commands.moveItemUp},
-        moveItemDown: {enabled: commands.moveItemDown},
-        cancelFlycheck: {enabled: commands.cancelFlycheck},
-        clearFlycheck: {enabled: commands.clearFlycheck},
-        runFlycheck: {enabled: commands.runFlycheck},
-        ssr: {enabled: commands.ssr},
-        serverVersion: {enabled: commands.serverVersion},
+        viewFileText: { enabled: commands.viewFileText },
+        viewItemTree: { enabled: commands.viewItemTree },
+        viewCrateGraph: { enabled: commands.viewCrateGraph },
+        viewFullCrateGraph: { enabled: commands.viewFullCrateGraph },
+        expandMacro: { enabled: commands.expandMacro },
+        run: { enabled: commands.run },
+        copyRunCommandLine: { enabled: commands.copyRunCommandLine },
+        debug: { enabled: commands.debug },
+        newDebugConfig: { enabled: commands.newDebugConfig },
+        openDocs: { enabled: commands.openDocs },
+        openCargoToml: { enabled: commands.openCargoToml },
+        peekTests: { enabled: commands.peekTests },
+        moveItemUp: { enabled: commands.moveItemUp },
+        moveItemDown: { enabled: commands.moveItemDown },
+        cancelFlycheck: { enabled: commands.cancelFlycheck },
+        clearFlycheck: { enabled: commands.clearFlycheck },
+        runFlycheck: { enabled: commands.runFlycheck },
+        ssr: { enabled: commands.ssr },
+        serverVersion: { enabled: commands.serverVersion },
         // Internal commands which are invoked by the server.
-        applyActionGroup: {enabled: commands.applyActionGroup},
-        applySnippetWorkspaceEdit: {enabled: commands.applySnippetWorkspaceEditCommand},
-        debugSingle: {enabled: commands.debugSingle},
-        gotoLocation: {enabled: commands.gotoLocation},
-        linkToCommand: {enabled: commands.linkToCommand},
-        resolveCodeAction: {enabled: commands.resolveCodeAction},
-        runSingle: {enabled: commands.runSingle},
-        showReferences: {enabled: commands.showReferences},
-        triggerParameterHints: {enabled: commands.triggerParameterHints},
-        openLogs: {enabled: commands.openLogs},
-        revealDependency: {enabled: commands.revealDependency}
+        applyActionGroup: { enabled: commands.applyActionGroup },
+        applySnippetWorkspaceEdit: { enabled: commands.applySnippetWorkspaceEditCommand },
+        debugSingle: { enabled: commands.debugSingle },
+        gotoLocation: { enabled: commands.gotoLocation },
+        linkToCommand: { enabled: commands.linkToCommand },
+        resolveCodeAction: { enabled: commands.resolveCodeAction },
+        runSingle: { enabled: commands.runSingle },
+        showReferences: { enabled: commands.showReferences },
+        triggerParameterHints: { enabled: commands.triggerParameterHints },
+        openLogs: { enabled: commands.openLogs },
+        revealDependency: { enabled: commands.revealDependency },
     };
 }
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 8c2e55bcc26..9c5c88c49e5 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -3,7 +3,7 @@ import * as os from "os";
 import * as path from "path";
 import * as readline from "readline";
 import * as vscode from "vscode";
-import {execute, log, memoizeAsync} from "./util";
+import { execute, log, memoizeAsync } from "./util";
 
 interface CompilationArtifact {
     fileName: string;
@@ -42,7 +42,7 @@ export class Cargo {
             }
         }
 
-        const result: ArtifactSpec = {cargoArgs: cargoArgs};
+        const result: ArtifactSpec = { cargoArgs: cargoArgs };
         if (cargoArgs[0] === "test" || cargoArgs[0] === "bench") {
             // for instance, `crates\rust-analyzer\tests\heavy_tests\main.rs` tests
             // produce 2 artifacts: {"kind": "bin"} and {"kind": "test"}
@@ -147,7 +147,7 @@ export class Cargo {
 
             cargo.stderr.on("data", (chunk) => onStderrString(chunk.toString()));
 
-            const rl = readline.createInterface({input: cargo.stdout});
+            const rl = readline.createInterface({ input: cargo.stdout });
             rl.on("line", (line) => {
                 const message = JSON.parse(line);
                 onStdoutJson(message);
@@ -189,14 +189,14 @@ export async function getSysroot(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
 
     // do not memoize the result because the toolchain may change between runs
-    return await execute(`${rustcPath} --print sysroot`, {cwd: dir});
+    return await execute(`${rustcPath} --print sysroot`, { cwd: dir });
 }
 
 export async function getRustcId(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
 
     // do not memoize the result because the toolchain may change between runs
-    const data = await execute(`${rustcPath} -V -v`, {cwd: dir});
+    const data = await execute(`${rustcPath} -V -v`, { cwd: dir });
     const rx = /commit-hash:\s(.*)$/m;
 
     return rx.exec(data)![1];
-- 
cgit 1.4.1-3-g733a5


From 1b8288ff966bcabadf8f15d71511ff96184e81ea Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Tue, 4 Apr 2023 13:47:01 -0300
Subject: Fixing naming from graph to list

---
 crates/ide/src/fetch_crates.rs            | 52 +++++++++++++++++--------------
 crates/rust-analyzer/src/handlers.rs      | 10 +++---
 crates/rust-analyzer/src/lsp_ext.rs       | 14 ++++-----
 crates/rust-analyzer/src/main_loop.rs     |  2 +-
 docs/dev/lsp-extensions.md                |  2 +-
 editors/code/src/dependencies_provider.ts |  8 ++---
 editors/code/src/lsp_ext.ts               | 12 +++----
 7 files changed, 52 insertions(+), 48 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/ide/src/fetch_crates.rs b/crates/ide/src/fetch_crates.rs
index ec6d66d5c43..416082ae73b 100644
--- a/crates/ide/src/fetch_crates.rs
+++ b/crates/ide/src/fetch_crates.rs
@@ -22,16 +22,21 @@ pub(crate) fn fetch_crates(db: &RootDatabase) -> Vec<CrateInfo> {
         .iter()
         .map(|crate_id| &crate_graph[crate_id])
         .filter(|&data| !matches!(data.origin, CrateOrigin::Local { .. }))
-        .map(|data| {
-            let crate_name = crate_name(data);
-            let version = data.version.clone().unwrap_or_else(|| "".to_owned());
-            let crate_path = crate_path(db, data, &crate_name);
-
-            CrateInfo { name: crate_name, version, path: crate_path }
-        })
+        .filter_map(|data| crate_info(data, db))
         .collect()
 }
 
+fn crate_info(data: &ide_db::base_db::CrateData, db: &RootDatabase) -> Option<CrateInfo> {
+    let crate_name = crate_name(data);
+    let crate_path = crate_path(db, data, &crate_name);
+    if let Some(crate_path) = crate_path {
+        let version = data.version.clone().unwrap_or_else(|| "".to_owned());
+        Some(CrateInfo { name: crate_name, version, path: crate_path })
+    } else {
+        None
+    }
+}
+
 fn crate_name(data: &ide_db::base_db::CrateData) -> String {
     data.display_name
         .clone()
@@ -39,27 +44,28 @@ fn crate_name(data: &ide_db::base_db::CrateData) -> String {
         .unwrap_or("unknown".to_string())
 }
 
-fn crate_path(db: &RootDatabase, data: &ide_db::base_db::CrateData, crate_name: &str) -> String {
+fn crate_path(
+    db: &RootDatabase,
+    data: &ide_db::base_db::CrateData,
+    crate_name: &str,
+) -> Option<String> {
     let source_root_id = db.file_source_root(data.root_file_id);
     let source_root = db.source_root(source_root_id);
     let source_root_path = source_root.path_for_file(&data.root_file_id);
-    match source_root_path.cloned() {
-        Some(mut root_path) => {
-            let mut crate_path = "".to_string();
-            while let Some(vfs_path) = root_path.parent() {
-                match vfs_path.name_and_extension() {
-                    Some((name, _)) => {
-                        if name.starts_with(crate_name) {
-                            crate_path = vfs_path.to_string();
-                            break;
-                        }
+    source_root_path.cloned().and_then(|mut root_path| {
+        let mut crate_path = None;
+        while let Some(vfs_path) = root_path.parent() {
+            match vfs_path.name_and_extension() {
+                Some((name, _)) => {
+                    if name.starts_with(crate_name) {
+                        crate_path = Some(vfs_path.to_string());
+                        break;
                     }
-                    None => break,
                 }
-                root_path = vfs_path;
+                None => break,
             }
-            crate_path
+            root_path = vfs_path;
         }
-        None => "".to_owned(),
-    }
+        crate_path
+    })
 }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 2324490e53b..5c966f0f68b 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -9,7 +9,7 @@ use vfs::FileId;
 use crate::{
     global_state::GlobalStateSnapshot, to_proto, Result,
     lsp_ext::{
-        CrateInfoResult, FetchDependencyGraphResult, FetchDependencyGraphParams,
+        CrateInfoResult, FetchDependencyListResult, FetchDependencyListParams,
     },
 };
 
@@ -49,12 +49,12 @@ pub(crate) fn publish_diagnostics(
     Ok(diagnostics)
 }
 
-pub(crate) fn fetch_dependency_graph(
+pub(crate) fn fetch_dependency_list(
     state: GlobalStateSnapshot,
-    _params: FetchDependencyGraphParams,
-) -> Result<FetchDependencyGraphResult> {
+    _params: FetchDependencyListParams,
+) -> Result<FetchDependencyListResult> {
     let crates = state.analysis.fetch_crates()?;
-    Ok(FetchDependencyGraphResult {
+    Ok(FetchDependencyListResult {
         crates: crates
             .into_iter()
             .map(|it| CrateInfoResult { name: it.name, version: it.version, path: it.path })
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 18511da4683..6285578a6ce 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -34,21 +34,21 @@ pub struct CrateInfoResult {
     pub version: String,
     pub path: String,
 }
-pub enum FetchDependencyGraph {}
+pub enum FetchDependencyList {}
 
-impl Request for FetchDependencyGraph {
-    type Params = FetchDependencyGraphParams;
-    type Result = FetchDependencyGraphResult;
-    const METHOD: &'static str = "rust-analyzer/fetchDependencyGraph";
+impl Request for FetchDependencyList {
+    type Params = FetchDependencyListParams;
+    type Result = FetchDependencyListResult;
+    const METHOD: &'static str = "rust-analyzer/fetchDependencyList";
 }
 
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct FetchDependencyGraphParams {}
+pub struct FetchDependencyListParams {}
 
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct FetchDependencyGraphResult {
+pub struct FetchDependencyListResult {
     pub crates: Vec<CrateInfoResult>,
 }
 
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 7a81a18f4af..d3cfc5e40d6 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -660,7 +660,7 @@ impl GlobalState {
             .on_sync::<lsp_ext::OnEnter>(handlers::handle_on_enter)
             .on_sync::<lsp_types::request::SelectionRangeRequest>(handlers::handle_selection_range)
             .on_sync::<lsp_ext::MatchingBrace>(handlers::handle_matching_brace)
-            .on::<lsp_ext::FetchDependencyGraph>(handlers::fetch_dependency_graph)
+            .on::<lsp_ext::FetchDependencyList>(handlers::fetch_dependency_list)
             .on::<lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status)
             .on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)
             .on::<lsp_ext::ViewHir>(handlers::handle_view_hir)
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 41bda554be9..d73ae3d519e 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -855,7 +855,7 @@ export interface Diagnostic {
 
 ## Dependency Tree
 
-**Method:** `rust-analyzer/fetchDependencyGraph`
+**Method:** `rust-analyzer/fetchDependencyList`
 
 **Request:**
 
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 3713250b8fc..2e5ea04922f 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -3,13 +3,12 @@ import * as fspath from "path";
 import * as fs from "fs";
 import { CtxInit } from "./ctx";
 import * as ra from "./lsp_ext";
-import { FetchDependencyGraphResult } from "./lsp_ext";
+import { FetchDependencyListResult } from "./lsp_ext";
 import { Ctx } from "./ctx";
 import { setFlagsFromString } from "v8";
 import * as ra from "./lsp_ext";
 
 
-
 export class RustDependenciesProvider
     implements vscode.TreeDataProvider<Dependency | DependencyFile>
 {
@@ -82,8 +81,8 @@ export class RustDependenciesProvider
     private async getRootDependencies(): Promise<Dependency[]> {
         const crates = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
 
-        const dependenciesResult: FetchDependencyGraphResult = await this.ctx.client.sendRequest(
-            ra.fetchDependencyGraph,
+        const dependenciesResult: FetchDependencyListResult = await this.ctx.client.sendRequest(
+            ra.fetchDependencyList,
             {}
         );
         const crates = dependenciesResult.crates;
@@ -97,7 +96,6 @@ export class RustDependenciesProvider
     }
 
     private toDep(moduleName: string, version: string, path: string): Dependency {
-        // const cratePath = fspath.join(basePath, `${moduleName}-${version}`);
         return new Dependency(moduleName, version, path, vscode.TreeItemCollapsibleState.Collapsed);
     }
 }
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index f066a1c6548..30de5035d63 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -70,9 +70,9 @@ export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>
 
 export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };
 
-export interface FetchDependencyGraphParams {}
+export interface FetchDependencyListParams {}
 
-export interface FetchDependencyGraphResult {
+export interface FetchDependencyListResult {
     crates: {
         name: string;
         version: string;
@@ -80,11 +80,11 @@ export interface FetchDependencyGraphResult {
     }[];
 }
 
-export const fetchDependencyGraph = new lc.RequestType<
-    FetchDependencyGraphParams,
-    FetchDependencyGraphResult,
+export const fetchDependencyList = new lc.RequestType<
+    FetchDependencyListParams,
+    FetchDependencyListResult,
     void
->("rust-analyzer/fetchDependencyGraph");
+>("rust-analyzer/fetchDependencyList");
 
 export interface FetchDependencyGraphParams {}
 
-- 
cgit 1.4.1-3-g733a5


From 8e687f7afb156a7ad2458b7a5aa481b5d7e435d1 Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Wed, 5 Apr 2023 14:57:01 -0300
Subject: improving code to work with multi-workspaces

---
 crates/ide/src/fetch_crates.rs            |  6 +--
 crates/ide/src/lib.rs                     |  4 +-
 editors/code/src/commands.ts              | 70 +++++++++++++++++++++++++------
 editors/code/src/ctx.ts                   |  8 ++--
 editors/code/src/dependencies_provider.ts |  6 ++-
 editors/code/src/util.ts                  | 18 ++++++++
 6 files changed, 89 insertions(+), 23 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/ide/src/fetch_crates.rs b/crates/ide/src/fetch_crates.rs
index 416082ae73b..5750d6b4261 100644
--- a/crates/ide/src/fetch_crates.rs
+++ b/crates/ide/src/fetch_crates.rs
@@ -1,9 +1,9 @@
 use ide_db::{
     base_db::{CrateOrigin, SourceDatabase, SourceDatabaseExt},
-    RootDatabase,
+    FxIndexSet, RootDatabase,
 };
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct CrateInfo {
     pub name: String,
     pub version: String,
@@ -16,7 +16,7 @@ pub struct CrateInfo {
 //
 // |===
 // image::https://user-images.githubusercontent.com/5748995/229394139-2625beab-f4c9-484b-84ed-ad5dee0b1e1a.png[]
-pub(crate) fn fetch_crates(db: &RootDatabase) -> Vec<CrateInfo> {
+pub(crate) fn fetch_crates(db: &RootDatabase) -> FxIndexSet<CrateInfo> {
     let crate_graph = db.crate_graph();
     crate_graph
         .iter()
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 96adb11dcde..24e2aed65a5 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -70,7 +70,7 @@ use ide_db::{
         salsa::{self, ParallelDatabase},
         CrateOrigin, Env, FileLoader, FileSet, SourceDatabase, VfsPath,
     },
-    symbol_index, FxHashMap, LineIndexDatabase,
+    symbol_index, FxHashMap, FxIndexSet, LineIndexDatabase,
 };
 use syntax::SourceFile;
 
@@ -333,7 +333,7 @@ impl Analysis {
         self.with_db(|db| view_crate_graph::view_crate_graph(db, full))
     }
 
-    pub fn fetch_crates(&self) -> Cancellable<Vec<CrateInfo>> {
+    pub fn fetch_crates(&self) -> Cancellable<FxIndexSet<CrateInfo>> {
         self.with_db(|db| fetch_crates::fetch_crates(db))
     }
 
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 7fe32754c90..4393d5fccbc 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -8,7 +8,15 @@ import { applySnippetWorkspaceEdit, applySnippetTextEdits } from "./snippets";
 import { spawnSync } from "child_process";
 import { RunnableQuickPick, selectRunnable, createTask, createArgs } from "./run";
 import { AstInspector } from "./ast_inspector";
-import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor, RustEditor } from "./util";
+import {
+    isRustDocument,
+    isCargoTomlDocument,
+    sleep,
+    isRustEditor,
+    RustEditor,
+    RustDocument,
+    closeDocument,
+} from "./util";
 import { startDebugSession, makeDebugConfig } from "./debug";
 import { LanguageClient } from "vscode-languageclient/node";
 import { LINKED_COMMANDS } from "./client";
@@ -269,27 +277,63 @@ export function openCargoToml(ctx: CtxInit): Cmd {
 
 export function revealDependency(ctx: CtxInit): Cmd {
     return async (editor: RustEditor) => {
-        const rootPath = vscode.workspace.workspaceFolders![0].uri.fsPath;
         const documentPath = editor.document.uri.fsPath;
-        if (documentPath.startsWith(rootPath)) return;
         const dep = ctx.dependencies?.getDependency(documentPath);
         if (dep) {
             await ctx.treeView?.reveal(dep, { select: true, expand: true });
         } else {
-            let documentPath = editor.document.uri.fsPath;
-            const parentChain: DependencyId[] = [{ id: documentPath.toLowerCase() }];
-            do {
-                documentPath = path.dirname(documentPath);
-                parentChain.push({ id: documentPath.toLowerCase() });
-            } while (!ctx.dependencies?.contains(documentPath));
-            parentChain.reverse();
-            for (const idx in parentChain) {
-                await ctx.treeView?.reveal(parentChain[idx], { select: true, expand: true });
-            }
+            await revealParentChain(editor.document, ctx);
         }
     };
 }
 
+/**
+ * This function calculates the parent chain of a given file until it reaches it crate root contained in ctx.dependencies.
+ * This is need because the TreeView is Lazy, so at first it only has the root dependencies: For example if we have the following crates:
+ * - core
+ * - alloc
+ * - std
+ *
+ * if I want to reveal alloc/src/str.rs, I have to:
+
+ * 1. reveal every children of alloc
+ * - core
+ * - alloc\
+ * &emsp;|-beches\
+ * &emsp;|-src\
+ * &emsp;|- ...
+ * - std
+ * 2. reveal every children of src:
+ * core
+ * alloc\
+ * &emsp;|-beches\
+ * &emsp;|-src\
+ * &emsp;&emsp;|- lib.rs\
+ * &emsp;&emsp;|- str.rs <------- FOUND IT!\
+ * &emsp;&emsp;|- ...\
+ * &emsp;|- ...\
+ * std
+ */
+async function revealParentChain(document: RustDocument, ctx: CtxInit) {
+    let documentPath = document.uri.fsPath;
+    const maxDepth = documentPath.split(path.sep).length - 1;
+    const parentChain: DependencyId[] = [{ id: documentPath.toLowerCase() }];
+    do {
+        documentPath = path.dirname(documentPath);
+        parentChain.push({ id: documentPath.toLowerCase() });
+        if (parentChain.length >= maxDepth) {
+            // this is an odd case that can happen when we change a crate version but we'd still have
+            // a open file referencing the old version
+            await closeDocument(document);
+            return;
+        }
+    } while (!ctx.dependencies?.contains(documentPath));
+    parentChain.reverse();
+    for (const idx in parentChain) {
+        await ctx.treeView?.reveal(parentChain[idx], { select: true, expand: true });
+    }
+}
+
 export async function execRevealDependency(e: RustEditor): Promise<void> {
     await vscode.commands.executeCommand("rust-analyzer.revealDependency", e);
 }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 69347522b86..dd2373d5847 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -7,6 +7,7 @@ import { Config, prepareVSCodeConfig } from "./config";
 import { createClient } from "./client";
 import {
     executeDiscoverProject,
+    isDocumentInWorkspace,
     isRustDocument,
     isRustEditor,
     LazyOutputChannel,
@@ -277,15 +278,16 @@ export class Ctx {
             ...this,
             client: client,
         };
-        const rootPath = vscode.workspace.workspaceFolders![0].uri.fsPath;
-        this._dependencies = new RustDependenciesProvider(rootPath, ctxInit);
+        this._dependencies = new RustDependenciesProvider(ctxInit);
         this._treeView = vscode.window.createTreeView("rustDependencies", {
             treeDataProvider: this._dependencies,
             showCollapseAll: true,
         });
 
+        this.pushExtCleanup(this._treeView);
         vscode.window.onDidChangeActiveTextEditor((e) => {
-            if (e && isRustEditor(e)) {
+            // we should skip documents that belong to the current workspace
+            if (e && isRustEditor(e) && !isDocumentInWorkspace(e.document)) {
                 execRevealDependency(e).catch((reason) => {
                     void vscode.window.showErrorMessage(`Dependency error: ${reason}`);
                 });
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 2e5ea04922f..3edbb316814 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -15,7 +15,7 @@ export class RustDependenciesProvider
     dependenciesMap: { [id: string]: Dependency | DependencyFile };
     ctx: CtxInit;
 
-    constructor(private readonly workspaceRoot: string,ctx: CtxInit) {
+    constructor(ctx: CtxInit) {
         this.dependenciesMap = {};
         this.ctx = ctx;
     }
@@ -37,6 +37,7 @@ export class RustDependenciesProvider
     }
 
     refresh(): void {
+        this.dependenciesMap = {};
         this._onDidChangeTreeData.fire();
     }
 
@@ -56,7 +57,7 @@ export class RustDependenciesProvider
         element?: Dependency | DependencyFile
     ): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
         return new Promise((resolve, _reject) => {
-            if (!this.workspaceRoot) {
+            if (!vscode.workspace.workspaceFolders) {
                 void vscode.window.showInformationMessage("No dependency in empty workspace");
                 return Promise.resolve([]);
             }
@@ -108,6 +109,7 @@ export class Dependency extends vscode.TreeItem {
         public readonly collapsibleState: vscode.TreeItemCollapsibleState
     ) {
         super(label, collapsibleState);
+        this.id = this.dependencyPath.toLowerCase();
         this.tooltip = `${this.label}-${this.version}`;
         this.description = this.version;
         this.resourceUri = vscode.Uri.file(dependencyPath);
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 922fbcbcf35..0196b37b8b6 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -112,6 +112,24 @@ export function isRustEditor(editor: vscode.TextEditor): editor is RustEditor {
     return isRustDocument(editor.document);
 }
 
+export function isDocumentInWorkspace(document: RustDocument): boolean {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) {
+        return false;
+    }
+    for (const folder of workspaceFolders) {
+        if (document.uri.fsPath.startsWith(folder.uri.fsPath)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export async function closeDocument(document: RustDocument) {
+    await vscode.window.showTextDocument(document, { preview: true, preserveFocus: false });
+    await vscode.commands.executeCommand("workbench.action.closeActiveEditor");
+}
+
 export function isValidExecutable(path: string): boolean {
     log.debug("Checking availability of a binary at", path);
 
-- 
cgit 1.4.1-3-g733a5


From a3081a67742a67680f7ddef503094e62e2e68c55 Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Sat, 8 Apr 2023 13:07:25 -0300
Subject: Adding crate_root_path to crate_graph

---
 crates/base-db/src/fixture.rs             |  4 ++++
 crates/base-db/src/input.rs               | 13 ++++++++++++
 crates/ide/src/fetch_crates.rs            | 34 ++++---------------------------
 crates/ide/src/lib.rs                     |  1 +
 crates/ide/src/shuffle_crate_graph.rs     |  1 +
 crates/paths/src/lib.rs                   |  7 +++++++
 crates/project-model/src/tests.rs         |  6 ++++++
 crates/project-model/src/workspace.rs     | 32 ++++++++++++++++++++++++++++-
 crates/vfs/src/vfs_path.rs                |  5 +----
 editors/code/src/dependencies_provider.ts |  8 ++++++--
 10 files changed, 74 insertions(+), 37 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/base-db/src/fixture.rs b/crates/base-db/src/fixture.rs
index 1936eabdd9f..cf3be9d07fd 100644
--- a/crates/base-db/src/fixture.rs
+++ b/crates/base-db/src/fixture.rs
@@ -165,6 +165,7 @@ impl ChangeFixture {
                     meta.edition,
                     Some(crate_name.clone().into()),
                     version,
+                    None,
                     meta.cfg,
                     Default::default(),
                     meta.env,
@@ -205,6 +206,7 @@ impl ChangeFixture {
                 Edition::CURRENT,
                 Some(CrateName::new("test").unwrap().into()),
                 None,
+                None,
                 default_cfg,
                 Default::default(),
                 Env::default(),
@@ -249,6 +251,7 @@ impl ChangeFixture {
                 Edition::Edition2021,
                 Some(CrateDisplayName::from_canonical_name("core".to_string())),
                 None,
+                None,
                 Default::default(),
                 Default::default(),
                 Env::default(),
@@ -288,6 +291,7 @@ impl ChangeFixture {
                 Edition::Edition2021,
                 Some(CrateDisplayName::from_canonical_name("proc_macros".to_string())),
                 None,
+                None,
                 Default::default(),
                 Default::default(),
                 Env::default(),
diff --git a/crates/base-db/src/input.rs b/crates/base-db/src/input.rs
index e6d265df675..466e2eab560 100644
--- a/crates/base-db/src/input.rs
+++ b/crates/base-db/src/input.rs
@@ -304,6 +304,7 @@ pub struct CrateData {
     /// For purposes of analysis, crates are anonymous (only names in
     /// `Dependency` matters), this name should only be used for UI.
     pub display_name: Option<CrateDisplayName>,
+    pub crate_root_path: Option<AbsPathBuf>,
     pub cfg_options: CfgOptions,
     /// The cfg options that could be used by the crate
     pub potential_cfg_options: Option<CfgOptions>,
@@ -361,6 +362,7 @@ impl CrateGraph {
         edition: Edition,
         display_name: Option<CrateDisplayName>,
         version: Option<String>,
+        crate_root_path: Option<AbsPathBuf>,
         cfg_options: CfgOptions,
         potential_cfg_options: Option<CfgOptions>,
         env: Env,
@@ -374,6 +376,7 @@ impl CrateGraph {
             edition,
             version,
             display_name,
+            crate_root_path,
             cfg_options,
             potential_cfg_options,
             env,
@@ -740,6 +743,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -753,6 +757,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -766,6 +771,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -793,6 +799,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -806,6 +813,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -830,6 +838,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -843,6 +852,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -856,6 +866,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -880,6 +891,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -893,6 +905,7 @@ mod tests {
             Edition2018,
             None,
             None,
+            None,
             Default::default(),
             Default::default(),
             Env::default(),
diff --git a/crates/ide/src/fetch_crates.rs b/crates/ide/src/fetch_crates.rs
index 5750d6b4261..916c26855a2 100644
--- a/crates/ide/src/fetch_crates.rs
+++ b/crates/ide/src/fetch_crates.rs
@@ -1,5 +1,5 @@
 use ide_db::{
-    base_db::{CrateOrigin, SourceDatabase, SourceDatabaseExt},
+    base_db::{CrateOrigin, SourceDatabase},
     FxIndexSet, RootDatabase,
 };
 
@@ -22,13 +22,13 @@ pub(crate) fn fetch_crates(db: &RootDatabase) -> FxIndexSet<CrateInfo> {
         .iter()
         .map(|crate_id| &crate_graph[crate_id])
         .filter(|&data| !matches!(data.origin, CrateOrigin::Local { .. }))
-        .filter_map(|data| crate_info(data, db))
+        .filter_map(|data| crate_info(data))
         .collect()
 }
 
-fn crate_info(data: &ide_db::base_db::CrateData, db: &RootDatabase) -> Option<CrateInfo> {
+fn crate_info(data: &ide_db::base_db::CrateData) -> Option<CrateInfo> {
     let crate_name = crate_name(data);
-    let crate_path = crate_path(db, data, &crate_name);
+    let crate_path = data.crate_root_path.as_ref().map(|p| p.display().to_string());
     if let Some(crate_path) = crate_path {
         let version = data.version.clone().unwrap_or_else(|| "".to_owned());
         Some(CrateInfo { name: crate_name, version, path: crate_path })
@@ -43,29 +43,3 @@ fn crate_name(data: &ide_db::base_db::CrateData) -> String {
         .map(|it| it.canonical_name().to_owned())
         .unwrap_or("unknown".to_string())
 }
-
-fn crate_path(
-    db: &RootDatabase,
-    data: &ide_db::base_db::CrateData,
-    crate_name: &str,
-) -> Option<String> {
-    let source_root_id = db.file_source_root(data.root_file_id);
-    let source_root = db.source_root(source_root_id);
-    let source_root_path = source_root.path_for_file(&data.root_file_id);
-    source_root_path.cloned().and_then(|mut root_path| {
-        let mut crate_path = None;
-        while let Some(vfs_path) = root_path.parent() {
-            match vfs_path.name_and_extension() {
-                Some((name, _)) => {
-                    if name.starts_with(crate_name) {
-                        crate_path = Some(vfs_path.to_string());
-                        break;
-                    }
-                }
-                None => break,
-            }
-            root_path = vfs_path;
-        }
-        crate_path
-    })
-}
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 24e2aed65a5..131c781beee 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -239,6 +239,7 @@ impl Analysis {
             Edition::CURRENT,
             None,
             None,
+            None,
             cfg_options.clone(),
             None,
             Env::default(),
diff --git a/crates/ide/src/shuffle_crate_graph.rs b/crates/ide/src/shuffle_crate_graph.rs
index d94b15f60c8..51ecc4001f6 100644
--- a/crates/ide/src/shuffle_crate_graph.rs
+++ b/crates/ide/src/shuffle_crate_graph.rs
@@ -34,6 +34,7 @@ pub(crate) fn shuffle_crate_graph(db: &mut RootDatabase) {
             data.edition,
             data.display_name.clone(),
             data.version.clone(),
+            data.crate_root_path.clone(),
             data.cfg_options.clone(),
             data.potential_cfg_options.clone(),
             data.env.clone(),
diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs
index ac09121aedf..6a3c685016d 100644
--- a/crates/paths/src/lib.rs
+++ b/crates/paths/src/lib.rs
@@ -213,6 +213,13 @@ impl AbsPath {
     pub fn exists(&self) -> bool {
         self.0.exists()
     }
+
+    pub fn name_and_extension(&self) -> Option<(&str, Option<&str>)> {
+        Some((
+            self.file_stem()?.to_str()?,
+            self.extension().and_then(|extension| extension.to_str()),
+        ))
+    }
     // endregion:delegate-methods
 }
 
diff --git a/crates/project-model/src/tests.rs b/crates/project-model/src/tests.rs
index 9acf60bf4a8..ca28d742d5c 100644
--- a/crates/project-model/src/tests.rs
+++ b/crates/project-model/src/tests.rs
@@ -102,6 +102,11 @@ fn replace_root(s: &mut String, direction: bool) {
     }
 }
 
+fn replace_fake_sys_root(s: &mut String) {
+    let root = get_test_path("fake-sysroot");
+    *s = s.replace(root.to_str().expect("expected str"), "$FAKESYSROOT$")
+}
+
 fn get_test_path(file: &str) -> PathBuf {
     let base = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
     base.join("test_data").join(file)
@@ -140,6 +145,7 @@ fn to_crate_graph(project_workspace: ProjectWorkspace) -> (CrateGraph, ProcMacro
 fn check_crate_graph(crate_graph: CrateGraph, expect: ExpectFile) {
     let mut crate_graph = format!("{crate_graph:#?}");
     replace_root(&mut crate_graph, false);
+    replace_fake_sys_root(&mut crate_graph);
     expect.assert_eq(&crate_graph);
 }
 
diff --git a/crates/project-model/src/workspace.rs b/crates/project-model/src/workspace.rs
index 5924287a37f..ba5a1c4e354 100644
--- a/crates/project-model/src/workspace.rs
+++ b/crates/project-model/src/workspace.rs
@@ -766,6 +766,7 @@ fn project_json_to_crate_graph(
                     proc_macro_dylib_path,
                     is_proc_macro,
                     repository,
+                    root_module,
                     ..
                 },
                 file_id,
@@ -784,6 +785,7 @@ fn project_json_to_crate_graph(
                     *edition,
                     display_name.clone(),
                     version.clone(),
+                    crate_path(display_name.as_ref(), root_module),
                     target_cfgs.iter().chain(cfg.iter()).cloned().collect(),
                     None,
                     env,
@@ -832,6 +834,30 @@ fn project_json_to_crate_graph(
     res
 }
 
+//Thats a best effort to try and find the crate path for a project configured using JsonProject model
+fn crate_path(
+    crate_name: Option<&CrateDisplayName>,
+    root_module_path: &AbsPathBuf,
+) -> Option<AbsPathBuf> {
+    crate_name.and_then(|crate_name| {
+        let mut crate_path = None;
+        let mut root_path = root_module_path.as_path();
+        while let Some(path) = root_path.parent() {
+            match path.name_and_extension() {
+                Some((name, _)) => {
+                    if name.starts_with(crate_name.canonical_name()) {
+                        crate_path = Some(path.to_path_buf());
+                        break;
+                    }
+                }
+                None => break,
+            }
+            root_path = path;
+        }
+        crate_path
+    })
+}
+
 fn cargo_to_crate_graph(
     load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
     rustc: Option<&(CargoWorkspace, WorkspaceBuildScripts)>,
@@ -1053,6 +1079,7 @@ fn detached_files_to_crate_graph(
             Edition::CURRENT,
             display_name.clone(),
             None,
+            None,
             cfg_options.clone(),
             None,
             Env::default(),
@@ -1249,6 +1276,7 @@ fn add_target_crate_root(
         edition,
         Some(display_name),
         Some(pkg.version.to_string()),
+        Some(pkg.manifest.parent().to_owned()),
         cfg_options,
         potential_cfg_options,
         env,
@@ -1320,11 +1348,13 @@ fn sysroot_to_crate_graph(
                 let env = Env::default();
                 let display_name =
                     CrateDisplayName::from_canonical_name(sysroot[krate].name.clone());
-                let crate_id = crate_graph.add_crate_root(
+                let crate_root_path = sysroot.src_root().join(display_name.canonical_name());
+            let crate_id = crate_graph.add_crate_root(
                     file_id,
                     Edition::CURRENT,
                     Some(display_name),
                     None,
+                Some(crate_root_path),
                     cfg_options.clone(),
                     None,
                     env,
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
index 38501a8ba5a..d327f2edf14 100644
--- a/crates/vfs/src/vfs_path.rs
+++ b/crates/vfs/src/vfs_path.rs
@@ -107,10 +107,7 @@ impl VfsPath {
     /// Returns `self`'s base name and file extension.
     pub fn name_and_extension(&self) -> Option<(&str, Option<&str>)> {
         match &self.0 {
-            VfsPathRepr::PathBuf(p) => Some((
-                p.file_stem()?.to_str()?,
-                p.extension().and_then(|extension| extension.to_str()),
-            )),
+            VfsPathRepr::PathBuf(p) => p.name_and_extension(),
             VfsPathRepr::VirtualPath(p) => p.name_and_extension(),
         }
     }
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 3edbb316814..aff5102e01f 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -110,9 +110,13 @@ export class Dependency extends vscode.TreeItem {
     ) {
         super(label, collapsibleState);
         this.id = this.dependencyPath.toLowerCase();
-        this.tooltip = `${this.label}-${this.version}`;
         this.description = this.version;
         this.resourceUri = vscode.Uri.file(dependencyPath);
+        if (this.version) {
+            this.tooltip = `${this.label}-${this.version}`;
+        } else {
+            this.tooltip = this.label;
+        }
     }
 }
 
@@ -124,8 +128,8 @@ export class DependencyFile extends vscode.TreeItem {
         public readonly collapsibleState: vscode.TreeItemCollapsibleState
     ) {
         super(vscode.Uri.file(dependencyPath), collapsibleState);
-        const isDir = fs.lstatSync(this.dependencyPath).isDirectory();
         this.id = this.dependencyPath.toLowerCase();
+        const isDir = fs.lstatSync(this.dependencyPath).isDirectory();
         if (!isDir) {
             this.command = { command: "vscode.open",
                 title: "Open File",
-- 
cgit 1.4.1-3-g733a5


From fe7874af90b9e1190b5aebcf3a6d5544177cf9b2 Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Sat, 8 Apr 2023 14:18:29 -0300
Subject: reveal only when tree is visible

---
 editors/code/src/commands.ts |  2 --
 editors/code/src/ctx.ts      | 34 +++++++++++++++++++++++++++++-----
 editors/code/src/util.ts     |  5 -----
 3 files changed, 29 insertions(+), 12 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 4393d5fccbc..81d3b8da7f9 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -15,7 +15,6 @@ import {
     isRustEditor,
     RustEditor,
     RustDocument,
-    closeDocument,
 } from "./util";
 import { startDebugSession, makeDebugConfig } from "./debug";
 import { LanguageClient } from "vscode-languageclient/node";
@@ -324,7 +323,6 @@ async function revealParentChain(document: RustDocument, ctx: CtxInit) {
         if (parentChain.length >= maxDepth) {
             // this is an odd case that can happen when we change a crate version but we'd still have
             // a open file referencing the old version
-            await closeDocument(document);
             return;
         }
     } while (!ctx.dependencies?.contains(documentPath));
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index dd2373d5847..4e592823b04 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -285,14 +285,38 @@ export class Ctx {
         });
 
         this.pushExtCleanup(this._treeView);
-        vscode.window.onDidChangeActiveTextEditor((e) => {
+        vscode.window.onDidChangeActiveTextEditor(async (e) => {
             // we should skip documents that belong to the current workspace
-            if (e && isRustEditor(e) && !isDocumentInWorkspace(e.document)) {
-                execRevealDependency(e).catch((reason) => {
-                    void vscode.window.showErrorMessage(`Dependency error: ${reason}`);
-                });
+            if (this.shouldRevealDependency(e)) {
+                try {
+                    await execRevealDependency(e);
+                } catch (reason) {
+                    await vscode.window.showErrorMessage(`Dependency error: ${reason}`);
+                }
             }
         });
+
+        this.treeView?.onDidChangeVisibility(async (e) => {
+            if (e.visible) {
+                const activeEditor = vscode.window.activeTextEditor;
+                if (this.shouldRevealDependency(activeEditor)) {
+                    try {
+                        await execRevealDependency(activeEditor);
+                    } catch (reason) {
+                        await vscode.window.showErrorMessage(`Dependency error: ${reason}`);
+                    }
+                }
+            }
+        });
+    }
+
+    private shouldRevealDependency(e: vscode.TextEditor | undefined): e is RustEditor {
+        return (
+            e !== undefined &&
+            isRustEditor(e) &&
+            !isDocumentInWorkspace(e.document) &&
+            (this.treeView?.visible || false)
+        );
     }
 
     async restart() {
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 0196b37b8b6..b6b779e2660 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -125,11 +125,6 @@ export function isDocumentInWorkspace(document: RustDocument): boolean {
     return false;
 }
 
-export async function closeDocument(document: RustDocument) {
-    await vscode.window.showTextDocument(document, { preview: true, preserveFocus: false });
-    await vscode.commands.executeCommand("workbench.action.closeActiveEditor");
-}
-
 export function isValidExecutable(path: string): boolean {
     log.debug("Checking availability of a binary at", path);
 
-- 
cgit 1.4.1-3-g733a5


From 66fe84d9369c40f2b17ae8cd541d6d87c501b45f Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Thu, 13 Apr 2023 13:06:43 -0300
Subject: accepting review suggestions

---
 crates/base-db/src/fixture.rs                 |  4 --
 crates/base-db/src/input.rs                   | 13 ------
 crates/ide/src/fetch_crates.rs                | 28 +++++--------
 crates/ide/src/lib.rs                         |  1 -
 crates/ide/src/shuffle_crate_graph.rs         |  1 -
 crates/paths/src/lib.rs                       | 14 +++----
 crates/project-model/src/workspace.rs         | 57 ++++++---------------------
 crates/rust-analyzer/src/handlers.rs          | 30 +++++++++++++-
 crates/rust-analyzer/src/lsp_ext.rs           |  4 +-
 crates/rust-analyzer/tests/slow-tests/tidy.rs |  2 +-
 docs/dev/lsp-extensions.md                    |  4 +-
 editors/code/src/dependencies_provider.ts     |  2 +-
 editors/code/src/lsp_ext.ts                   |  4 +-
 13 files changed, 67 insertions(+), 97 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/base-db/src/fixture.rs b/crates/base-db/src/fixture.rs
index cf3be9d07fd..1936eabdd9f 100644
--- a/crates/base-db/src/fixture.rs
+++ b/crates/base-db/src/fixture.rs
@@ -165,7 +165,6 @@ impl ChangeFixture {
                     meta.edition,
                     Some(crate_name.clone().into()),
                     version,
-                    None,
                     meta.cfg,
                     Default::default(),
                     meta.env,
@@ -206,7 +205,6 @@ impl ChangeFixture {
                 Edition::CURRENT,
                 Some(CrateName::new("test").unwrap().into()),
                 None,
-                None,
                 default_cfg,
                 Default::default(),
                 Env::default(),
@@ -251,7 +249,6 @@ impl ChangeFixture {
                 Edition::Edition2021,
                 Some(CrateDisplayName::from_canonical_name("core".to_string())),
                 None,
-                None,
                 Default::default(),
                 Default::default(),
                 Env::default(),
@@ -291,7 +288,6 @@ impl ChangeFixture {
                 Edition::Edition2021,
                 Some(CrateDisplayName::from_canonical_name("proc_macros".to_string())),
                 None,
-                None,
                 Default::default(),
                 Default::default(),
                 Env::default(),
diff --git a/crates/base-db/src/input.rs b/crates/base-db/src/input.rs
index 466e2eab560..e6d265df675 100644
--- a/crates/base-db/src/input.rs
+++ b/crates/base-db/src/input.rs
@@ -304,7 +304,6 @@ pub struct CrateData {
     /// For purposes of analysis, crates are anonymous (only names in
     /// `Dependency` matters), this name should only be used for UI.
     pub display_name: Option<CrateDisplayName>,
-    pub crate_root_path: Option<AbsPathBuf>,
     pub cfg_options: CfgOptions,
     /// The cfg options that could be used by the crate
     pub potential_cfg_options: Option<CfgOptions>,
@@ -362,7 +361,6 @@ impl CrateGraph {
         edition: Edition,
         display_name: Option<CrateDisplayName>,
         version: Option<String>,
-        crate_root_path: Option<AbsPathBuf>,
         cfg_options: CfgOptions,
         potential_cfg_options: Option<CfgOptions>,
         env: Env,
@@ -376,7 +374,6 @@ impl CrateGraph {
             edition,
             version,
             display_name,
-            crate_root_path,
             cfg_options,
             potential_cfg_options,
             env,
@@ -743,7 +740,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -757,7 +753,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -771,7 +766,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -799,7 +793,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -813,7 +806,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -838,7 +830,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -852,7 +843,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -866,7 +856,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -891,7 +880,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
@@ -905,7 +893,6 @@ mod tests {
             Edition2018,
             None,
             None,
-            None,
             Default::default(),
             Default::default(),
             Env::default(),
diff --git a/crates/ide/src/fetch_crates.rs b/crates/ide/src/fetch_crates.rs
index 916c26855a2..d326b7c2ccc 100644
--- a/crates/ide/src/fetch_crates.rs
+++ b/crates/ide/src/fetch_crates.rs
@@ -1,13 +1,13 @@
 use ide_db::{
-    base_db::{CrateOrigin, SourceDatabase},
+    base_db::{CrateOrigin, FileId, SourceDatabase},
     FxIndexSet, RootDatabase,
 };
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct CrateInfo {
-    pub name: String,
-    pub version: String,
-    pub path: String,
+    pub name: Option<String>,
+    pub version: Option<String>,
+    pub root_file_id: FileId,
 }
 
 // Feature: Show Dependency Tree
@@ -22,24 +22,16 @@ pub(crate) fn fetch_crates(db: &RootDatabase) -> FxIndexSet<CrateInfo> {
         .iter()
         .map(|crate_id| &crate_graph[crate_id])
         .filter(|&data| !matches!(data.origin, CrateOrigin::Local { .. }))
-        .filter_map(|data| crate_info(data))
+        .map(|data| crate_info(data))
         .collect()
 }
 
-fn crate_info(data: &ide_db::base_db::CrateData) -> Option<CrateInfo> {
+fn crate_info(data: &ide_db::base_db::CrateData) -> CrateInfo {
     let crate_name = crate_name(data);
-    let crate_path = data.crate_root_path.as_ref().map(|p| p.display().to_string());
-    if let Some(crate_path) = crate_path {
-        let version = data.version.clone().unwrap_or_else(|| "".to_owned());
-        Some(CrateInfo { name: crate_name, version, path: crate_path })
-    } else {
-        None
-    }
+    let version = data.version.clone();
+    CrateInfo { name: crate_name, version, root_file_id: data.root_file_id }
 }
 
-fn crate_name(data: &ide_db::base_db::CrateData) -> String {
-    data.display_name
-        .clone()
-        .map(|it| it.canonical_name().to_owned())
-        .unwrap_or("unknown".to_string())
+fn crate_name(data: &ide_db::base_db::CrateData) -> Option<String> {
+    data.display_name.as_ref().map(|it| it.canonical_name().to_owned())
 }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 131c781beee..24e2aed65a5 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -239,7 +239,6 @@ impl Analysis {
             Edition::CURRENT,
             None,
             None,
-            None,
             cfg_options.clone(),
             None,
             Env::default(),
diff --git a/crates/ide/src/shuffle_crate_graph.rs b/crates/ide/src/shuffle_crate_graph.rs
index 51ecc4001f6..d94b15f60c8 100644
--- a/crates/ide/src/shuffle_crate_graph.rs
+++ b/crates/ide/src/shuffle_crate_graph.rs
@@ -34,7 +34,6 @@ pub(crate) fn shuffle_crate_graph(db: &mut RootDatabase) {
             data.edition,
             data.display_name.clone(),
             data.version.clone(),
-            data.crate_root_path.clone(),
             data.cfg_options.clone(),
             data.potential_cfg_options.clone(),
             data.env.clone(),
diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs
index 6a3c685016d..083dfcf43d9 100644
--- a/crates/paths/src/lib.rs
+++ b/crates/paths/src/lib.rs
@@ -184,6 +184,13 @@ impl AbsPath {
         self.0.ends_with(&suffix.0)
     }
 
+    pub fn name_and_extension(&self) -> Option<(&str, Option<&str>)> {
+        Some((
+            self.file_stem()?.to_str()?,
+            self.extension().and_then(|extension| extension.to_str()),
+        ))
+    }
+
     // region:delegate-methods
 
     // Note that we deliberately don't implement `Deref<Target = Path>` here.
@@ -213,13 +220,6 @@ impl AbsPath {
     pub fn exists(&self) -> bool {
         self.0.exists()
     }
-
-    pub fn name_and_extension(&self) -> Option<(&str, Option<&str>)> {
-        Some((
-            self.file_stem()?.to_str()?,
-            self.extension().and_then(|extension| extension.to_str()),
-        ))
-    }
     // endregion:delegate-methods
 }
 
diff --git a/crates/project-model/src/workspace.rs b/crates/project-model/src/workspace.rs
index ba5a1c4e354..102f862522e 100644
--- a/crates/project-model/src/workspace.rs
+++ b/crates/project-model/src/workspace.rs
@@ -766,7 +766,6 @@ fn project_json_to_crate_graph(
                     proc_macro_dylib_path,
                     is_proc_macro,
                     repository,
-                    root_module,
                     ..
                 },
                 file_id,
@@ -785,7 +784,6 @@ fn project_json_to_crate_graph(
                     *edition,
                     display_name.clone(),
                     version.clone(),
-                    crate_path(display_name.as_ref(), root_module),
                     target_cfgs.iter().chain(cfg.iter()).cloned().collect(),
                     None,
                     env,
@@ -834,30 +832,6 @@ fn project_json_to_crate_graph(
     res
 }
 
-//Thats a best effort to try and find the crate path for a project configured using JsonProject model
-fn crate_path(
-    crate_name: Option<&CrateDisplayName>,
-    root_module_path: &AbsPathBuf,
-) -> Option<AbsPathBuf> {
-    crate_name.and_then(|crate_name| {
-        let mut crate_path = None;
-        let mut root_path = root_module_path.as_path();
-        while let Some(path) = root_path.parent() {
-            match path.name_and_extension() {
-                Some((name, _)) => {
-                    if name.starts_with(crate_name.canonical_name()) {
-                        crate_path = Some(path.to_path_buf());
-                        break;
-                    }
-                }
-                None => break,
-            }
-            root_path = path;
-        }
-        crate_path
-    })
-}
-
 fn cargo_to_crate_graph(
     load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
     rustc: Option<&(CargoWorkspace, WorkspaceBuildScripts)>,
@@ -1079,7 +1053,6 @@ fn detached_files_to_crate_graph(
             Edition::CURRENT,
             display_name.clone(),
             None,
-            None,
             cfg_options.clone(),
             None,
             Env::default(),
@@ -1276,7 +1249,6 @@ fn add_target_crate_root(
         edition,
         Some(display_name),
         Some(pkg.version.to_string()),
-        Some(pkg.manifest.parent().to_owned()),
         cfg_options,
         potential_cfg_options,
         env,
@@ -1345,27 +1317,24 @@ fn sysroot_to_crate_graph(
             .filter_map(|krate| {
                 let file_id = load(&sysroot[krate].root)?;
 
-                let env = Env::default();
-                let display_name =
-                    CrateDisplayName::from_canonical_name(sysroot[krate].name.clone());
-                let crate_root_path = sysroot.src_root().join(display_name.canonical_name());
+            let env = Env::default();
+            let display_name = CrateDisplayName::from_canonical_name(sysroot[krate].name.clone());
             let crate_id = crate_graph.add_crate_root(
                     file_id,
                     Edition::CURRENT,
                     Some(display_name),
                     None,
-                Some(crate_root_path),
-                    cfg_options.clone(),
-                    None,
-                    env,
-                    false,
-                    CrateOrigin::Lang(LangCrateOrigin::from(&*sysroot[krate].name)),
-                    target_layout.clone(),
-                    channel,
-                );
-                Some((krate, crate_id))
-            })
-            .collect(),
+                cfg_options.clone(),
+                None,
+                env,
+                false,
+                CrateOrigin::Lang(LangCrateOrigin::from(&*sysroot[krate].name)),
+                target_layout.clone(),
+                channel,
+            );
+            Some((krate, crate_id))
+        })
+        .collect(),
     };
     for from in sysroot.crates() {
         for &to in sysroot[from].deps.iter() {
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 5c966f0f68b..ae6dd4dd561 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -57,7 +57,35 @@ pub(crate) fn fetch_dependency_list(
     Ok(FetchDependencyListResult {
         crates: crates
             .into_iter()
-            .map(|it| CrateInfoResult { name: it.name, version: it.version, path: it.path })
+            .filter_map(|it| {
+                let root_file_path = state.file_id_to_file_path(it.root_file_id);
+                crate_path(it.name.as_ref(), root_file_path).map(|crate_path| CrateInfoResult {
+                    name: it.name,
+                    version: it.version,
+                    path: crate_path.to_string(),
+                })
+            })
             .collect(),
     })
 }
+
+//Thats a best effort to try and find the crate path
+fn crate_path(crate_name: Option<&String>, root_file_path: VfsPath) -> Option<VfsPath> {
+    crate_name.and_then(|crate_name| {
+        let mut crate_path = None;
+        let mut root_path = root_file_path;
+        while let Some(path) = root_path.parent() {
+            match path.name_and_extension() {
+                Some((name, _)) => {
+                    if name.starts_with(crate_name.as_str()) {
+                        crate_path = Some(path);
+                        break;
+                    }
+                }
+                None => break,
+            }
+            root_path = path;
+        }
+        crate_path
+    })
+}
\ No newline at end of file
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 6285578a6ce..8689fae0798 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -30,8 +30,8 @@ pub struct AnalyzerStatusParams {
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct CrateInfoResult {
-    pub name: String,
-    pub version: String,
+    pub name: Option<String>,
+    pub version: Option<String>,
     pub path: String,
 }
 pub enum FetchDependencyList {}
diff --git a/crates/rust-analyzer/tests/slow-tests/tidy.rs b/crates/rust-analyzer/tests/slow-tests/tidy.rs
index 91dde1c7528..8e3097fce42 100644
--- a/crates/rust-analyzer/tests/slow-tests/tidy.rs
+++ b/crates/rust-analyzer/tests/slow-tests/tidy.rs
@@ -45,7 +45,7 @@ fn check_lsp_extensions_docs() {
             sh.read_file(sourcegen::project_root().join("docs/dev/lsp-extensions.md")).unwrap();
         let text = lsp_extensions_md
             .lines()
-            .find_map(|line| dbg!(line.strip_prefix("lsp_ext.rs hash:")))
+            .find_map(|line| line.strip_prefix("lsp_ext.rs hash:"))
             .unwrap()
             .trim();
         u64::from_str_radix(text, 16).unwrap()
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index d73ae3d519e..0fb92638e0d 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -860,12 +860,12 @@ export interface Diagnostic {
 **Request:**
 
 ```typescript
-export interface FetchDependencyGraphParams {}
+export interface FetchDependencyListParams {}
 ```
 
 **Response:** 
 ```typescript
-export interface FetchDependencyGraphResult {
+export interface FetchDependencyListResult {
     crates: {
         name: string;
         version: string;
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index aff5102e01f..b1ea3658867 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -88,7 +88,7 @@ export class RustDependenciesProvider
         );
         const crates = dependenciesResult.crates;
         const deps = crates.map((crate) => {
-        const dep = this.toDep(crate.name, crate.version, crate.path);
+        const dep = this.toDep(crate.name || "unknown", crate.version || "", crate.path);
             this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
         this.dependenciesMap[stdlib.dependencyPath.toLowerCase()] = stdlib;
         return dep;
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 30de5035d63..b72804e510c 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -74,8 +74,8 @@ export interface FetchDependencyListParams {}
 
 export interface FetchDependencyListResult {
     crates: {
-        name: string;
-        version: string;
+        name: string | undefined;
+        version: string | undefined;
         path: string;
     }[];
 }
-- 
cgit 1.4.1-3-g733a5


From bd2160f014aa0bd6761c90697e00650bf008993a Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Wed, 26 Apr 2023 21:54:31 -0300
Subject: final rabasing fixes

---
 editors/code/src/ctx.ts                   | 25 ++++-------
 editors/code/src/dependencies_provider.ts | 33 ++++++---------
 editors/code/src/toolchain.ts             | 69 +------------------------------
 3 files changed, 23 insertions(+), 104 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 4e592823b04..60ea7695795 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -22,13 +22,6 @@ import {
     DependencyId,
 } from "./dependencies_provider";
 import { execRevealDependency } from "./commands";
-import {
-    Dependency,
-    DependencyFile,
-    RustDependenciesProvider,
-    DependencyId,
-} from "./dependencies_provider";
-import { execRevealDependency } from "./commands";
 import { PersistentState } from "./persistent_state";
 import { bootstrap } from "./bootstrap";
 import { ExecOptions } from "child_process";
@@ -40,12 +33,12 @@ import { ExecOptions } from "child_process";
 export type Workspace =
     | { kind: "Empty" }
     | {
-          kind: "Workspace Folder";
-      }
+    kind: "Workspace Folder";
+}
     | {
-          kind: "Detached Files";
-          files: vscode.TextDocument[];
-      };
+    kind: "Detached Files";
+    files: vscode.TextDocument[];
+};
 
 export function fetchWorkspace(): Workspace {
     const folders = (vscode.workspace.workspaceFolders || []).filter(
@@ -59,9 +52,9 @@ export function fetchWorkspace(): Workspace {
         ? rustDocuments.length === 0
             ? { kind: "Empty" }
             : {
-                  kind: "Detached Files",
-                  files: rustDocuments,
-              }
+                kind: "Detached Files",
+                files: rustDocuments,
+            }
         : { kind: "Workspace Folder" };
 }
 
@@ -483,4 +476,4 @@ export interface Disposable {
     dispose(): void;
 }
 
-export type Cmd = (...args: any[]) => unknown;
+export type Cmd = (...args: any[]) => unknown;
\ No newline at end of file
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index b1ea3658867..0faf7665cfd 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -1,17 +1,12 @@
 import * as vscode from "vscode";
 import * as fspath from "path";
 import * as fs from "fs";
-import { CtxInit } from "./ctx";
+import {CtxInit} from "./ctx";
 import * as ra from "./lsp_ext";
-import { FetchDependencyListResult } from "./lsp_ext";
-import { Ctx } from "./ctx";
-import { setFlagsFromString } from "v8";
-import * as ra from "./lsp_ext";
-
+import {FetchDependencyListResult} from "./lsp_ext";
 
 export class RustDependenciesProvider
-    implements vscode.TreeDataProvider<Dependency | DependencyFile>
-{
+    implements vscode.TreeDataProvider<Dependency | DependencyFile> {
     dependenciesMap: { [id: string]: Dependency | DependencyFile };
     ctx: CtxInit;
 
@@ -61,7 +56,6 @@ export class RustDependenciesProvider
                 void vscode.window.showInformationMessage("No dependency in empty workspace");
                 return Promise.resolve([]);
             }
-
             if (element) {
                 const files = fs.readdirSync(element.dependencyPath).map((fileName) => {
                     const filePath = fspath.join(element.dependencyPath, fileName);
@@ -80,20 +74,17 @@ export class RustDependenciesProvider
     }
 
     private async getRootDependencies(): Promise<Dependency[]> {
-        const crates = await this.ctx.client.sendRequest(ra.fetchDependencyGraph, {});
-
         const dependenciesResult: FetchDependencyListResult = await this.ctx.client.sendRequest(
             ra.fetchDependencyList,
             {}
         );
         const crates = dependenciesResult.crates;
-        const deps = crates.map((crate) => {
-        const dep = this.toDep(crate.name || "unknown", crate.version || "", crate.path);
+
+        return crates.map((crate) => {
+            const dep = this.toDep(crate.name || "unknown", crate.version || "", crate.path);
             this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
-        this.dependenciesMap[stdlib.dependencyPath.toLowerCase()] = stdlib;
-        return dep;
+            return dep;
         });
-        return deps;
     }
 
     private toDep(moduleName: string, version: string, path: string): Dependency {
@@ -131,11 +122,13 @@ export class DependencyFile extends vscode.TreeItem {
         this.id = this.dependencyPath.toLowerCase();
         const isDir = fs.lstatSync(this.dependencyPath).isDirectory();
         if (!isDir) {
-            this.command = { command: "vscode.open",
+            this.command = {
+                command: "vscode.open",
                 title: "Open File",
                 arguments: [vscode.Uri.file(this.dependencyPath)],
-        };
-    }}
+            };
+        }
+    }
 }
 
-export type DependencyId = { id: string };
+export type DependencyId = { id: string };
\ No newline at end of file
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 9c5c88c49e5..c876048ba65 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -96,40 +96,6 @@ export class Cargo {
         return artifacts[0].fileName;
     }
 
-    async crates(): Promise<Crate[]> {
-        const pathToCargo = await cargoPath();
-        return await new Promise((resolve, reject) => {
-            const crates: Crate[] = [];
-
-            const cargo = cp.spawn(pathToCargo, ["tree", "--prefix", "none"], {
-                stdio: ["ignore", "pipe", "pipe"],
-                cwd: this.rootFolder,
-            });
-            const rl = readline.createInterface({ input: cargo.stdout });
-            rl.on("line", (line) => {
-                const match = line.match(TREE_LINE_PATTERN);
-                if (match) {
-                    const name = match[1];
-                    const version = match[2];
-                    const extraInfo = match[3];
-                    // ignore duplicates '(*)' and path dependencies
-                    if (this.shouldIgnore(extraInfo)) {
-                        return;
-                    }
-                    crates.push({ name, version });
-                }
-            });
-            cargo.on("exit", (exitCode, _) => {
-                if (exitCode === 0) resolve(crates);
-                else reject(new Error(`exit code: ${exitCode}.`));
-            });
-        });
-    }
-
-    private shouldIgnore(extraInfo: string): boolean {
-        return extraInfo !== undefined && (extraInfo === "*" || path.isAbsolute(extraInfo));
-    }
-
     private async runCargo(
         cargoArgs: string[],
         onStdoutJson: (obj: any) => void,
@@ -161,29 +127,6 @@ export class Cargo {
     }
 }
 
-export async function activeToolchain(): Promise<string> {
-    const pathToRustup = await rustupPath();
-    return await new Promise((resolve, reject) => {
-        const execution = cp.spawn(pathToRustup, ["show", "active-toolchain"], {
-            stdio: ["ignore", "pipe", "pipe"],
-            cwd: os.homedir(),
-        });
-        const rl = readline.createInterface({ input: execution.stdout });
-
-        let currToolchain: string | undefined = undefined;
-        rl.on("line", (line) => {
-            const match = line.match(TOOLCHAIN_PATTERN);
-            if (match) {
-                currToolchain = match[1];
-            }
-        });
-        execution.on("exit", (exitCode, _) => {
-            if (exitCode === 0 && currToolchain) resolve(currToolchain);
-            else reject(new Error(`exit code: ${exitCode}.`));
-        });
-    });
-}
-
 /** Mirrors `project_model::sysroot::discover_sysroot_dir()` implementation*/
 export async function getSysroot(dir: string): Promise<string> {
     const rustcPath = await getPathForExecutable("rustc");
@@ -202,16 +145,6 @@ export async function getRustcId(dir: string): Promise<string> {
     return rx.exec(data)![1];
 }
 
-export async function getRustcVersion(dir: string): Promise<string> {
-    const rustcPath = await getPathForExecutable("rustc");
-
-    // do not memoize the result because the toolchain may change between runs
-    const data = await execute(`${rustcPath} -V`, { cwd: dir });
-    const rx = /(\d\.\d+\.\d+)/;
-
-    return rx.exec(data)![1];
-}
-
 /** Mirrors `toolchain::cargo()` implementation */
 export function cargoPath(): Promise<string> {
     return getPathForExecutable("cargo");
@@ -278,4 +211,4 @@ async function isFileAtUri(uri: vscode.Uri): Promise<boolean> {
     } catch {
         return false;
     }
-}
+}
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 072f69e4c16bb49f9fd94989029d3e5086e8ac22 Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Wed, 26 Apr 2023 22:02:38 -0300
Subject: fixing ts linting and rust test

---
 crates/project-model/src/workspace.rs     | 29 +++++++++++++++--------------
 editors/code/src/ctx.ts                   | 18 +++++++++---------
 editors/code/src/dependencies_provider.ts |  9 +++++----
 editors/code/src/toolchain.ts             |  2 +-
 4 files changed, 30 insertions(+), 28 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/project-model/src/workspace.rs b/crates/project-model/src/workspace.rs
index 102f862522e..5924287a37f 100644
--- a/crates/project-model/src/workspace.rs
+++ b/crates/project-model/src/workspace.rs
@@ -1317,24 +1317,25 @@ fn sysroot_to_crate_graph(
             .filter_map(|krate| {
                 let file_id = load(&sysroot[krate].root)?;
 
-            let env = Env::default();
-            let display_name = CrateDisplayName::from_canonical_name(sysroot[krate].name.clone());
-            let crate_id = crate_graph.add_crate_root(
+                let env = Env::default();
+                let display_name =
+                    CrateDisplayName::from_canonical_name(sysroot[krate].name.clone());
+                let crate_id = crate_graph.add_crate_root(
                     file_id,
                     Edition::CURRENT,
                     Some(display_name),
                     None,
-                cfg_options.clone(),
-                None,
-                env,
-                false,
-                CrateOrigin::Lang(LangCrateOrigin::from(&*sysroot[krate].name)),
-                target_layout.clone(),
-                channel,
-            );
-            Some((krate, crate_id))
-        })
-        .collect(),
+                    cfg_options.clone(),
+                    None,
+                    env,
+                    false,
+                    CrateOrigin::Lang(LangCrateOrigin::from(&*sysroot[krate].name)),
+                    target_layout.clone(),
+                    channel,
+                );
+                Some((krate, crate_id))
+            })
+            .collect(),
     };
     for from in sysroot.crates() {
         for &to in sysroot[from].deps.iter() {
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 60ea7695795..8bed74b88ea 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -33,12 +33,12 @@ import { ExecOptions } from "child_process";
 export type Workspace =
     | { kind: "Empty" }
     | {
-    kind: "Workspace Folder";
-}
+          kind: "Workspace Folder";
+      }
     | {
-    kind: "Detached Files";
-    files: vscode.TextDocument[];
-};
+          kind: "Detached Files";
+          files: vscode.TextDocument[];
+      };
 
 export function fetchWorkspace(): Workspace {
     const folders = (vscode.workspace.workspaceFolders || []).filter(
@@ -52,9 +52,9 @@ export function fetchWorkspace(): Workspace {
         ? rustDocuments.length === 0
             ? { kind: "Empty" }
             : {
-                kind: "Detached Files",
-                files: rustDocuments,
-            }
+                  kind: "Detached Files",
+                  files: rustDocuments,
+              }
         : { kind: "Workspace Folder" };
 }
 
@@ -476,4 +476,4 @@ export interface Disposable {
     dispose(): void;
 }
 
-export type Cmd = (...args: any[]) => unknown;
\ No newline at end of file
+export type Cmd = (...args: any[]) => unknown;
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 0faf7665cfd..59b3b27731c 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -1,12 +1,13 @@
 import * as vscode from "vscode";
 import * as fspath from "path";
 import * as fs from "fs";
-import {CtxInit} from "./ctx";
+import { CtxInit } from "./ctx";
 import * as ra from "./lsp_ext";
-import {FetchDependencyListResult} from "./lsp_ext";
+import { FetchDependencyListResult } from "./lsp_ext";
 
 export class RustDependenciesProvider
-    implements vscode.TreeDataProvider<Dependency | DependencyFile> {
+    implements vscode.TreeDataProvider<Dependency | DependencyFile>
+{
     dependenciesMap: { [id: string]: Dependency | DependencyFile };
     ctx: CtxInit;
 
@@ -131,4 +132,4 @@ export class DependencyFile extends vscode.TreeItem {
     }
 }
 
-export type DependencyId = { id: string };
\ No newline at end of file
+export type DependencyId = { id: string };
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index c876048ba65..917a1d6b099 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -211,4 +211,4 @@ async function isFileAtUri(uri: vscode.Uri): Promise<boolean> {
     } catch {
         return false;
     }
-}
\ No newline at end of file
+}
-- 
cgit 1.4.1-3-g733a5


From bcb21311eae7f2c13ca012b3b3088b0d3b417c6d Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Thu, 27 Apr 2023 16:13:05 -0300
Subject: Accepting review suggestions

---
 crates/rust-analyzer/src/handlers.rs      | 39 +++++++++++++++----------------
 crates/rust-analyzer/src/lsp_ext.rs       |  4 ++--
 editors/code/src/commands.ts              |  3 +++
 editors/code/src/dependencies_provider.ts | 21 ++++++++++++-----
 editors/code/src/lsp_ext.ts               |  1 +
 5 files changed, 40 insertions(+), 28 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 4518b2a76a9..76ad847b133 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -58,23 +58,20 @@ pub(crate) fn fetch_dependency_list(
         .into_iter()
         .filter_map(|it| {
             let root_file_path = state.file_id_to_file_path(it.root_file_id);
-            crate_path(it.name.as_ref(), root_file_path).map(|path| CrateInfoResult {
+            crate_path(root_file_path).and_then(to_url).map(|path| CrateInfoResult {
                 name: it.name,
                 version: it.version,
-                path: path.to_string(),
+                path,
             })
         })
         .collect();
     Ok(FetchDependencyListResult { crates: crate_infos })
 }
 
-/// Searches for the directory of a Rust crate with a given name in the directory tree
-/// of the root file of that crate.
+/// Searches for the directory of a Rust crate given this crate's root file path.
 ///
 /// # Arguments
 ///
-/// * `crate_name`: The name of the crate to search for. This should be a `Some` value if
-///   a crate name has been specified, or `None` if no crate name has been specified.
 /// * `root_file_path`: The path to the root file of the crate.
 ///
 /// # Returns
@@ -82,19 +79,21 @@ pub(crate) fn fetch_dependency_list(
 /// An `Option` value representing the path to the directory of the crate with the given
 /// name, if such a crate is found. If no crate with the given name is found, this function
 /// returns `None`.
-fn crate_path(crate_name: Option<&String>, root_file_path: VfsPath) -> Option<VfsPath> {
-    crate_name.and_then(|crate_name| {
-        let mut root_path = root_file_path;
-        while let Some(path) = root_path.parent() {
-            if let Some((name, _)) = path.name_and_extension() {
-                if name.starts_with(crate_name.as_str()) {
-                    return Some(path);
-                }
-            } else {
-                break;
-            }
-            root_path = path;
+fn crate_path(root_file_path: VfsPath) -> Option<VfsPath> {
+    let mut current_dir = root_file_path.parent();
+    while let Some(path) = current_dir {
+        let cargo_toml_path = path.join("../Cargo.toml")?;
+        if fs::metadata(cargo_toml_path.as_path()?).is_ok() {
+            let crate_path = cargo_toml_path.parent()?;
+            return Some(crate_path);
         }
-        None
-    })
+        current_dir = path.parent();
+    }
+    None
+}
+
+fn to_url(path: VfsPath) -> Option<Url> {
+    let path = path.as_path()?;
+    let str_path = path.as_os_str().to_str()?;
+    Url::from_file_path(str_path).ok()
 }
\ No newline at end of file
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 8689fae0798..69e7d824680 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -4,11 +4,11 @@ use std::{collections::HashMap, path::PathBuf};
 
 use ide_db::line_index::WideEncoding;
 use lsp_types::request::Request;
-use lsp_types::PositionEncodingKind;
 use lsp_types::{
     notification::Notification, CodeActionKind, DocumentOnTypeFormattingParams,
     PartialResultParams, Position, Range, TextDocumentIdentifier, WorkDoneProgressParams,
 };
+use lsp_types::{PositionEncodingKind, Url};
 use serde::{Deserialize, Serialize};
 
 use crate::line_index::PositionEncoding;
@@ -32,7 +32,7 @@ pub struct AnalyzerStatusParams {
 pub struct CrateInfoResult {
     pub name: Option<String>,
     pub version: Option<String>,
-    pub path: String,
+    pub path: Url,
 }
 pub enum FetchDependencyList {}
 
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 81d3b8da7f9..98ccd50dc04 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -276,6 +276,9 @@ export function openCargoToml(ctx: CtxInit): Cmd {
 
 export function revealDependency(ctx: CtxInit): Cmd {
     return async (editor: RustEditor) => {
+        if (!ctx.dependencies?.isInitialized()) {
+            return;
+        }
         const documentPath = editor.document.uri.fsPath;
         const dep = ctx.dependencies?.getDependency(documentPath);
         if (dep) {
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 59b3b27731c..74fbacbb3cd 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -32,6 +32,10 @@ export class RustDependenciesProvider
         return filePath.toLowerCase() in this.dependenciesMap;
     }
 
+    isInitialized(): boolean {
+        return Object.keys(this.dependenciesMap).length !== 0;
+    }
+
     refresh(): void {
         this.dependenciesMap = {};
         this._onDidChangeTreeData.fire();
@@ -89,7 +93,12 @@ export class RustDependenciesProvider
     }
 
     private toDep(moduleName: string, version: string, path: string): Dependency {
-        return new Dependency(moduleName, version, path, vscode.TreeItemCollapsibleState.Collapsed);
+        return new Dependency(
+            moduleName,
+            version,
+            vscode.Uri.parse(path).fsPath,
+            vscode.TreeItemCollapsibleState.Collapsed
+        );
     }
 }
 
@@ -101,9 +110,9 @@ export class Dependency extends vscode.TreeItem {
         public readonly collapsibleState: vscode.TreeItemCollapsibleState
     ) {
         super(label, collapsibleState);
-        this.id = this.dependencyPath.toLowerCase();
-        this.description = this.version;
         this.resourceUri = vscode.Uri.file(dependencyPath);
+        this.id = this.resourceUri.fsPath.toLowerCase();
+        this.description = this.version;
         if (this.version) {
             this.tooltip = `${this.label}-${this.version}`;
         } else {
@@ -120,13 +129,13 @@ export class DependencyFile extends vscode.TreeItem {
         public readonly collapsibleState: vscode.TreeItemCollapsibleState
     ) {
         super(vscode.Uri.file(dependencyPath), collapsibleState);
-        this.id = this.dependencyPath.toLowerCase();
-        const isDir = fs.lstatSync(this.dependencyPath).isDirectory();
+        this.id = this.resourceUri!.fsPath.toLowerCase();
+        const isDir = fs.lstatSync(this.resourceUri!.fsPath).isDirectory();
         if (!isDir) {
             this.command = {
                 command: "vscode.open",
                 title: "Open File",
-                arguments: [vscode.Uri.file(this.dependencyPath)],
+                arguments: [this.resourceUri],
             };
         }
     }
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index b72804e510c..0d75392c92b 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -2,6 +2,7 @@
  * This file mirrors `crates/rust-analyzer/src/lsp_ext.rs` declarations.
  */
 
+import { Uri } from "vscode";
 import * as lc from "vscode-languageclient";
 
 // rust-analyzer overrides
-- 
cgit 1.4.1-3-g733a5


From 0aed507f1632703a0d3e123fd250fd2eba3ef446 Mon Sep 17 00:00:00 2001
From: Bruno Ortiz <brunortiz11@gmail.com>
Date: Thu, 27 Apr 2023 16:15:54 -0300
Subject: fixing TS linting, removing import

---
 editors/code/src/lsp_ext.ts | 1 -
 1 file changed, 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 0d75392c92b..b72804e510c 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -2,7 +2,6 @@
  * This file mirrors `crates/rust-analyzer/src/lsp_ext.rs` declarations.
  */
 
-import { Uri } from "vscode";
 import * as lc from "vscode-languageclient";
 
 // rust-analyzer overrides
-- 
cgit 1.4.1-3-g733a5


From 06cfeb47b25494eff718c1eb88ff0885f443113d Mon Sep 17 00:00:00 2001
From: Erik Steiger <rkstgr@gmail.com>
Date: Fri, 5 May 2023 14:41:03 +0200
Subject: Sort rust dependencies in tree view

---
 editors/code/src/dependencies_provider.ts | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'editors/code/src')

diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 74fbacbb3cd..cb306cb368a 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -89,6 +89,8 @@ export class RustDependenciesProvider
             const dep = this.toDep(crate.name || "unknown", crate.version || "", crate.path);
             this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
             return dep;
+        }).sort((a, b) => {
+            return a.label.localeCompare(b.label)
         });
     }
 
-- 
cgit 1.4.1-3-g733a5


From 91b4a169cdc1e51aeae4f8414b9b309ed00972fb Mon Sep 17 00:00:00 2001
From: Erik Steiger <rkstgr@gmail.com>
Date: Fri, 5 May 2023 14:49:42 +0200
Subject: Fix formatting

---
 editors/code/src/dependencies_provider.ts | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index cb306cb368a..8900aa9a5f3 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -85,13 +85,15 @@ export class RustDependenciesProvider
         );
         const crates = dependenciesResult.crates;
 
-        return crates.map((crate) => {
-            const dep = this.toDep(crate.name || "unknown", crate.version || "", crate.path);
-            this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
-            return dep;
-        }).sort((a, b) => {
-            return a.label.localeCompare(b.label)
-        });
+        return crates
+            .map((crate) => {
+                const dep = this.toDep(crate.name || "unknown", crate.version || "", crate.path);
+                this.dependenciesMap[dep.dependencyPath.toLowerCase()] = dep;
+                return dep;
+            })
+            .sort((a, b) => {
+                return a.label.localeCompare(b.label);
+            });
     }
 
     private toDep(moduleName: string, version: string, path: string): Dependency {
-- 
cgit 1.4.1-3-g733a5


From 7bc60f512ea56c54de30c7e12919c99f7f15ade4 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Sat, 6 May 2023 16:49:42 +0100
Subject: feat: define problem matcher for panics in VS Code

Now in VS Code "go to next error" (`F8`) will bring you to the source of
a panic.
---
 editors/code/package.json | 22 ++++++++++++++++++++++
 editors/code/src/tasks.ts |  2 +-
 2 files changed, 23 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index ca00da9f361..04573174235 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -1512,6 +1512,18 @@
                         "endColumn": 6
                     }
                 ]
+            },
+            {
+                "name": "rust-panic",
+                "patterns": [
+                    {
+                        "regexp": "^thread '.*' panicked at '(.*)', (.*):(\\d*):(\\d*)$",
+                        "message": 1,
+                        "file": 2,
+                        "line": 3,
+                        "column": 4
+                    }
+                ]
             }
         ],
         "languages": [
@@ -1561,6 +1573,16 @@
                 ],
                 "pattern": "$rustc-json"
             },
+            {
+                "name": "rust-panic",
+                "owner": "rust-panic",
+                "source": "panic",
+                "fileLocation": [
+                    "autoDetect",
+                    "${workspaceRoot}"
+                ],
+                "pattern": "$rust-panic"
+            },
             {
                 "name": "rustc-watch",
                 "owner": "rustc",
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index e6239deeb21..d6509d9aa6e 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -128,7 +128,7 @@ export async function buildCargoTask(
         name,
         TASK_SOURCE,
         exec,
-        ["$rustc"]
+        ["$rustc", "$rust-panic"]
     );
 }
 
-- 
cgit 1.4.1-3-g733a5


From 0028e73927fc4e3402c7243511936de0f2bc17bc Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 16 May 2023 22:08:58 +0200
Subject: fix: Force disable augmentsSyntaxTokens capability on VSCode

---
 editors/code/src/client.ts | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

(limited to 'editors/code/src')

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index b27d9f54943..f721fcce766 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -366,6 +366,7 @@ export async function createClient(
 
     // To turn on all proposed features use: client.registerProposedFeatures();
     client.registerFeature(new ExperimentalFeatures());
+    client.registerFeature(new OverrideFeatures());
 
     return client;
 }
@@ -401,6 +402,25 @@ class ExperimentalFeatures implements lc.StaticFeature {
     dispose(): void {}
 }
 
+class OverrideFeatures implements lc.StaticFeature {
+    getState(): lc.FeatureState {
+        return { kind: "static" };
+    }
+    fillClientCapabilities(capabilities: lc.ClientCapabilities): void {
+        // Force disable `augmentsSyntaxTokens`, VSCode's textmate grammar is somewhat incomplete
+        // making the experience generally worse
+        const caps = capabilities.textDocument?.semanticTokens;
+        if (caps) {
+            caps.augmentsSyntaxTokens = false;
+        }
+    }
+    initialize(
+        _capabilities: lc.ServerCapabilities,
+        _documentSelector: lc.DocumentSelector | undefined
+    ): void {}
+    dispose(): void {}
+}
+
 function isCodeActionWithoutEditsAndCommands(value: any): boolean {
     const candidate: lc.CodeAction = value;
     return (
-- 
cgit 1.4.1-3-g733a5


From 7dfef85be64a574577a2b7fe4d169e42503f0297 Mon Sep 17 00:00:00 2001
From: David Barsky <me@davidbarsky.com>
Date: Fri, 26 May 2023 11:50:07 -0400
Subject: fix: add a toggle to disable the dependency explorer.

---
 editors/code/package.json  | 7 ++++++-
 editors/code/src/config.ts | 4 ++++
 editors/code/src/ctx.ts    | 5 ++++-
 3 files changed, 14 insertions(+), 2 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index 96d63b42393..390508b883e 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -465,6 +465,11 @@
                     "default": true,
                     "type": "boolean"
                 },
+                "rust-analyzer.showDependenciesExplorer": {
+                    "markdownDescription": "Whether to show the dependencies view.",
+                    "default": true,
+                    "type": "boolean"
+                },
                 "$generated-start": {},
                 "rust-analyzer.assist.emitMustUse": {
                     "markdownDescription": "Whether to insert #[must_use] when generating `as_` methods\nfor enum variants.",
@@ -2013,7 +2018,7 @@
                 {
                     "id": "rustDependencies",
                     "name": "Rust Dependencies",
-                    "when": "inRustProject"
+                    "when": "inRustProject && config.rust-analyzer.showDependenciesExplorer"
                 }
             ]
         },
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index d6b8cc7a56a..c6d2bcc2b2a 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -284,6 +284,10 @@ export class Config {
     get useRustcErrorCode() {
         return this.get<boolean>("diagnostics.useRustcErrorCode");
     }
+
+    get showDependenciesExplorer() {
+        return this.get<boolean>("showDependenciesExplorer");
+    }
 }
 
 // the optional `cb?` parameter is meant to be used to add additional
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 8bed74b88ea..a72b5391ff1 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -263,7 +263,10 @@ export class Ctx {
         }
         await client.start();
         this.updateCommands();
-        this.prepareTreeDependenciesView(client);
+
+        if (this.config.showDependenciesExplorer) {
+            this.prepareTreeDependenciesView(client);
+        }
     }
 
     private prepareTreeDependenciesView(client: lc.LanguageClient) {
-- 
cgit 1.4.1-3-g733a5


From 6c3e15aaa057ab3c18c5575aacf9e1e56951b8ce Mon Sep 17 00:00:00 2001
From: Mohsen Alizadeh <mohsen@alizadeh.us>
Date: Sun, 25 Jun 2023 17:26:04 -0700
Subject: 13583 rename runnable env to runnables extra env

---
 docs/user/manual.adoc      | 6 +++---
 editors/code/package.json  | 2 +-
 editors/code/src/config.ts | 4 ++--
 editors/code/src/debug.ts  | 2 +-
 editors/code/src/run.ts    | 2 +-
 5 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'editors/code/src')

diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index 5a4078f16fe..bd924031e03 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -933,17 +933,17 @@ For example:
 More about `when` clause contexts https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts[here].
 
 ==== Setting runnable environment variables
-You can use "rust-analyzer.runnableEnv" setting to define runnable environment-specific substitution variables.
+You can use "rust-analyzer.runnables.extraEnv" setting to define runnable environment-specific substitution variables.
 The simplest way for all runnables in a bunch:
 ```jsonc
-"rust-analyzer.runnableEnv": {
+"rust-analyzer.runnables.extraEnv": {
     "RUN_SLOW_TESTS": "1"
 }
 ```
 
 Or it is possible to specify vars more granularly:
 ```jsonc
-"rust-analyzer.runnableEnv": [
+"rust-analyzer.runnables.extraEnv": [
     {
         // "mask": null, // null mask means that this rule will be applied for all runnables
         env: {
diff --git a/editors/code/package.json b/editors/code/package.json
index a95689193da..cdf9365b0a0 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -320,7 +320,7 @@
                     "default": null,
                     "description": "Custom cargo runner extension ID."
                 },
-                "rust-analyzer.runnableEnv": {
+                "rust-analyzer.runnables.extraEnv": {
                     "anyOf": [
                         {
                             "type": "null"
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index c6d2bcc2b2a..13e6bbc1d25 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -224,8 +224,8 @@ export class Config {
         return this.get<string | undefined>("cargoRunner");
     }
 
-    get runnableEnv() {
-        const item = this.get<any>("runnableEnv");
+    get runnablesExtraEnv() {
+        const item = this.get<any>("runnables.extraEnv");
         if (!item) return item;
         const fixRecord = (r: Record<string, any>) => {
             for (const key in r) {
diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
index cffee1de6af..8fbd427039e 100644
--- a/editors/code/src/debug.ts
+++ b/editors/code/src/debug.ts
@@ -118,7 +118,7 @@ async function getDebugConfiguration(
         return path.normalize(p).replace(wsFolder, "${workspaceFolder" + workspaceQualifier + "}");
     }
 
-    const env = prepareEnv(runnable, ctx.config.runnableEnv);
+    const env = prepareEnv(runnable, ctx.config.runnablesExtraEnv);
     const executable = await getDebugExecutable(runnable, env);
     let sourceFileMap = debugOptions.sourceFileMap;
     if (sourceFileMap === "auto") {
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index 623fb102953..cc2ecfa2d80 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -140,7 +140,7 @@ export async function createTask(runnable: ra.Runnable, config: Config): Promise
         command: args[0], // run, test, etc...
         args: args.slice(1),
         cwd: runnable.args.workspaceRoot || ".",
-        env: prepareEnv(runnable, config.runnableEnv),
+        env: prepareEnv(runnable, config.runnablesExtraEnv),
         overrideCargo: runnable.args.overrideCargo,
     };
 
-- 
cgit 1.4.1-3-g733a5


From 8e0efbc2a78d5b723caf51f5e4732a523b4b91a0 Mon Sep 17 00:00:00 2001
From: Tetsuharu Ohzeki <tetsuharu.ohzeki@gmail.com>
Date: Wed, 28 Jun 2023 03:12:42 +0900
Subject: editor/code: Enable `noImplicitOverride` ts option

---
 editors/code/src/dependencies_provider.ts | 8 ++++----
 editors/code/tsconfig.json                | 1 -
 2 files changed, 4 insertions(+), 5 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 8900aa9a5f3..d67345258ec 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -108,10 +108,10 @@ export class RustDependenciesProvider
 
 export class Dependency extends vscode.TreeItem {
     constructor(
-        public readonly label: string,
+        public override readonly label: string,
         private version: string,
         readonly dependencyPath: string,
-        public readonly collapsibleState: vscode.TreeItemCollapsibleState
+        public override readonly collapsibleState: vscode.TreeItemCollapsibleState
     ) {
         super(label, collapsibleState);
         this.resourceUri = vscode.Uri.file(dependencyPath);
@@ -127,10 +127,10 @@ export class Dependency extends vscode.TreeItem {
 
 export class DependencyFile extends vscode.TreeItem {
     constructor(
-        readonly label: string,
+        override readonly label: string,
         readonly dependencyPath: string,
         readonly parent: Dependency | DependencyFile,
-        public readonly collapsibleState: vscode.TreeItemCollapsibleState
+        public override readonly collapsibleState: vscode.TreeItemCollapsibleState
     ) {
         super(vscode.Uri.file(dependencyPath), collapsibleState);
         this.id = this.resourceUri!.fsPath.toLowerCase();
diff --git a/editors/code/tsconfig.json b/editors/code/tsconfig.json
index 50e3d68460a..04bd4569377 100644
--- a/editors/code/tsconfig.json
+++ b/editors/code/tsconfig.json
@@ -13,7 +13,6 @@
         // to update typescript version without any code change.
         "useUnknownInCatchVariables": false,
         "exactOptionalPropertyTypes": false,
-        "noImplicitOverride": false,
         "noPropertyAccessFromIndexSignature": false,
         "noUncheckedIndexedAccess": false
     },
-- 
cgit 1.4.1-3-g733a5


From 3f70117d69251d01b0ca2de8324eb5dafa8ff193 Mon Sep 17 00:00:00 2001
From: Mohsen Alizadeh <mohsen@alizadeh.us>
Date: Wed, 28 Jun 2023 21:24:28 -0700
Subject: fallback to old key

---
 editors/code/src/config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 13e6bbc1d25..ee9ba7465ab 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -225,7 +225,7 @@ export class Config {
     }
 
     get runnablesExtraEnv() {
-        const item = this.get<any>("runnables.extraEnv");
+        const item = this.get<any>("runnables.extraEnv") ?? this.get<any>("runnableEnv");
         if (!item) return item;
         const fixRecord = (r: Record<string, any>) => {
             for (const key in r) {
-- 
cgit 1.4.1-3-g733a5


From 832a64e290ce97e6ae9fce3743dc2f38c4088ccd Mon Sep 17 00:00:00 2001
From: Alex Kladov <aleksey.kladov@gmail.com>
Date: Fri, 30 Jun 2023 22:18:52 +0100
Subject: feat: don't add panics to error jump list by default

To re-enable this, use

    "rust-analyzer.runnables.problemMatcher": [
        "$rustc",
        "$rust-panic"
    ],

setting.

closes: #14977
---
 editors/code/package.json  | 10 ++++++++++
 editors/code/src/config.ts |  4 ++++
 editors/code/src/run.ts    |  1 +
 editors/code/src/tasks.ts  |  5 ++++-
 4 files changed, 19 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/package.json b/editors/code/package.json
index fe060ce698b..1a1d76c6991 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -339,6 +339,16 @@
                     "default": null,
                     "markdownDescription": "Environment variables passed to the runnable launched using `Test` or `Debug` lens or `rust-analyzer.run` command."
                 },
+                "rust-analyzer.runnables.problemMatcher": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "default": [
+                        "$rustc"
+                    ],
+                    "markdownDescription": "Problem matchers to use for `rust-analyzer.run` command, eg `[\"$rustc\", \"$rust-panic\"]`."
+                },
                 "rust-analyzer.server.path": {
                     "type": [
                         "null",
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index ee9ba7465ab..15a1d4e0f1d 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -220,6 +220,10 @@ export class Config {
         return this.get<string[] | undefined>("discoverProjectCommand");
     }
 
+    get problemMatcher(): string[] {
+        return this.get<string[]>("runnables.problemMatcher") || [];
+    }
+
     get cargoRunner() {
         return this.get<string | undefined>("cargoRunner");
     }
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index cc2ecfa2d80..bdd85243133 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -151,6 +151,7 @@ export async function createTask(runnable: ra.Runnable, config: Config): Promise
         definition,
         runnable.label,
         args,
+        config.problemMatcher,
         config.cargoRunner,
         true
     );
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index d6509d9aa6e..efb889dc797 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -46,6 +46,7 @@ class CargoTaskProvider implements vscode.TaskProvider {
                     { type: TASK_TYPE, command: def.command },
                     `cargo ${def.command}`,
                     [def.command],
+                    this.config.problemMatcher,
                     this.config.cargoRunner
                 );
                 vscodeTask.group = def.group;
@@ -70,6 +71,7 @@ class CargoTaskProvider implements vscode.TaskProvider {
                 definition,
                 task.name,
                 args,
+                this.config.problemMatcher,
                 this.config.cargoRunner
             );
         }
@@ -83,6 +85,7 @@ export async function buildCargoTask(
     definition: CargoTaskDefinition,
     name: string,
     args: string[],
+    problemMatcher: string[],
     customRunner?: string,
     throwOnError: boolean = false
 ): Promise<vscode.Task> {
@@ -128,7 +131,7 @@ export async function buildCargoTask(
         name,
         TASK_SOURCE,
         exec,
-        ["$rustc", "$rust-panic"]
+        problemMatcher
     );
 }
 
-- 
cgit 1.4.1-3-g733a5


From 72a3883a7128b4eae6f38d6479f33aaaaae4790b Mon Sep 17 00:00:00 2001
From: Tetsuharu Ohzeki <tetsuharu.ohzeki@gmail.com>
Date: Wed, 28 Jun 2023 04:03:53 +0900
Subject: editor/code: Enable `noUncheckedIndexedAccess` ts option

https://www.typescriptlang.org/tsconfig#noUncheckedIndexedAccess
---
 editors/code/src/ast_inspector.ts         |  6 ++--
 editors/code/src/client.ts                |  7 ++--
 editors/code/src/commands.ts              | 14 ++++++--
 editors/code/src/config.ts                | 54 +++++++++++++++++--------------
 editors/code/src/debug.ts                 | 12 +++----
 editors/code/src/dependencies_provider.ts |  8 ++++-
 editors/code/src/diagnostics.ts           |  4 ++-
 editors/code/src/nullable.ts              | 19 +++++++++++
 editors/code/src/run.ts                   | 11 ++++---
 editors/code/src/snippets.ts              |  6 ++--
 editors/code/src/tasks.ts                 |  4 ++-
 editors/code/src/toolchain.ts             |  9 ++++--
 editors/code/src/undefinable.ts           | 19 +++++++++++
 editors/code/tsconfig.json                |  3 +-
 14 files changed, 124 insertions(+), 52 deletions(-)
 create mode 100644 editors/code/src/nullable.ts
 create mode 100644 editors/code/src/undefinable.ts

(limited to 'editors/code/src')

diff --git a/editors/code/src/ast_inspector.ts b/editors/code/src/ast_inspector.ts
index 176040120f4..fa963d8eb99 100644
--- a/editors/code/src/ast_inspector.ts
+++ b/editors/code/src/ast_inspector.ts
@@ -2,6 +2,7 @@ import * as vscode from "vscode";
 
 import { Ctx, Disposable } from "./ctx";
 import { RustEditor, isRustEditor } from "./util";
+import { unwrapUndefinable } from "./undefinable";
 
 // FIXME: consider implementing this via the Tree View API?
 // https://code.visualstudio.com/api/extension-guides/tree-view
@@ -164,8 +165,9 @@ export class AstInspector implements vscode.HoverProvider, vscode.DefinitionProv
         if (!parsedRange) return;
 
         const [begin, end] = parsedRange.slice(1).map((off) => this.positionAt(doc, +off));
-
-        return new vscode.Range(begin, end);
+        const actualBegin = unwrapUndefinable(begin);
+        const actualEnd = unwrapUndefinable(end);
+        return new vscode.Range(actualBegin, actualEnd);
     }
 
     // Memoize the last value, otherwise the CPU is at 100% single core
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index f721fcce766..7b151c804af 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -9,6 +9,7 @@ import { WorkspaceEdit } from "vscode";
 import { Config, prepareVSCodeConfig } from "./config";
 import { randomUUID } from "crypto";
 import { sep as pathSeparator } from "path";
+import { unwrapUndefinable } from "./undefinable";
 
 export interface Env {
     [name: string]: string;
@@ -323,10 +324,12 @@ export async function createClient(
                         }
                         for (const [group, { index, items }] of groups) {
                             if (items.length === 1) {
-                                result[index] = items[0];
+                                const item = unwrapUndefinable(items[0]);
+                                result[index] = item;
                             } else {
                                 const action = new vscode.CodeAction(group);
-                                action.kind = items[0].kind;
+                                const item = unwrapUndefinable(items[0]);
+                                action.kind = item.kind;
                                 action.command = {
                                     command: "rust-analyzer.applyActionGroup",
                                     title: "",
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 98ccd50dc04..3c6105e89fe 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -20,6 +20,7 @@ import { startDebugSession, makeDebugConfig } from "./debug";
 import { LanguageClient } from "vscode-languageclient/node";
 import { LINKED_COMMANDS } from "./client";
 import { DependencyId } from "./dependencies_provider";
+import { unwrapUndefinable } from "./undefinable";
 
 export * from "./ast_inspector";
 export * from "./run";
@@ -129,7 +130,8 @@ export function matchingBrace(ctx: CtxInit): Cmd {
             ),
         });
         editor.selections = editor.selections.map((sel, idx) => {
-            const active = client.protocol2CodeConverter.asPosition(response[idx]);
+            const position = unwrapUndefinable(response[idx]);
+            const active = client.protocol2CodeConverter.asPosition(position);
             const anchor = sel.isEmpty ? active : sel.anchor;
             return new vscode.Selection(anchor, active);
         });
@@ -231,7 +233,7 @@ export function parentModule(ctx: CtxInit): Cmd {
         if (!locations) return;
 
         if (locations.length === 1) {
-            const loc = locations[0];
+            const loc = unwrapUndefinable(locations[0]);
 
             const uri = client.protocol2CodeConverter.asUri(loc.targetUri);
             const range = client.protocol2CodeConverter.asRange(loc.targetRange);
@@ -331,7 +333,13 @@ async function revealParentChain(document: RustDocument, ctx: CtxInit) {
     } while (!ctx.dependencies?.contains(documentPath));
     parentChain.reverse();
     for (const idx in parentChain) {
-        await ctx.treeView?.reveal(parentChain[idx], { select: true, expand: true });
+        const treeView = ctx.treeView;
+        if (!treeView) {
+            continue;
+        }
+
+        const dependency = unwrapUndefinable(parentChain[idx]);
+        await treeView.reveal(dependency, { select: true, expand: true });
     }
 }
 
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 15a1d4e0f1d..9595ba05282 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -4,6 +4,7 @@ import * as path from "path";
 import * as vscode from "vscode";
 import { Env } from "./client";
 import { log } from "./util";
+import { expectNotUndefined, unwrapUndefinable } from "./undefinable";
 
 export type RunnableEnvCfg =
     | undefined
@@ -338,7 +339,7 @@ export function substituteVariablesInEnv(env: Env): Env {
             const depRe = new RegExp(/\${(?<depName>.+?)}/g);
             let match = undefined;
             while ((match = depRe.exec(value))) {
-                const depName = match.groups!.depName;
+                const depName = unwrapUndefinable(match.groups?.depName);
                 deps.add(depName);
                 // `depName` at this point can have a form of `expression` or
                 // `prefix:expression`
@@ -356,7 +357,7 @@ export function substituteVariablesInEnv(env: Env): Env {
         if (match) {
             const { prefix, body } = match.groups!;
             if (prefix === "env") {
-                const envName = body;
+                const envName = unwrapUndefinable(body);
                 envWithDeps[dep] = {
                     value: process.env[envName] ?? "",
                     deps: [],
@@ -384,13 +385,12 @@ export function substituteVariablesInEnv(env: Env): Env {
     do {
         leftToResolveSize = toResolve.size;
         for (const key of toResolve) {
-            if (envWithDeps[key].deps.every((dep) => resolved.has(dep))) {
-                envWithDeps[key].value = envWithDeps[key].value.replace(
-                    /\${(?<depName>.+?)}/g,
-                    (_wholeMatch, depName) => {
-                        return envWithDeps[depName].value;
-                    }
-                );
+            const item = unwrapUndefinable(envWithDeps[key]);
+            if (item.deps.every((dep) => resolved.has(dep))) {
+                item.value = item.value.replace(/\${(?<depName>.+?)}/g, (_wholeMatch, depName) => {
+                    const item = unwrapUndefinable(envWithDeps[depName]);
+                    return item.value;
+                });
                 resolved.add(key);
                 toResolve.delete(key);
             }
@@ -399,7 +399,8 @@ export function substituteVariablesInEnv(env: Env): Env {
 
     const resolvedEnv: Env = {};
     for (const key of Object.keys(env)) {
-        resolvedEnv[key] = envWithDeps[`env:${key}`].value;
+        const item = unwrapUndefinable(envWithDeps[`env:${key}`]);
+        resolvedEnv[key] = item.value;
     }
     return resolvedEnv;
 }
@@ -418,20 +419,19 @@ function substituteVSCodeVariableInString(val: string): string {
 function computeVscodeVar(varName: string): string | null {
     const workspaceFolder = () => {
         const folders = vscode.workspace.workspaceFolders ?? [];
-        if (folders.length === 1) {
-            // TODO: support for remote workspaces?
-            return folders[0].uri.fsPath;
-        } else if (folders.length > 1) {
-            // could use currently opened document to detect the correct
-            // workspace. However, that would be determined by the document
-            // user has opened on Editor startup. Could lead to
-            // unpredictable workspace selection in practice.
-            // It's better to pick the first one
-            return folders[0].uri.fsPath;
-        } else {
-            // no workspace opened
-            return "";
-        }
+        const folder = folders[0];
+        // TODO: support for remote workspaces?
+        const fsPath: string =
+            folder === undefined
+                ? // no workspace opened
+                  ""
+                : // could use currently opened document to detect the correct
+                  // workspace. However, that would be determined by the document
+                  // user has opened on Editor startup. Could lead to
+                  // unpredictable workspace selection in practice.
+                  // It's better to pick the first one
+                  folder.uri.fsPath;
+        return fsPath;
     };
     // https://code.visualstudio.com/docs/editor/variables-reference
     const supportedVariables: { [k: string]: () => string } = {
@@ -454,7 +454,11 @@ function computeVscodeVar(varName: string): string | null {
     };
 
     if (varName in supportedVariables) {
-        return supportedVariables[varName]();
+        const fn = expectNotUndefined(
+            supportedVariables[varName],
+            `${varName} should not be undefined here`
+        );
+        return fn();
     } else {
         // return "${" + varName + "}";
         return null;
diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
index 8fbd427039e..ede90d707dd 100644
--- a/editors/code/src/debug.ts
+++ b/editors/code/src/debug.ts
@@ -6,6 +6,7 @@ import * as ra from "./lsp_ext";
 import { Cargo, getRustcId, getSysroot } from "./toolchain";
 import { Ctx } from "./ctx";
 import { prepareEnv } from "./run";
+import { unwrapUndefinable } from "./undefinable";
 
 const debugOutput = vscode.window.createOutputChannel("Debug");
 type DebugConfigProvider = (
@@ -105,12 +106,13 @@ async function getDebugConfiguration(
     const workspaceFolders = vscode.workspace.workspaceFolders!;
     const isMultiFolderWorkspace = workspaceFolders.length > 1;
     const firstWorkspace = workspaceFolders[0];
-    const workspace =
+    const maybeWorkspace =
         !isMultiFolderWorkspace || !runnable.args.workspaceRoot
             ? firstWorkspace
             : workspaceFolders.find((w) => runnable.args.workspaceRoot?.includes(w.uri.fsPath)) ||
               firstWorkspace;
 
+    const workspace = unwrapUndefinable(maybeWorkspace);
     const wsFolder = path.normalize(workspace.uri.fsPath);
     const workspaceQualifier = isMultiFolderWorkspace ? `:${workspace.name}` : "";
     function simplifyPath(p: string): string {
@@ -130,12 +132,8 @@ async function getDebugConfiguration(
         sourceFileMap[`/rustc/${commitHash}/`] = rustlib;
     }
 
-    const debugConfig = knownEngines[debugEngine.id](
-        runnable,
-        simplifyPath(executable),
-        env,
-        sourceFileMap
-    );
+    const provider = unwrapUndefinable(knownEngines[debugEngine.id]);
+    const debugConfig = provider(runnable, simplifyPath(executable), env, sourceFileMap);
     if (debugConfig.type in debugOptions.engineSettings) {
         const settingsMap = (debugOptions.engineSettings as any)[debugConfig.type];
         for (var key in settingsMap) {
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index d67345258ec..51ba11ecc92 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -4,6 +4,7 @@ import * as fs from "fs";
 import { CtxInit } from "./ctx";
 import * as ra from "./lsp_ext";
 import { FetchDependencyListResult } from "./lsp_ext";
+import { unwrapUndefinable } from "./undefinable";
 
 export class RustDependenciesProvider
     implements vscode.TreeDataProvider<Dependency | DependencyFile>
@@ -49,7 +50,12 @@ export class RustDependenciesProvider
     }
 
     getTreeItem(element: Dependency | DependencyFile): vscode.TreeItem | Thenable<vscode.TreeItem> {
-        if (element.id! in this.dependenciesMap) return this.dependenciesMap[element.id!];
+        const dependenciesMap = this.dependenciesMap;
+        const elementId = element.id!;
+        if (elementId in dependenciesMap) {
+            const dependency = unwrapUndefinable(dependenciesMap[elementId]);
+            return dependency;
+        }
         return element;
     }
 
diff --git a/editors/code/src/diagnostics.ts b/editors/code/src/diagnostics.ts
index 9695d8bf26d..a7e0845a278 100644
--- a/editors/code/src/diagnostics.ts
+++ b/editors/code/src/diagnostics.ts
@@ -2,6 +2,7 @@ import * as anser from "anser";
 import * as vscode from "vscode";
 import { ProviderResult, Range, TextEditorDecorationType, ThemeColor, window } from "vscode";
 import { Ctx } from "./ctx";
+import { unwrapUndefinable } from "./undefinable";
 
 export const URI_SCHEME = "rust-analyzer-diagnostics-view";
 
@@ -195,7 +196,8 @@ export class AnsiDecorationProvider implements vscode.Disposable {
             // anser won't return both the RGB and the color name at the same time,
             // so just fake a single foreground control char with the palette number:
             const spans = anser.ansiToJson(`\x1b[38;5;${paletteColor}m`);
-            const rgb = spans[1].fg;
+            const span = unwrapUndefinable(spans[1]);
+            const rgb = span.fg;
 
             if (rgb) {
                 return `rgb(${rgb})`;
diff --git a/editors/code/src/nullable.ts b/editors/code/src/nullable.ts
new file mode 100644
index 00000000000..e973e162907
--- /dev/null
+++ b/editors/code/src/nullable.ts
@@ -0,0 +1,19 @@
+export type NotNull<T> = T extends null ? never : T;
+
+export type Nullable<T> = T | null;
+
+function isNotNull<T>(input: Nullable<T>): input is NotNull<T> {
+    return input !== null;
+}
+
+function expectNotNull<T>(input: Nullable<T>, msg: string): NotNull<T> {
+    if (isNotNull(input)) {
+        return input;
+    }
+
+    throw new TypeError(msg);
+}
+
+export function unwrapNullable<T>(input: Nullable<T>): NotNull<T> {
+    return expectNotNull(input, `unwrapping \`null\``);
+}
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index bdd85243133..c20a5487b77 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -6,6 +6,7 @@ import * as tasks from "./tasks";
 import { CtxInit } from "./ctx";
 import { makeDebugConfig } from "./debug";
 import { Config, RunnableEnvCfg } from "./config";
+import { unwrapUndefinable } from "./undefinable";
 
 const quickPickButtons = [
     { iconPath: new vscode.ThemeIcon("save"), tooltip: "Save as a launch.json configuration." },
@@ -68,12 +69,14 @@ export async function selectRunnable(
             quickPick.onDidHide(() => close()),
             quickPick.onDidAccept(() => close(quickPick.selectedItems[0])),
             quickPick.onDidTriggerButton(async (_button) => {
-                await makeDebugConfig(ctx, quickPick.activeItems[0].runnable);
+                const runnable = unwrapUndefinable(quickPick.activeItems[0]).runnable;
+                await makeDebugConfig(ctx, runnable);
                 close();
             }),
-            quickPick.onDidChangeActive((active) => {
-                if (showButtons && active.length > 0) {
-                    if (active[0].label.startsWith("cargo")) {
+            quickPick.onDidChangeActive((activeList) => {
+                if (showButtons && activeList.length > 0) {
+                    const active = unwrapUndefinable(activeList[0]);
+                    if (active.label.startsWith("cargo")) {
                         // save button makes no sense for `cargo test` or `cargo check`
                         quickPick.buttons = [];
                     } else if (quickPick.buttons.length === 0) {
diff --git a/editors/code/src/snippets.ts b/editors/code/src/snippets.ts
index 299d29c27ee..1ad93d280ba 100644
--- a/editors/code/src/snippets.ts
+++ b/editors/code/src/snippets.ts
@@ -1,10 +1,11 @@
 import * as vscode from "vscode";
 
 import { assert } from "./util";
+import { unwrapUndefinable } from "./undefinable";
 
 export async function applySnippetWorkspaceEdit(edit: vscode.WorkspaceEdit) {
     if (edit.entries().length === 1) {
-        const [uri, edits] = edit.entries()[0];
+        const [uri, edits] = unwrapUndefinable(edit.entries()[0]);
         const editor = await editorFromUri(uri);
         if (editor) await applySnippetTextEdits(editor, edits);
         return;
@@ -68,7 +69,8 @@ export async function applySnippetTextEdits(editor: vscode.TextEditor, edits: vs
     });
     if (selections.length > 0) editor.selections = selections;
     if (selections.length === 1) {
-        editor.revealRange(selections[0], vscode.TextEditorRevealType.InCenterIfOutsideViewport);
+        const selection = unwrapUndefinable(selections[0]);
+        editor.revealRange(selection, vscode.TextEditorRevealType.InCenterIfOutsideViewport);
     }
 }
 
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index efb889dc797..5199508c822 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -2,6 +2,7 @@ import * as vscode from "vscode";
 import * as toolchain from "./toolchain";
 import { Config } from "./config";
 import { log } from "./util";
+import { unwrapUndefinable } from "./undefinable";
 
 // This ends up as the `type` key in tasks.json. RLS also uses `cargo` and
 // our configuration should be compatible with it so use the same key.
@@ -120,7 +121,8 @@ export async function buildCargoTask(
 
         const fullCommand = [...cargoCommand, ...args];
 
-        exec = new vscode.ProcessExecution(fullCommand[0], fullCommand.slice(1), definition);
+        const processName = unwrapUndefinable(fullCommand[0]);
+        exec = new vscode.ProcessExecution(processName, fullCommand.slice(1), definition);
     }
 
     return new vscode.Task(
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 917a1d6b099..b2c0c669db2 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -4,6 +4,8 @@ import * as path from "path";
 import * as readline from "readline";
 import * as vscode from "vscode";
 import { execute, log, memoizeAsync } from "./util";
+import { unwrapNullable } from "./nullable";
+import { unwrapUndefinable } from "./undefinable";
 
 interface CompilationArtifact {
     fileName: string;
@@ -93,7 +95,8 @@ export class Cargo {
             throw new Error("Multiple compilation artifacts are not supported.");
         }
 
-        return artifacts[0].fileName;
+        const artifact = unwrapUndefinable(artifacts[0]);
+        return artifact.fileName;
     }
 
     private async runCargo(
@@ -142,7 +145,9 @@ export async function getRustcId(dir: string): Promise<string> {
     const data = await execute(`${rustcPath} -V -v`, { cwd: dir });
     const rx = /commit-hash:\s(.*)$/m;
 
-    return rx.exec(data)![1];
+    const result = unwrapNullable(rx.exec(data));
+    const first = unwrapUndefinable(result[1]);
+    return first;
 }
 
 /** Mirrors `toolchain::cargo()` implementation */
diff --git a/editors/code/src/undefinable.ts b/editors/code/src/undefinable.ts
new file mode 100644
index 00000000000..813bac5a123
--- /dev/null
+++ b/editors/code/src/undefinable.ts
@@ -0,0 +1,19 @@
+export type NotUndefined<T> = T extends undefined ? never : T;
+
+export type Undefinable<T> = T | undefined;
+
+function isNotUndefined<T>(input: Undefinable<T>): input is NotUndefined<T> {
+    return input !== undefined;
+}
+
+export function expectNotUndefined<T>(input: Undefinable<T>, msg: string): NotUndefined<T> {
+    if (isNotUndefined(input)) {
+        return input;
+    }
+
+    throw new TypeError(msg);
+}
+
+export function unwrapUndefinable<T>(input: Undefinable<T>): NotUndefined<T> {
+    return expectNotUndefined(input, `unwrapping \`undefined\``);
+}
diff --git a/editors/code/tsconfig.json b/editors/code/tsconfig.json
index 3f887a41b3d..12d31f0bee3 100644
--- a/editors/code/tsconfig.json
+++ b/editors/code/tsconfig.json
@@ -14,8 +14,7 @@
         // to update typescript version without any code change.
         "useUnknownInCatchVariables": false,
         "exactOptionalPropertyTypes": false,
-        "noPropertyAccessFromIndexSignature": false,
-        "noUncheckedIndexedAccess": false
+        "noPropertyAccessFromIndexSignature": false
     },
     "exclude": ["node_modules", ".vscode-test"],
     "include": ["src", "tests"]
-- 
cgit 1.4.1-3-g733a5


From f70845305f54181e1681828c7935305c66e743bb Mon Sep 17 00:00:00 2001
From: Tetsuharu Ohzeki <tetsuharu.ohzeki@gmail.com>
Date: Wed, 28 Jun 2023 18:15:30 +0900
Subject: editor/code: Enable `noPropertyAccessFromIndexSignature` ts option

---
 editors/code/src/bootstrap.ts            | 2 +-
 editors/code/src/config.ts               | 4 ++--
 editors/code/src/debug.ts                | 5 +++--
 editors/code/src/toolchain.ts            | 2 +-
 editors/code/tests/unit/settings.test.ts | 2 +-
 editors/code/tsconfig.json               | 3 +--
 6 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/bootstrap.ts b/editors/code/src/bootstrap.ts
index b38fa06a85c..7b831a8a695 100644
--- a/editors/code/src/bootstrap.ts
+++ b/editors/code/src/bootstrap.ts
@@ -36,7 +36,7 @@ async function getServer(
     config: Config,
     state: PersistentState
 ): Promise<string | undefined> {
-    const explicitPath = process.env.__RA_LSP_SERVER_DEBUG ?? config.serverPath;
+    const explicitPath = process.env["__RA_LSP_SERVER_DEBUG"] ?? config.serverPath;
     if (explicitPath) {
         if (explicitPath.startsWith("~/")) {
             return os.homedir() + explicitPath.slice("~".length);
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 9595ba05282..deea958f8da 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -339,7 +339,7 @@ export function substituteVariablesInEnv(env: Env): Env {
             const depRe = new RegExp(/\${(?<depName>.+?)}/g);
             let match = undefined;
             while ((match = depRe.exec(value))) {
-                const depName = unwrapUndefinable(match.groups?.depName);
+                const depName = unwrapUndefinable(match.groups?.["depName"]);
                 deps.add(depName);
                 // `depName` at this point can have a form of `expression` or
                 // `prefix:expression`
@@ -448,7 +448,7 @@ function computeVscodeVar(varName: string): string | null {
         // https://github.com/microsoft/vscode/blob/08ac1bb67ca2459496b272d8f4a908757f24f56f/src/vs/workbench/api/common/extHostVariableResolverService.ts#L81
         // or
         // https://github.com/microsoft/vscode/blob/29eb316bb9f154b7870eb5204ec7f2e7cf649bec/src/vs/server/node/remoteTerminalChannel.ts#L56
-        execPath: () => process.env.VSCODE_EXEC_PATH ?? process.execPath,
+        execPath: () => process.env["VSCODE_EXEC_PATH"] ?? process.execPath,
 
         pathSeparator: () => path.sep,
     };
diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
index ede90d707dd..29758feafe4 100644
--- a/editors/code/src/debug.ts
+++ b/editors/code/src/debug.ts
@@ -147,8 +147,9 @@ async function getDebugConfiguration(
         debugConfig.name = `run ${path.basename(executable)}`;
     }
 
-    if (debugConfig.cwd) {
-        debugConfig.cwd = simplifyPath(debugConfig.cwd);
+    const cwd = debugConfig["cwd"];
+    if (cwd) {
+        debugConfig["cwd"] = simplifyPath(cwd);
     }
 
     return debugConfig;
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index b2c0c669db2..014e6b66f64 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -176,7 +176,7 @@ export const getPathForExecutable = memoizeAsync(
 );
 
 async function lookupInPath(exec: string): Promise<boolean> {
-    const paths = process.env.PATH ?? "";
+    const paths = process.env["PATH"] ?? "";
 
     const candidates = paths.split(path.delimiter).flatMap((dirInPath) => {
         const candidate = path.join(dirInPath, exec);
diff --git a/editors/code/tests/unit/settings.test.ts b/editors/code/tests/unit/settings.test.ts
index 2cc1b670dc8..f171f5f74f3 100644
--- a/editors/code/tests/unit/settings.test.ts
+++ b/editors/code/tests/unit/settings.test.ts
@@ -57,7 +57,7 @@ export async function getTests(ctx: Context) {
                 USING_VSCODE_VAR: "${workspaceFolderBasename}",
             };
             const actualEnv = await substituteVariablesInEnv(envJson);
-            assert.deepStrictEqual(actualEnv.USING_VSCODE_VAR, "code");
+            assert.deepStrictEqual(actualEnv["USING_VSCODE_VAR"], "code");
         });
     });
 }
diff --git a/editors/code/tsconfig.json b/editors/code/tsconfig.json
index 12d31f0bee3..4b107a5d251 100644
--- a/editors/code/tsconfig.json
+++ b/editors/code/tsconfig.json
@@ -13,8 +13,7 @@
         // These disables some enhancement type checking options
         // to update typescript version without any code change.
         "useUnknownInCatchVariables": false,
-        "exactOptionalPropertyTypes": false,
-        "noPropertyAccessFromIndexSignature": false
+        "exactOptionalPropertyTypes": false
     },
     "exclude": ["node_modules", ".vscode-test"],
     "include": ["src", "tests"]
-- 
cgit 1.4.1-3-g733a5


From ebaf8c8135dfc0d655fe26fe38b5282df39fff26 Mon Sep 17 00:00:00 2001
From: DropDemBits <r3usrlnd@gmail.com>
Date: Thu, 6 Jul 2023 23:25:02 -0400
Subject: fix: Indent after pressing enter on a blank line

---
 editors/code/src/config.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index da7c74c28ba..5c63823321c 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -99,7 +99,8 @@ export class Config {
         let onEnterRules: vscode.OnEnterRule[] = [
             {
                 // Carry indentation from the previous line
-                beforeText: /^\s*$/,
+                // if it's only whitespace
+                beforeText: /^\s+$/,
                 action: { indentAction: vscode.IndentAction.None },
             },
             {
-- 
cgit 1.4.1-3-g733a5


From cfa15d49aaff173a055617a347eda6f6caa9e915 Mon Sep 17 00:00:00 2001
From: Adenine <adenine.dev@gmail.com>
Date: Sun, 18 Jun 2023 20:31:46 -0400
Subject: implement first pass of memory layout viewer

---
 crates/ide/src/lib.rs                        |   6 +
 crates/ide/src/view_memory_layout.rs         | 170 ++++++++++++++++
 crates/rust-analyzer/src/handlers/request.rs |  28 +++
 crates/rust-analyzer/src/lsp_ext.rs          |  34 ++++
 crates/rust-analyzer/src/main_loop.rs        |   1 +
 editors/code/package.json                    |   9 +
 editors/code/src/commands.ts                 | 283 +++++++++++++++++++++++++++
 editors/code/src/lsp_ext.ts                  |  27 ++-
 editors/code/src/main.ts                     |   9 +-
 9 files changed, 561 insertions(+), 6 deletions(-)
 create mode 100644 crates/ide/src/view_memory_layout.rs

(limited to 'editors/code/src')

diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index cb2a1140ba8..a9a8f6903b2 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -60,6 +60,7 @@ mod interpret_function;
 mod view_item_tree;
 mod shuffle_crate_graph;
 mod fetch_crates;
+mod view_memory_layout;
 
 use std::ffi::OsStr;
 
@@ -74,6 +75,7 @@ use ide_db::{
 };
 use syntax::SourceFile;
 use triomphe::Arc;
+use view_memory_layout::{view_memory_layout, RecursiveMemoryLayout};
 
 use crate::navigation_target::{ToNav, TryToNav};
 
@@ -724,6 +726,10 @@ impl Analysis {
         self.with_db(|db| move_item::move_item(db, range, direction))
     }
 
+    pub fn get_recursive_memory_layout(&self, position: FilePosition) -> Cancellable<Option<RecursiveMemoryLayout>> {
+        self.with_db(|db| view_memory_layout(db, position))
+    }
+
     /// Performs an operation on the database that may be canceled.
     ///
     /// rust-analyzer needs to be able to answer semantic questions about the
diff --git a/crates/ide/src/view_memory_layout.rs b/crates/ide/src/view_memory_layout.rs
new file mode 100644
index 00000000000..3b1b4968e77
--- /dev/null
+++ b/crates/ide/src/view_memory_layout.rs
@@ -0,0 +1,170 @@
+use hir::{Field, HirDisplay, Layout, Semantics, Type};
+use ide_db::{
+    defs::{Definition, IdentClass},
+    helpers::pick_best_token,
+    RootDatabase,
+};
+use syntax::{AstNode, SyntaxKind, SyntaxToken};
+
+use crate::FilePosition;
+
+pub struct MemoryLayoutNode {
+    pub item_name: String,
+    pub typename: String,
+    pub size: u64,
+    pub alignment: u64,
+    pub offset: u64,
+    pub parent_idx: i64,
+    pub children_start: i64,
+    pub children_len: u64,
+}
+
+pub struct RecursiveMemoryLayout {
+    pub nodes: Vec<MemoryLayoutNode>,
+}
+
+fn get_definition(sema: &Semantics<'_, RootDatabase>, token: SyntaxToken) -> Option<Definition> {
+    for token in sema.descend_into_macros(token) {
+        let def = IdentClass::classify_token(sema, &token).map(IdentClass::definitions_no_ops);
+        if let Some(&[x]) = def.as_deref() {
+            return Some(x);
+        }
+    }
+    None
+}
+
+pub(crate) fn view_memory_layout(
+    db: &RootDatabase,
+    position: FilePosition,
+) -> Option<RecursiveMemoryLayout> {
+    let sema = Semantics::new(db);
+    let file = sema.parse(position.file_id);
+    let token =
+        pick_best_token(file.syntax().token_at_offset(position.offset), |kind| match kind {
+            SyntaxKind::IDENT => 3,
+            _ => 0,
+        })?;
+
+    let def = get_definition(&sema, token)?;
+
+    let ty = match def {
+        Definition::Adt(it) => it.ty(db),
+        Definition::TypeAlias(it) => it.ty(db),
+        Definition::BuiltinType(it) => it.ty(db),
+        Definition::SelfType(it) => it.self_ty(db),
+        Definition::Local(it) => it.ty(db),
+        _ => return None,
+    };
+
+    enum FieldOrTupleIdx {
+        Field(Field),
+        TupleIdx(usize),
+    }
+
+    impl FieldOrTupleIdx {
+        fn name(&self, db: &RootDatabase) -> String {
+            match *self {
+                FieldOrTupleIdx::Field(f) => f
+                    .name(db)
+                    .as_str()
+                    .map(|s| s.to_owned())
+                    .unwrap_or_else(|| format!("{:#?}", f.name(db).as_tuple_index().unwrap())),
+                FieldOrTupleIdx::TupleIdx(i) => format!(".{i}").to_owned(),
+            }
+        }
+
+        fn index(&self) -> usize {
+            match *self {
+                FieldOrTupleIdx::Field(f) => f.index(),
+                FieldOrTupleIdx::TupleIdx(i) => i,
+            }
+        }
+    }
+
+    fn read_layout(
+        nodes: &mut Vec<MemoryLayoutNode>,
+        db: &RootDatabase,
+        ty: &Type,
+        layout: &Layout,
+        parent_idx: usize,
+    ) {
+        let mut fields = ty
+            .fields(db)
+            .into_iter()
+            .map(|(f, ty)| (FieldOrTupleIdx::Field(f), ty))
+            .chain(
+                ty.tuple_fields(db)
+                    .into_iter()
+                    .enumerate()
+                    .map(|(i, ty)| (FieldOrTupleIdx::TupleIdx(i), ty)),
+            )
+            .collect::<Vec<_>>();
+
+        fields.sort_by_key(|(f, _)| layout.field_offset(f.index()).unwrap_or(u64::MAX));
+
+        if fields.len() == 0 {
+            return;
+        }
+
+        let children_start = nodes.len();
+        nodes[parent_idx].children_start = children_start as i64;
+        nodes[parent_idx].children_len = fields.len() as u64;
+
+        for (field, child_ty) in fields.iter() {
+            if let Ok(child_layout) = child_ty.layout(db) {
+                nodes.push(MemoryLayoutNode {
+                    item_name: field.name(db),
+                    typename: child_ty.display(db).to_string(),
+                    size: child_layout.size(),
+                    alignment: child_layout.align(),
+                    offset: layout.field_offset(field.index()).unwrap_or(0),
+                    parent_idx: parent_idx as i64,
+                    children_start: -1,
+                    children_len: 0,
+                });
+            } else {
+                nodes.push(MemoryLayoutNode {
+                    item_name: field.name(db)
+                        + format!("(no layout data: {:?})", child_ty.layout(db).unwrap_err())
+                            .as_ref(),
+                    typename: child_ty.display(db).to_string(),
+                    size: 0,
+                    offset: 0,
+                    alignment: 0,
+                    parent_idx: parent_idx as i64,
+                    children_start: -1,
+                    children_len: 0,
+                });
+            }
+        }
+
+        for (i, (_, child_ty)) in fields.iter().enumerate() {
+            if let Ok(child_layout) = child_ty.layout(db) {
+                read_layout(nodes, db, &child_ty, &child_layout, children_start + i);
+            }
+        }
+    }
+
+    ty.layout(db).map(|layout| {
+        let item_name = match def {
+            Definition::Local(l) => l.name(db).as_str().unwrap().to_owned(),
+            _ => "[ROOT]".to_owned(),
+        };
+
+        let typename = ty.display(db).to_string();
+
+        let mut nodes = vec![MemoryLayoutNode {
+            item_name,
+            typename: typename.clone(),
+            size: layout.size(),
+            offset: 0,
+            alignment: layout.align(),
+            parent_idx: -1,
+            children_start: -1,
+            children_len: 0,
+        }];
+        read_layout(&mut nodes, db, &ty, &layout, 0);
+
+        RecursiveMemoryLayout { nodes }
+    })
+}
diff --git a/crates/rust-analyzer/src/handlers/request.rs b/crates/rust-analyzer/src/handlers/request.rs
index bb0c7ffa728..2b901a60191 100644
--- a/crates/rust-analyzer/src/handlers/request.rs
+++ b/crates/rust-analyzer/src/handlers/request.rs
@@ -1689,6 +1689,34 @@ pub(crate) fn handle_move_item(
     }
 }
 
+pub(crate) fn handle_view_recursive_memory_layout(
+    snap: GlobalStateSnapshot,
+    params: lsp_ext::ViewRecursiveMemoryLayoutParams,
+) -> Result<Option<lsp_ext::RecursiveMemoryLayout>> {
+    let _p = profile::span("view_recursive_memory_layout");
+    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
+    let line_index = snap.file_line_index(file_id)?;
+    let offset = from_proto::offset(&line_index, params.position)?;
+
+    let res = snap.analysis.get_recursive_memory_layout(FilePosition { file_id, offset })?;
+    Ok(res.map(|it| lsp_ext::RecursiveMemoryLayout {
+        nodes: it
+            .nodes
+            .iter()
+            .map(|n| lsp_ext::MemoryLayoutNode {
+                item_name: n.item_name.clone(),
+                typename: n.typename.clone(),
+                size: n.size,
+                offset: n.offset,
+                alignment: n.alignment,
+                parent_idx: n.parent_idx,
+                children_start: n.children_start,
+                children_len: n.children_len,
+            })
+            .collect(),
+    }))
+}
+
 fn to_command_link(command: lsp_types::Command, tooltip: String) -> lsp_ext::CommandLink {
     lsp_ext::CommandLink { tooltip: Some(tooltip), command }
 }
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 4d67c8b305f..39b8e840288 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -182,6 +182,40 @@ pub struct ExpandedMacro {
     pub expansion: String,
 }
 
+pub enum ViewRecursiveMemoryLayout {}
+
+impl Request for ViewRecursiveMemoryLayout {
+    type Params = ViewRecursiveMemoryLayoutParams;
+    type Result = Option<RecursiveMemoryLayout>;
+    const METHOD: &'static str = "rust-analyzer/viewRecursiveMemoryLayout";
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ViewRecursiveMemoryLayoutParams {
+    pub text_document: TextDocumentIdentifier,
+    pub position: Position,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RecursiveMemoryLayout {
+    pub nodes: Vec<MemoryLayoutNode>,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MemoryLayoutNode {
+    pub item_name: String,
+    pub typename: String,
+    pub size: u64,
+    pub offset: u64,
+    pub alignment: u64,
+    pub parent_idx: i64,
+    pub children_start: i64,
+    pub children_len: u64,
+}
+
 pub enum CancelFlycheck {}
 
 impl Notification for CancelFlycheck {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 9eecf4957af..74036710fa3 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -753,6 +753,7 @@ impl GlobalState {
             )
             .on::<lsp_types::request::WillRenameFiles>(handlers::handle_will_rename_files)
             .on::<lsp_ext::Ssr>(handlers::handle_ssr)
+            .on::<lsp_ext::ViewRecursiveMemoryLayout>(handlers::handle_view_recursive_memory_layout)
             .finish();
     }
 
diff --git a/editors/code/package.json b/editors/code/package.json
index 1a1d76c6991..cd8b40e3557 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -284,6 +284,11 @@
                 "command": "rust-analyzer.revealDependency",
                 "title": "Reveal File",
                 "category": "rust-analyzer"
+            },
+            {
+                "command": "rust-analyzer.viewMemoryLayout",
+                "title": "View Memory Layout",
+                "category": "rust-analyzer"
             }
         ],
         "keybindings": [
@@ -2067,6 +2072,10 @@
                 {
                     "command": "rust-analyzer.openCargoToml",
                     "when": "inRustProject"
+                },
+                {
+                    "command": "rust-analyzer.viewMemoryLayout",
+                    "when": "inRustProject"
                 }
             ],
             "editor/context": [
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 3c6105e89fe..c0d68881c23 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -1129,3 +1129,286 @@ export function linkToCommand(_: Ctx): Cmd {
         }
     };
 }
+
+export function viewMemoryLayout(ctx: CtxInit): Cmd {
+    return async () => {
+
+        const editor = vscode.window.activeTextEditor;
+        if (!editor) return "";
+        const client = ctx.client;
+
+        const position = editor.selection.active;
+        const expanded = await client.sendRequest(ra.viewRecursiveMemoryLayout, {
+            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
+                editor.document
+            ),
+            position,
+        });
+
+        // if (expanded == null) return "Not available";
+
+
+        const document = vscode.window.createWebviewPanel(
+            "memory_layout",
+            "[Memory Layout]",
+            vscode.ViewColumn.Two,
+            { enableScripts: true, });
+
+        document.webview.html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+    <style>   
+        * {
+            box-sizing: border-box;
+        }
+
+        body {
+            margin: 0;
+            overflow: hidden;
+            min-height: 100%;
+            height: 100vh;
+            padding: 32px;
+            position: relative;
+            display: block;
+
+            background-color: var(--vscode-editor-background);
+            font-family: var(--vscode-editor-font-family);
+            font-size: var(--vscode-editor-font-size);
+            color: var(--vscode-editor-foreground);
+        }
+
+        .container {
+            position: relative;
+        }
+
+        .trans {
+            transition: all 0.2s ease-in-out;
+        }
+
+        .grid {
+            height: 100%;
+            position: relative;
+            color: var(--vscode-commandCenter-activeBorder);
+            pointer-events: none;
+        }
+
+        .grid-line {
+            position: absolute;
+            width: 100%;
+            height: 1px;
+            background-color: var(--vscode-commandCenter-activeBorder);
+        }
+
+        #tooltip {
+            position: fixed;
+            display: none;
+            z-index: 1;
+            pointer-events: none;
+            padding: 4px 8px;
+            z-index: 2;
+
+            color: var(--vscode-editorHoverWidget-foreground);
+            background-color: var(--vscode-editorHoverWidget-background);
+            border: 1px solid var(--vscode-editorHoverWidget-border);
+        }
+
+        #tooltip b {
+            color: var(--vscode-editorInlayHint-typeForeground);
+        }
+
+        #tooltip ul {
+            margin-left: 0;
+            padding-left: 20px;
+        }
+
+        table {
+            position: absolute;
+            transform: rotateZ(90deg) rotateX(180deg);
+            transform-origin: top left;
+            border-collapse: collapse;
+            table-layout: fixed;
+            left: 48px;
+            top: 0;
+            max-height: calc(100vw - 64px - 48px);
+            z-index: 1;
+        }
+
+        td {
+            border: 1px solid var(--vscode-focusBorder);
+            writing-mode: vertical-rl;
+            text-orientation: sideways-right;
+
+            height: 80px;
+        }
+
+        td p {
+            height: calc(100% - 16px);
+            width: calc(100% - 8px);
+            margin: 8px 4px;
+            display: inline-block;
+            transform: rotateY(180deg);
+            pointer-events: none;
+            overflow: hidden;
+        }
+
+        td p * {
+            overflow: hidden;
+            white-space: nowrap;
+            text-overflow: ellipsis;
+            display: inline-block;
+            height: 100%;
+        }
+
+        td p b {
+            color: var(--vscode-editorInlayHint-typeForeground);
+        }
+
+        td:hover {
+            background-color: var(--vscode-editor-hoverHighlightBackground);
+        }
+
+        td:empty {
+            visibility: hidden;
+            border: 0;
+        }
+    </style>
+</head>
+<body>
+    <div id="tooltip"></div>
+</body>
+<script>(function() {
+
+const data = ${JSON.stringify(expanded)}
+
+if (!(data && data.nodes.length)) {
+    document.body.innerText = "Not Available"
+    return
+}
+
+data.nodes.map(n => {
+    n.typename = n.typename.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', ' & quot; ').replaceAll("'", '&#039;')
+    return n
+})
+
+let height = window.innerHeight - 64
+
+addEventListener("resize", e => {
+    const new_height = window.innerHeight - 64
+    height = new_height
+    container.classList.remove("trans")
+    table.classList.remove("trans")
+    locate()
+    setTimeout(() => { // give delay to redraw, annoying but needed
+        container.classList.add("trans")
+        table.classList.add("trans")
+    }, 0)
+})
+
+const container = document.createElement("div")
+container.classList.add("container")
+container.classList.add("trans")
+document.body.appendChild(container)
+
+const tooltip = document.getElementById("tooltip")
+
+let y = 0
+let zoom = 1.0
+
+const table = document.createElement("table")
+table.classList.add("trans")
+container.appendChild(table)
+const rows = []
+
+function node_t(idx, depth, offset) {
+    if (!rows[depth]) {
+        rows[depth] = { el: document.createElement("tr"), offset: 0 }
+    }
+
+    if (rows[depth].offset < offset) {
+        const pad = document.createElement("td")
+        pad.colSpan = offset - rows[depth].offset
+        rows[depth].el.appendChild(pad)
+        rows[depth].offset += offset - rows[depth].offset
+    }
+
+    const td = document.createElement("td")
+    td.innerHTML = '<p><span>' + data.nodes[idx].itemName + ':</span> <b>' + data.nodes[idx].typename + '</b></p>'
+
+    td.colSpan = data.nodes[idx].size
+
+    td.addEventListener("mouseover", e => {
+        const node = data.nodes[idx]
+        tooltip.innerHTML = node.itemName + ": <b>" + node.typename + "</b><br/>"
+            + "<ul>"
+            + "<li>size = " + node.size + "</li>"
+            + "<li>align = " + node.alignment + "</li>"
+            + "<li>field offset = " + node.offset + "</li>"
+            + "</ul>"
+            + "<i>double click to focus</i>"
+
+        tooltip.style.display = "block"
+    })
+    td.addEventListener("mouseleave", _ => tooltip.style.display = "none")
+    const total_offset = rows[depth].offset
+    td.addEventListener("dblclick", e => {
+        const node = data.nodes[idx]
+        zoom = data.nodes[0].size / node.size
+        y = -(total_offset) / data.nodes[0].size * zoom
+        x = 0
+        locate()
+    })
+
+    rows[depth].el.appendChild(td)
+    rows[depth].offset += data.nodes[idx].size
+
+
+    if (data.nodes[idx].childrenStart != -1) {
+        for (let i = 0; i < data.nodes[idx].childrenLen; i++) {
+            if (data.nodes[data.nodes[idx].childrenStart + i].size) {
+                node_t(data.nodes[idx].childrenStart + i, depth + 1, offset + data.nodes[data.nodes[idx].childrenStart + i].offset)
+            }
+        }
+    }
+}
+
+node_t(0, 0, 0)
+
+for (const row of rows) table.appendChild(row.el)
+
+const grid = document.createElement("div")
+grid.classList.add("grid")
+container.appendChild(grid)
+
+for (let i = 0; i < data.nodes[0].size / 8 + 1; i++) {
+    const el = document.createElement("div")
+    el.classList.add("grid-line")
+    el.style.top = (i / (data.nodes[0].size / 8) * 100) + "%"
+    el.innerText = i * 8
+    grid.appendChild(el)
+}
+
+addEventListener("mousemove", e => {
+    tooltip.style.top = e.clientY + 10 + "px"
+    tooltip.style.left = e.clientX + 10 + "px"
+})
+
+function locate() {
+    container.style.top = height * y + "px"
+    container.style.height = (height * zoom) + "px"
+
+    table.style.width = container.style.height
+}
+
+locate()
+
+})()
+</script>
+</html>`
+
+        ctx.pushExtCleanup(document);
+    };
+}
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index b72804e510c..4244098ae1d 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -70,7 +70,7 @@ export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>
 
 export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };
 
-export interface FetchDependencyListParams {}
+export interface FetchDependencyListParams { }
 
 export interface FetchDependencyListResult {
     crates: {
@@ -86,7 +86,7 @@ export const fetchDependencyList = new lc.RequestType<
     void
 >("rust-analyzer/fetchDependencyList");
 
-export interface FetchDependencyGraphParams {}
+export interface FetchDependencyGraphParams { }
 
 export interface FetchDependencyGraphResult {
     crates: {
@@ -150,6 +150,9 @@ export const serverStatus = new lc.NotificationType<ServerStatusParams>(
     "experimental/serverStatus"
 );
 export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>("experimental/ssr");
+export const viewRecursiveMemoryLayout = new lc.RequestType<ViewRecursiveMemoryLayoutParams, RecursiveMemoryLayout | null, void>(
+    "rust-analyzer/viewRecursiveMemoryLayout"
+);
 
 export type JoinLinesParams = {
     textDocument: lc.TextDocumentIdentifier;
@@ -197,3 +200,23 @@ export type SsrParams = {
     position: lc.Position;
     selections: readonly lc.Range[];
 };
+
+export type ViewRecursiveMemoryLayoutParams = {
+    textDocument: lc.TextDocumentIdentifier;
+    position: lc.Position;
+};
+export type RecursiveMemoryLayoutNode = {
+    item_name: string;
+    typename: string;
+    size: number;
+    alignment: number;
+    offset: number;
+    parent_idx: number;
+    children_start: number;
+    children_len: number;
+};
+export type RecursiveMemoryLayout = {
+    name: string;
+    expansion: string;
+    nodes: RecursiveMemoryLayoutNode[];
+};
\ No newline at end of file
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index be9bc9d363c..492275968f3 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -24,11 +24,11 @@ export async function activate(
         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);
     }
 
     const ctx = new Ctx(context, createCommands(), fetchWorkspace());
@@ -144,7 +144,7 @@ function createCommands(): Record<string, CommandFactory> {
                     health: "stopped",
                 });
             },
-            disabled: (_) => async () => {},
+            disabled: (_) => async () => { },
         },
 
         analyzerStatus: { enabled: commands.analyzerStatus },
@@ -179,6 +179,7 @@ function createCommands(): Record<string, CommandFactory> {
         runFlycheck: { enabled: commands.runFlycheck },
         ssr: { enabled: commands.ssr },
         serverVersion: { enabled: commands.serverVersion },
+        viewMemoryLayout: { enabled: commands.viewMemoryLayout },
         // Internal commands which are invoked by the server.
         applyActionGroup: { enabled: commands.applyActionGroup },
         applySnippetWorkspaceEdit: { enabled: commands.applySnippetWorkspaceEditCommand },
-- 
cgit 1.4.1-3-g733a5


From de5e3cf7459b955aa729bcbc6150655edf23e790 Mon Sep 17 00:00:00 2001
From: Adenine <adenine.dev@gmail.com>
Date: Mon, 19 Jun 2023 00:24:42 -0400
Subject: fix incorrect committed rust and run prettier

---
 crates/ide/src/view_memory_layout.rs | 46 +++++++++++++++++++-----------------
 editors/code/src/commands.ts         | 11 ++++-----
 editors/code/src/lsp_ext.ts          | 14 ++++++-----
 editors/code/src/main.ts             |  8 +++----
 4 files changed, 40 insertions(+), 39 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/ide/src/view_memory_layout.rs b/crates/ide/src/view_memory_layout.rs
index 3b1b4968e77..9ed0d3f224c 100644
--- a/crates/ide/src/view_memory_layout.rs
+++ b/crates/ide/src/view_memory_layout.rs
@@ -145,26 +145,28 @@ pub(crate) fn view_memory_layout(
         }
     }
 
-    ty.layout(db).map(|layout| {
-        let item_name = match def {
-            Definition::Local(l) => l.name(db).as_str().unwrap().to_owned(),
-            _ => "[ROOT]".to_owned(),
-        };
-
-        let typename = ty.display(db).to_string();
-
-        let mut nodes = vec![MemoryLayoutNode {
-            item_name,
-            typename: typename.clone(),
-            size: layout.size(),
-            offset: 0,
-            alignment: layout.align(),
-            parent_idx: -1,
-            children_start: -1,
-            children_len: 0,
-        }];
-        read_layout(&mut nodes, db, &ty, &layout, 0);
-
-        RecursiveMemoryLayout { nodes }
-    })
+    ty.layout(db)
+        .map(|layout| {
+            let item_name = match def {
+                Definition::Local(l) => l.name(db).as_str().unwrap().to_owned(),
+                _ => "[ROOT]".to_owned(),
+            };
+
+            let typename = ty.display(db).to_string();
+
+            let mut nodes = vec![MemoryLayoutNode {
+                item_name,
+                typename: typename.clone(),
+                size: layout.size(),
+                offset: 0,
+                alignment: layout.align(),
+                parent_idx: -1,
+                children_start: -1,
+                children_len: 0,
+            }];
+            read_layout(&mut nodes, db, &ty, &layout, 0);
+
+            RecursiveMemoryLayout { nodes }
+        })
+        .ok()
 }
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index c0d68881c23..1e74158b821 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -1132,27 +1132,24 @@ export function linkToCommand(_: Ctx): Cmd {
 
 export function viewMemoryLayout(ctx: CtxInit): Cmd {
     return async () => {
-
         const editor = vscode.window.activeTextEditor;
         if (!editor) return "";
         const client = ctx.client;
 
         const position = editor.selection.active;
         const expanded = await client.sendRequest(ra.viewRecursiveMemoryLayout, {
-            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
-                editor.document
-            ),
+            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
             position,
         });
 
         // if (expanded == null) return "Not available";
 
-
         const document = vscode.window.createWebviewPanel(
             "memory_layout",
             "[Memory Layout]",
             vscode.ViewColumn.Two,
-            { enableScripts: true, });
+            { enableScripts: true }
+        );
 
         document.webview.html = `<!DOCTYPE html>
 <html lang="en">
@@ -1407,7 +1404,7 @@ locate()
 
 })()
 </script>
-</html>`
+</html>`;
 
         ctx.pushExtCleanup(document);
     };
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 4244098ae1d..8a0c55a942f 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -70,7 +70,7 @@ export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>
 
 export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };
 
-export interface FetchDependencyListParams { }
+export interface FetchDependencyListParams {}
 
 export interface FetchDependencyListResult {
     crates: {
@@ -86,7 +86,7 @@ export const fetchDependencyList = new lc.RequestType<
     void
 >("rust-analyzer/fetchDependencyList");
 
-export interface FetchDependencyGraphParams { }
+export interface FetchDependencyGraphParams {}
 
 export interface FetchDependencyGraphResult {
     crates: {
@@ -150,9 +150,11 @@ export const serverStatus = new lc.NotificationType<ServerStatusParams>(
     "experimental/serverStatus"
 );
 export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>("experimental/ssr");
-export const viewRecursiveMemoryLayout = new lc.RequestType<ViewRecursiveMemoryLayoutParams, RecursiveMemoryLayout | null, void>(
-    "rust-analyzer/viewRecursiveMemoryLayout"
-);
+export const viewRecursiveMemoryLayout = new lc.RequestType<
+    ViewRecursiveMemoryLayoutParams,
+    RecursiveMemoryLayout | null,
+    void
+>("rust-analyzer/viewRecursiveMemoryLayout");
 
 export type JoinLinesParams = {
     textDocument: lc.TextDocumentIdentifier;
@@ -219,4 +221,4 @@ export type RecursiveMemoryLayout = {
     name: string;
     expansion: string;
     nodes: RecursiveMemoryLayoutNode[];
-};
\ No newline at end of file
+};
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 492275968f3..64aea03394a 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -24,11 +24,11 @@ export async function activate(
         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);
     }
 
     const ctx = new Ctx(context, createCommands(), fetchWorkspace());
@@ -144,7 +144,7 @@ function createCommands(): Record<string, CommandFactory> {
                     health: "stopped",
                 });
             },
-            disabled: (_) => async () => { },
+            disabled: (_) => async () => {},
         },
 
         analyzerStatus: { enabled: commands.analyzerStatus },
-- 
cgit 1.4.1-3-g733a5


From c43cfefdd868c92f60d936e8958c0980428a0679 Mon Sep 17 00:00:00 2001
From: Adenine <adenine.dev@gmail.com>
Date: Mon, 19 Jun 2023 00:27:53 -0400
Subject: fix typescript return path warning

---
 editors/code/src/commands.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 1e74158b821..052e3918241 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -1133,7 +1133,7 @@ export function linkToCommand(_: Ctx): Cmd {
 export function viewMemoryLayout(ctx: CtxInit): Cmd {
     return async () => {
         const editor = vscode.window.activeTextEditor;
-        if (!editor) return "";
+        if (!editor) return;
         const client = ctx.client;
 
         const position = editor.selection.active;
-- 
cgit 1.4.1-3-g733a5


From 4d5c66986ece98fb0015cbca5ee0de1f9870c800 Mon Sep 17 00:00:00 2001
From: Adenine <adenine.dev@gmail.com>
Date: Fri, 7 Jul 2023 23:03:55 -0400
Subject: cleanup + docs + tests

---
 crates/ide-db/src/helpers.rs         |  18 ++-
 crates/ide/src/lib.rs                |   5 +-
 crates/ide/src/static_index.rs       |  17 +--
 crates/ide/src/view_memory_layout.rs | 277 ++++++++++++++++++++++++++++++-----
 docs/dev/lsp-extensions.md           |  55 ++++++-
 editors/code/src/commands.ts         |   2 -
 editors/code/src/lsp_ext.ts          |   2 -
 7 files changed, 318 insertions(+), 58 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/ide-db/src/helpers.rs b/crates/ide-db/src/helpers.rs
index eba9d8afc40..1eb8f00020b 100644
--- a/crates/ide-db/src/helpers.rs
+++ b/crates/ide-db/src/helpers.rs
@@ -9,7 +9,10 @@ use syntax::{
     AstToken, SyntaxKind, SyntaxToken, TokenAtOffset,
 };
 
-use crate::{defs::Definition, generated, RootDatabase};
+use crate::{
+    defs::{Definition, IdentClass},
+    generated, RootDatabase,
+};
 
 pub fn item_name(db: &RootDatabase, item: ItemInNs) -> Option<Name> {
     match item {
@@ -109,3 +112,16 @@ pub fn is_editable_crate(krate: Crate, db: &RootDatabase) -> bool {
     let source_root_id = db.file_source_root(root_file);
     !db.source_root(source_root_id).is_library
 }
+
+pub fn get_definition(
+    sema: &Semantics<'_, RootDatabase>,
+    token: SyntaxToken,
+) -> Option<Definition> {
+    for token in sema.descend_into_macros(token) {
+        let def = IdentClass::classify_token(sema, &token).map(IdentClass::definitions_no_ops);
+        if let Some(&[x]) = def.as_deref() {
+            return Some(x);
+        }
+    }
+    None
+}
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index a9a8f6903b2..0ad4c6c47e6 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -726,7 +726,10 @@ impl Analysis {
         self.with_db(|db| move_item::move_item(db, range, direction))
     }
 
-    pub fn get_recursive_memory_layout(&self, position: FilePosition) -> Cancellable<Option<RecursiveMemoryLayout>> {
+    pub fn get_recursive_memory_layout(
+        &self,
+        position: FilePosition,
+    ) -> Cancellable<Option<RecursiveMemoryLayout>> {
         self.with_db(|db| view_memory_layout(db, position))
     }
 
diff --git a/crates/ide/src/static_index.rs b/crates/ide/src/static_index.rs
index 7101e8ed203..59e8300dcdb 100644
--- a/crates/ide/src/static_index.rs
+++ b/crates/ide/src/static_index.rs
@@ -3,13 +3,14 @@
 
 use std::collections::HashMap;
 
-use hir::{db::HirDatabase, Crate, Module, Semantics};
+use hir::{db::HirDatabase, Crate, Module};
+use ide_db::helpers::get_definition;
 use ide_db::{
     base_db::{FileId, FileRange, SourceDatabaseExt},
-    defs::{Definition, IdentClass},
+    defs::Definition,
     FxHashSet, RootDatabase,
 };
-use syntax::{AstNode, SyntaxKind::*, SyntaxToken, TextRange, T};
+use syntax::{AstNode, SyntaxKind::*, TextRange, T};
 
 use crate::{
     hover::hover_for_definition,
@@ -214,16 +215,6 @@ impl StaticIndex<'_> {
     }
 }
 
-fn get_definition(sema: &Semantics<'_, RootDatabase>, token: SyntaxToken) -> Option<Definition> {
-    for token in sema.descend_into_macros(token) {
-        let def = IdentClass::classify_token(sema, &token).map(IdentClass::definitions_no_ops);
-        if let Some(&[it]) = def.as_deref() {
-            return Some(it);
-        }
-    }
-    None
-}
-
 #[cfg(test)]
 mod tests {
     use crate::{fixture, StaticIndex};
diff --git a/crates/ide/src/view_memory_layout.rs b/crates/ide/src/view_memory_layout.rs
index 9ed0d3f224c..ae8dd504e3e 100644
--- a/crates/ide/src/view_memory_layout.rs
+++ b/crates/ide/src/view_memory_layout.rs
@@ -1,10 +1,10 @@
 use hir::{Field, HirDisplay, Layout, Semantics, Type};
 use ide_db::{
-    defs::{Definition, IdentClass},
-    helpers::pick_best_token,
+    defs::Definition,
+    helpers::{get_definition, pick_best_token},
     RootDatabase,
 };
-use syntax::{AstNode, SyntaxKind, SyntaxToken};
+use syntax::{AstNode, SyntaxKind};
 
 use crate::FilePosition;
 
@@ -23,16 +23,40 @@ pub struct RecursiveMemoryLayout {
     pub nodes: Vec<MemoryLayoutNode>,
 }
 
-fn get_definition(sema: &Semantics<'_, RootDatabase>, token: SyntaxToken) -> Option<Definition> {
-    for token in sema.descend_into_macros(token) {
-        let def = IdentClass::classify_token(sema, &token).map(IdentClass::definitions_no_ops);
-        if let Some(&[x]) = def.as_deref() {
-            return Some(x);
+enum FieldOrTupleIdx {
+    Field(Field),
+    TupleIdx(usize),
+}
+
+impl FieldOrTupleIdx {
+    fn name(&self, db: &RootDatabase) -> String {
+        match *self {
+            FieldOrTupleIdx::Field(f) => f
+                .name(db)
+                .as_str()
+                .map(|s| s.to_owned())
+                .unwrap_or_else(|| format!(".{}", f.name(db).as_tuple_index().unwrap())),
+            FieldOrTupleIdx::TupleIdx(i) => format!(".{i}").to_owned(),
+        }
+    }
+
+    fn index(&self) -> usize {
+        match *self {
+            FieldOrTupleIdx::Field(f) => f.index(),
+            FieldOrTupleIdx::TupleIdx(i) => i,
         }
     }
-    None
 }
 
+// Feature: View Memory Layout
+//
+// Displays the recursive memory layout of a datatype.
+//
+// |===
+// | Editor  | Action Name
+//
+// | VS Code | **rust-analyzer: View Memory Layout**
+// |===
 pub(crate) fn view_memory_layout(
     db: &RootDatabase,
     position: FilePosition,
@@ -53,34 +77,12 @@ pub(crate) fn view_memory_layout(
         Definition::BuiltinType(it) => it.ty(db),
         Definition::SelfType(it) => it.self_ty(db),
         Definition::Local(it) => it.ty(db),
+        Definition::Field(it) => it.ty(db),
+        Definition::Const(it) => it.ty(db),
+        Definition::Static(it) => it.ty(db),
         _ => return None,
     };
 
-    enum FieldOrTupleIdx {
-        Field(Field),
-        TupleIdx(usize),
-    }
-
-    impl FieldOrTupleIdx {
-        fn name(&self, db: &RootDatabase) -> String {
-            match *self {
-                FieldOrTupleIdx::Field(f) => f
-                    .name(db)
-                    .as_str()
-                    .map(|s| s.to_owned())
-                    .unwrap_or_else(|| format!("{:#?}", f.name(db).as_tuple_index().unwrap())),
-                FieldOrTupleIdx::TupleIdx(i) => format!(".{i}").to_owned(),
-            }
-        }
-
-        fn index(&self) -> usize {
-            match *self {
-                FieldOrTupleIdx::Field(f) => f.index(),
-                FieldOrTupleIdx::TupleIdx(i) => i,
-            }
-        }
-    }
-
     fn read_layout(
         nodes: &mut Vec<MemoryLayoutNode>,
         db: &RootDatabase,
@@ -100,12 +102,12 @@ pub(crate) fn view_memory_layout(
             )
             .collect::<Vec<_>>();
 
-        fields.sort_by_key(|(f, _)| layout.field_offset(f.index()).unwrap_or(u64::MAX));
-
         if fields.len() == 0 {
             return;
         }
 
+        fields.sort_by_key(|(f, _)| layout.field_offset(f.index()).unwrap());
+
         let children_start = nodes.len();
         nodes[parent_idx].children_start = children_start as i64;
         nodes[parent_idx].children_len = fields.len() as u64;
@@ -148,8 +150,21 @@ pub(crate) fn view_memory_layout(
     ty.layout(db)
         .map(|layout| {
             let item_name = match def {
-                Definition::Local(l) => l.name(db).as_str().unwrap().to_owned(),
-                _ => "[ROOT]".to_owned(),
+                // def is a datatype
+                Definition::Adt(_)
+                | Definition::TypeAlias(_)
+                | Definition::BuiltinType(_)
+                | Definition::SelfType(_) => "[ROOT]".to_owned(),
+
+                // def is an item
+                def => def
+                    .name(db)
+                    .map(|n| {
+                        n.as_str()
+                            .map(|s| s.to_owned())
+                            .unwrap_or_else(|| format!(".{}", n.as_tuple_index().unwrap()))
+                    })
+                    .unwrap_or("[ROOT]".to_owned()),
             };
 
             let typename = ty.display(db).to_string();
@@ -170,3 +185,189 @@ pub(crate) fn view_memory_layout(
         })
         .ok()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::fixture;
+
+    fn make_memory_layout(ra_fixture: &str) -> Option<RecursiveMemoryLayout> {
+        let (analysis, position, _) = fixture::annotations(ra_fixture);
+
+        view_memory_layout(&analysis.db, position)
+    }
+
+    fn check_item_info<T>(node: &MemoryLayoutNode, item_name: &str, check_typename: bool) {
+        assert_eq!(node.item_name, item_name);
+        assert_eq!(node.size, core::mem::size_of::<T>() as u64);
+        assert_eq!(node.alignment, core::mem::align_of::<T>() as u64);
+        if check_typename {
+            assert_eq!(node.typename, std::any::type_name::<T>());
+        }
+    }
+
+    #[test]
+    fn view_memory_layout_none() {
+        assert!(make_memory_layout(r#"$0"#).is_none());
+        assert!(make_memory_layout(r#"stru$0ct Blah {}"#).is_none());
+    }
+
+    #[test]
+    fn view_memory_layout_primitive() {
+        let ml = make_memory_layout(
+            r#"
+fn main() {
+    let foo$0 = 109; // default i32
+}
+"#,
+        )
+        .unwrap();
+
+        assert_eq!(ml.nodes.len(), 1);
+        assert_eq!(ml.nodes[0].parent_idx, -1);
+        assert_eq!(ml.nodes[0].children_start, -1);
+        check_item_info::<i32>(&ml.nodes[0], "foo", true);
+        assert_eq!(ml.nodes[0].offset, 0);
+    }
+
+    #[test]
+    fn view_memory_layout_constant() {
+        let ml = make_memory_layout(
+            r#"
+const BLAH$0: bool = 0;
+"#,
+        )
+        .unwrap();
+
+        assert_eq!(ml.nodes.len(), 1);
+        assert_eq!(ml.nodes[0].parent_idx, -1);
+        assert_eq!(ml.nodes[0].children_start, -1);
+        check_item_info::<bool>(&ml.nodes[0], "BLAH", true);
+        assert_eq!(ml.nodes[0].offset, 0);
+    }
+
+    #[test]
+    fn view_memory_layout_static() {
+        let ml = make_memory_layout(
+            r#"
+static BLAH$0: bool = 0;
+"#,
+        )
+        .unwrap();
+
+        assert_eq!(ml.nodes.len(), 1);
+        assert_eq!(ml.nodes[0].parent_idx, -1);
+        assert_eq!(ml.nodes[0].children_start, -1);
+        check_item_info::<bool>(&ml.nodes[0], "BLAH", true);
+        assert_eq!(ml.nodes[0].offset, 0);
+    }
+
+    #[test]
+    fn view_memory_layout_tuple() {
+        let ml = make_memory_layout(
+            r#"
+fn main() {
+    let x$0 = (101.0, 111u8, 119i64);
+}
+        "#,
+        )
+        .unwrap();
+
+        assert_eq!(ml.nodes.len(), 4);
+        assert_eq!(ml.nodes[0].children_start, 1);
+        assert_eq!(ml.nodes[0].children_len, 3);
+        check_item_info::<(f64, u8, i64)>(&ml.nodes[0], "x", true);
+    }
+
+    #[test]
+    fn view_memory_layout_struct() {
+        let ml = make_memory_layout(
+            r#"
+#[repr(C)]
+struct Blah$0 {
+    a: u32,
+    b: (i32, u8),
+    c: i8,
+}
+"#,
+        )
+        .unwrap();
+
+        #[repr(C)] // repr C makes this testable, rustc doesn't enforce a layout otherwise ;-;
+        struct Blah {
+            a: u32,
+            b: (i32, u8),
+            c: i8,
+        }
+
+        assert_eq!(ml.nodes.len(), 6);
+        check_item_info::<Blah>(&ml.nodes[0], "[ROOT]", false);
+        assert_eq!(ml.nodes[0].offset, 0);
+
+        check_item_info::<u32>(&ml.nodes[1], "a", true);
+        assert_eq!(ml.nodes[1].offset, 0);
+
+        check_item_info::<(i32, u8)>(&ml.nodes[2], "b", true);
+        assert_eq!(ml.nodes[2].offset, 4);
+
+        check_item_info::<i8>(&ml.nodes[3], "c", true);
+        assert_eq!(ml.nodes[3].offset, 12);
+    }
+
+    #[test]
+    fn view_memory_layout_member() {
+        let ml = make_memory_layout(
+            r#"
+struct Oof {
+    a$0: bool
+}
+"#,
+        )
+        .unwrap();
+
+        assert_eq!(ml.nodes.len(), 1);
+        assert_eq!(ml.nodes[0].parent_idx, -1);
+        assert_eq!(ml.nodes[0].children_start, -1);
+        check_item_info::<bool>(&ml.nodes[0], "a", true);
+        // NOTE: this should not give the memory layout relative to the parent structure, but the type referred to by the member variable alone.
+        assert_eq!(ml.nodes[0].offset, 0);
+    }
+
+    #[test]
+    fn view_memory_layout_alias() {
+        let ml_a = make_memory_layout(
+            r#"
+struct X {
+    a: u32,
+    b: i8,
+    c: (f32, f32),
+}
+
+type Foo$0 = X;
+        "#,
+        )
+        .unwrap();
+        let ml_b = make_memory_layout(
+            r#"
+struct X$0 {
+    a: u32,
+    b: i8,
+    c: (f32, f32),
+}
+        "#,
+        )
+        .unwrap();
+
+        ml_a.nodes.iter().zip(ml_b.nodes.iter()).for_each(|(a, b)| {
+            assert_eq!(a.item_name, b.item_name);
+            assert_eq!(a.typename, b.typename);
+            assert_eq!(a.size, b.size);
+            assert_eq!(a.alignment, b.alignment);
+            assert_eq!(a.offset, b.offset);
+            assert_eq!(a.parent_idx, b.parent_idx);
+            assert_eq!(a.children_start, b.children_start);
+            assert_eq!(a.children_len, b.children_len);
+        })
+    }
+}
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index bc58aa7220d..8655e954675 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: 2d60bbffe70ae198
+lsp_ext.rs hash: 12bf360ee77cc63d
 
 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:
@@ -886,3 +886,56 @@ export interface FetchDependencyListResult {
 }
 ```
 Returns all crates from this workspace, so it can be used create a viewTree to help navigate the dependency tree.
+
+## View Recursive Memory Layout
+
+**Method:** `rust-analyzer/fetchDependencyList`
+
+**Request:**
+
+```typescript
+/// Holds a location in a text document, the location may be a datatype or a variable and it will do its best to locate the desired type.
+export interface ViewRecursiveMemoryLayoutParams {
+  textDocument: TextDocumentIdentifier;
+  position: Position;
+}
+```
+
+**Response:**
+
+```typescript
+export interface RecursiveMemoryLayoutNode = {
+    /// Name of the item, or [ROOT], `.n` for tuples
+    item_name: string;
+    /// Full name of the type (type aliases are ignored)
+    typename: string;
+    /// Size of the type in bytes
+    size: number;
+    /// Alignment of the type in bytes
+    alignment: number;
+    /// Offset of the type relative to its parent (or 0 if its the root)
+    offset: number;
+    /// Index of the node's parent (or -1 if its the root)
+    parent_idx: number;
+    /// Index of the node's children (or -1 if it does not have children)
+    children_start: number;
+    /// Number of child nodes (unspecified it does not have children)
+    children_len: number;
+};
+
+export interface RecursiveMemoryLayout = {
+    nodes: RecursiveMemoryLayoutNode[];
+};
+```
+
+Returns a vector of nodes representing items in the datatype as a tree, `RecursiveMemoryLayout::nodes[0]` is the root node.
+
+If `RecursiveMemoryLayout::nodes::length == 0` we could not find a suitable type.
+
+Generic Types do not give anything because they are incomplete. Fully specified generic types do not give anything if they are selected directly but do work when a child of other types [this is consistent with other behavior](https://github.com/rust-lang/rust-analyzer/issues/15010).
+
+### Unresolved questions:
+
+- How should enums/unions be represented? currently they do not produce any children because they have multiple distinct sets of children.
+- Should niches be represented? currently they are not reported.
+- A visual representation of the memory layout is not specified, see the provided implementation for an example, however it may not translate well to terminal based editors or other such things.
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 052e3918241..17202e5345a 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -1142,8 +1142,6 @@ export function viewMemoryLayout(ctx: CtxInit): Cmd {
             position,
         });
 
-        // if (expanded == null) return "Not available";
-
         const document = vscode.window.createWebviewPanel(
             "memory_layout",
             "[Memory Layout]",
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 8a0c55a942f..9ab1a993762 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -218,7 +218,5 @@ export type RecursiveMemoryLayoutNode = {
     children_len: number;
 };
 export type RecursiveMemoryLayout = {
-    name: string;
-    expansion: string;
     nodes: RecursiveMemoryLayoutNode[];
 };
-- 
cgit 1.4.1-3-g733a5


From 1dd54eb44ad7eacd450ad81a14ec35cadc15f856 Mon Sep 17 00:00:00 2001
From: Adenine <adenine.dev@gmail.com>
Date: Sat, 8 Jul 2023 12:25:54 -0400
Subject: change viewMemoryLayoutParams to be textPositionParams

---
 crates/rust-analyzer/src/handlers/request.rs |  2 +-
 crates/rust-analyzer/src/lsp_ext.rs          |  9 +--------
 docs/dev/lsp-extensions.md                   | 14 +++-----------
 editors/code/src/lsp_ext.ts                  |  6 +-----
 4 files changed, 6 insertions(+), 25 deletions(-)

(limited to 'editors/code/src')

diff --git a/crates/rust-analyzer/src/handlers/request.rs b/crates/rust-analyzer/src/handlers/request.rs
index b191d8d3684..aad74b7466a 100644
--- a/crates/rust-analyzer/src/handlers/request.rs
+++ b/crates/rust-analyzer/src/handlers/request.rs
@@ -1691,7 +1691,7 @@ pub(crate) fn handle_move_item(
 
 pub(crate) fn handle_view_recursive_memory_layout(
     snap: GlobalStateSnapshot,
-    params: lsp_ext::ViewRecursiveMemoryLayoutParams,
+    params: lsp_types::TextDocumentPositionParams,
 ) -> anyhow::Result<Option<lsp_ext::RecursiveMemoryLayout>> {
     let _p = profile::span("view_recursive_memory_layout");
     let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 39b8e840288..d0989b3230d 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -185,18 +185,11 @@ pub struct ExpandedMacro {
 pub enum ViewRecursiveMemoryLayout {}
 
 impl Request for ViewRecursiveMemoryLayout {
-    type Params = ViewRecursiveMemoryLayoutParams;
+    type Params = lsp_types::TextDocumentPositionParams;
     type Result = Option<RecursiveMemoryLayout>;
     const METHOD: &'static str = "rust-analyzer/viewRecursiveMemoryLayout";
 }
 
-#[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct ViewRecursiveMemoryLayoutParams {
-    pub text_document: TextDocumentIdentifier,
-    pub position: Position,
-}
-
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RecursiveMemoryLayout {
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 8655e954675..024acb87709 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: 12bf360ee77cc63d
+lsp_ext.rs hash: 149a5be3c5e469d1
 
 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:
@@ -889,17 +889,9 @@ Returns all crates from this workspace, so it can be used create a viewTree to h
 
 ## View Recursive Memory Layout
 
-**Method:** `rust-analyzer/fetchDependencyList`
-
-**Request:**
+**Method:** `rust-analyzer/viewRecursiveMemoryLayout`
 
-```typescript
-/// Holds a location in a text document, the location may be a datatype or a variable and it will do its best to locate the desired type.
-export interface ViewRecursiveMemoryLayoutParams {
-  textDocument: TextDocumentIdentifier;
-  position: Position;
-}
-```
+**Request:** `TextDocumentPositionParams`
 
 **Response:**
 
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 9ab1a993762..5af2cab0ee1 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -151,7 +151,7 @@ export const serverStatus = new lc.NotificationType<ServerStatusParams>(
 );
 export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>("experimental/ssr");
 export const viewRecursiveMemoryLayout = new lc.RequestType<
-    ViewRecursiveMemoryLayoutParams,
+    lc.TextDocumentPositionParams,
     RecursiveMemoryLayout | null,
     void
 >("rust-analyzer/viewRecursiveMemoryLayout");
@@ -203,10 +203,6 @@ export type SsrParams = {
     selections: readonly lc.Range[];
 };
 
-export type ViewRecursiveMemoryLayoutParams = {
-    textDocument: lc.TextDocumentIdentifier;
-    position: lc.Position;
-};
 export type RecursiveMemoryLayoutNode = {
     item_name: string;
     typename: string;
-- 
cgit 1.4.1-3-g733a5


From fd31006646b3c9014b1770cf02ab2e9bca59c1e8 Mon Sep 17 00:00:00 2001
From: Tetsuharu Ohzeki <tetsuharu.ohzeki@gmail.com>
Date: Mon, 10 Jul 2023 23:12:42 +0900
Subject: editor/code: Assert types in catch in `sendRequestWithRetry()`
 properly

---
 editors/code/src/util.ts | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index b6b779e2660..688e3873ab4 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -69,20 +69,24 @@ export async function sendRequestWithRetry<TParam, TRet>(
             return await (token
                 ? client.sendRequest(reqType, param, token)
                 : client.sendRequest(reqType, param));
-        } catch (error) {
+        } catch (error: unknown) {
             if (delay === null) {
                 log.warn("LSP request timed out", { method: reqType.method, param, error });
                 throw error;
             }
-            if (error.code === lc.LSPErrorCodes.RequestCancelled) {
-                throw error;
-            }
 
-            if (error.code !== lc.LSPErrorCodes.ContentModified) {
-                log.warn("LSP request failed", { method: reqType.method, param, error });
-                throw error;
+            if (error instanceof lc.ResponseError) {
+                switch (error.code) {
+                    case lc.LSPErrorCodes.RequestCancelled:
+                        throw error;
+                    case lc.LSPErrorCodes.ContentModified:
+                        await sleep(delay);
+                        continue;
+                }
             }
-            await sleep(delay);
+
+            log.warn("LSP request failed", { method: reqType.method, param, error });
+            throw error;
         }
     }
     throw "unreachable";
-- 
cgit 1.4.1-3-g733a5


From a66b7e3eba90690ed2860125c7d47932fddaff22 Mon Sep 17 00:00:00 2001
From: Tetsuharu Ohzeki <tetsuharu.ohzeki@gmail.com>
Date: Mon, 10 Jul 2023 23:13:16 +0900
Subject: editor/code: Remove unused `sendRequestWithRetry`

---
 editors/code/src/util.ts | 36 ------------------------------------
 1 file changed, 36 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 688e3873ab4..b6240234aa6 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -1,4 +1,3 @@
-import * as lc from "vscode-languageclient/node";
 import * as vscode from "vscode";
 import { strict as nativeAssert } from "assert";
 import { exec, ExecOptions, spawnSync } from "child_process";
@@ -57,41 +56,6 @@ export const log = new (class {
     }
 })();
 
-export async function sendRequestWithRetry<TParam, TRet>(
-    client: lc.LanguageClient,
-    reqType: lc.RequestType<TParam, TRet, unknown>,
-    param: TParam,
-    token?: vscode.CancellationToken
-): Promise<TRet> {
-    // The sequence is `10 * (2 ** (2 * n))` where n is 1, 2, 3...
-    for (const delay of [40, 160, 640, 2560, 10240, null]) {
-        try {
-            return await (token
-                ? client.sendRequest(reqType, param, token)
-                : client.sendRequest(reqType, param));
-        } catch (error: unknown) {
-            if (delay === null) {
-                log.warn("LSP request timed out", { method: reqType.method, param, error });
-                throw error;
-            }
-
-            if (error instanceof lc.ResponseError) {
-                switch (error.code) {
-                    case lc.LSPErrorCodes.RequestCancelled:
-                        throw error;
-                    case lc.LSPErrorCodes.ContentModified:
-                        await sleep(delay);
-                        continue;
-                }
-            }
-
-            log.warn("LSP request failed", { method: reqType.method, param, error });
-            throw error;
-        }
-    }
-    throw "unreachable";
-}
-
 export function sleep(ms: number) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-- 
cgit 1.4.1-3-g733a5


From 444bc5b3ba366d2eab252e2c4f5c956a5e21df58 Mon Sep 17 00:00:00 2001
From: Tetsuharu Ohzeki <tetsuharu.ohzeki@gmail.com>
Date: Mon, 10 Jul 2023 23:03:08 +0900
Subject: editor/code: Enable TypeScript's `--useUnknownInCatchVariables`
 option

see: https://www.typescriptlang.org/tsconfig#useUnknownInCatchVariables
---
 editors/code/src/commands.ts     | 4 ++--
 editors/code/tests/unit/index.ts | 3 +++
 editors/code/tsconfig.json       | 1 -
 3 files changed, 5 insertions(+), 3 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 17202e5345a..94ec5e99c6a 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -373,7 +373,7 @@ export function ssr(ctx: CtxInit): Cmd {
                         selections,
                     });
                 } catch (e) {
-                    return e.toString();
+                    return String(e);
                 }
                 return null;
             },
@@ -1156,7 +1156,7 @@ export function viewMemoryLayout(ctx: CtxInit): Cmd {
     <meta http-equiv="X-UA-Compatible" content="IE=edge">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Document</title>
-    <style>   
+    <style>
         * {
             box-sizing: border-box;
         }
diff --git a/editors/code/tests/unit/index.ts b/editors/code/tests/unit/index.ts
index 2fa223bed4a..c231927bb00 100644
--- a/editors/code/tests/unit/index.ts
+++ b/editors/code/tests/unit/index.ts
@@ -1,3 +1,4 @@
+import * as assert from "node:assert/strict";
 import { readdir } from "fs/promises";
 import * as path from "path";
 
@@ -30,6 +31,7 @@ class Suite {
                 await test.promise;
                 ok(`  ✔ ${test.name}`);
             } catch (e) {
+                assert.ok(e instanceof Error);
                 error(`  ✖︎ ${test.name}\n  ${e.stack}`);
                 failed += 1;
             }
@@ -50,6 +52,7 @@ export class Context {
             await ctx.run();
             ok(`✔ ${name}`);
         } catch (e) {
+            assert.ok(e instanceof Error);
             error(`✖︎ ${name}\n  ${e.stack}`);
             throw e;
         }
diff --git a/editors/code/tsconfig.json b/editors/code/tsconfig.json
index 4b107a5d251..87fd14072f2 100644
--- a/editors/code/tsconfig.json
+++ b/editors/code/tsconfig.json
@@ -12,7 +12,6 @@
         "newLine": "LF",
         // These disables some enhancement type checking options
         // to update typescript version without any code change.
-        "useUnknownInCatchVariables": false,
         "exactOptionalPropertyTypes": false
     },
     "exclude": ["node_modules", ".vscode-test"],
-- 
cgit 1.4.1-3-g733a5


From 445b4fc27f81212ccfab85890f3196517e85ecb3 Mon Sep 17 00:00:00 2001
From: Tetsuharu Ohzeki <tetsuharu.ohzeki@gmail.com>
Date: Tue, 11 Jul 2023 06:10:00 +0900
Subject: editor/code: Sort the style to import types

see:
- https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/consistent-type-imports.md
- https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/no-import-type-side-effects.md
---
 editors/code/.eslintrc.js                     |  9 +++++++++
 editors/code/src/ast_inspector.ts             |  4 ++--
 editors/code/src/bootstrap.ts                 |  4 ++--
 editors/code/src/client.ts                    |  2 +-
 editors/code/src/commands.ts                  | 12 ++++++------
 editors/code/src/config.ts                    |  2 +-
 editors/code/src/ctx.ts                       | 14 +++++++-------
 editors/code/src/debug.ts                     |  4 ++--
 editors/code/src/dependencies_provider.ts     |  4 ++--
 editors/code/src/diagnostics.ts               | 10 ++++++++--
 editors/code/src/main.ts                      |  2 +-
 editors/code/src/persistent_state.ts          |  2 +-
 editors/code/src/run.ts                       |  6 +++---
 editors/code/src/tasks.ts                     |  2 +-
 editors/code/src/util.ts                      |  2 +-
 editors/code/tests/unit/launch_config.test.ts |  2 +-
 editors/code/tests/unit/runnable_env.test.ts  |  6 +++---
 editors/code/tests/unit/settings.test.ts      |  2 +-
 18 files changed, 52 insertions(+), 37 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/.eslintrc.js b/editors/code/.eslintrc.js
index 297e9fa1e5c..69f02b4ab50 100644
--- a/editors/code/.eslintrc.js
+++ b/editors/code/.eslintrc.js
@@ -33,5 +33,14 @@ module.exports = {
         "@typescript-eslint/semi": ["error", "always"],
         "@typescript-eslint/no-unnecessary-type-assertion": "error",
         "@typescript-eslint/no-floating-promises": "error",
+
+        "@typescript-eslint/consistent-type-imports": [
+            "error",
+            {
+                prefer: "type-imports",
+                fixStyle: "inline-type-imports",
+            },
+        ],
+        "@typescript-eslint/no-import-type-side-effects": "error",
     },
 };
diff --git a/editors/code/src/ast_inspector.ts b/editors/code/src/ast_inspector.ts
index fa963d8eb99..2ebfd564ca3 100644
--- a/editors/code/src/ast_inspector.ts
+++ b/editors/code/src/ast_inspector.ts
@@ -1,7 +1,7 @@
 import * as vscode from "vscode";
 
-import { Ctx, Disposable } from "./ctx";
-import { RustEditor, isRustEditor } from "./util";
+import type { Ctx, Disposable } from "./ctx";
+import { type RustEditor, isRustEditor } from "./util";
 import { unwrapUndefinable } from "./undefinable";
 
 // FIXME: consider implementing this via the Tree View API?
diff --git a/editors/code/src/bootstrap.ts b/editors/code/src/bootstrap.ts
index 7b831a8a695..85668a23f37 100644
--- a/editors/code/src/bootstrap.ts
+++ b/editors/code/src/bootstrap.ts
@@ -1,8 +1,8 @@
 import * as vscode from "vscode";
 import * as os from "os";
-import { Config } from "./config";
+import type { Config } from "./config";
 import { log, isValidExecutable } from "./util";
-import { PersistentState } from "./persistent_state";
+import type { PersistentState } from "./persistent_state";
 import { exec } from "child_process";
 
 export async function bootstrap(
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 7b151c804af..35a114fb04d 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -6,7 +6,7 @@ import * as Is from "vscode-languageclient/lib/common/utils/is";
 import { assert } from "./util";
 import * as diagnostics from "./diagnostics";
 import { WorkspaceEdit } from "vscode";
-import { Config, prepareVSCodeConfig } from "./config";
+import { type Config, prepareVSCodeConfig } from "./config";
 import { randomUUID } from "crypto";
 import { sep as pathSeparator } from "path";
 import { unwrapUndefinable } from "./undefinable";
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 94ec5e99c6a..1289fa2ac73 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -3,23 +3,23 @@ import * as lc from "vscode-languageclient";
 import * as ra from "./lsp_ext";
 import * as path from "path";
 
-import { Ctx, Cmd, CtxInit, discoverWorkspace } from "./ctx";
+import { type Ctx, type Cmd, type CtxInit, discoverWorkspace } from "./ctx";
 import { applySnippetWorkspaceEdit, applySnippetTextEdits } from "./snippets";
 import { spawnSync } from "child_process";
-import { RunnableQuickPick, selectRunnable, createTask, createArgs } from "./run";
+import { type RunnableQuickPick, selectRunnable, createTask, createArgs } from "./run";
 import { AstInspector } from "./ast_inspector";
 import {
     isRustDocument,
     isCargoTomlDocument,
     sleep,
     isRustEditor,
-    RustEditor,
-    RustDocument,
+    type RustEditor,
+    type RustDocument,
 } from "./util";
 import { startDebugSession, makeDebugConfig } from "./debug";
-import { LanguageClient } from "vscode-languageclient/node";
+import type { LanguageClient } from "vscode-languageclient/node";
 import { LINKED_COMMANDS } from "./client";
-import { DependencyId } from "./dependencies_provider";
+import type { DependencyId } from "./dependencies_provider";
 import { unwrapUndefinable } from "./undefinable";
 
 export * from "./ast_inspector";
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 7f4efebb2af..7dbc4bdd47b 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -2,7 +2,7 @@ import * as Is from "vscode-languageclient/lib/common/utils/is";
 import * as os from "os";
 import * as path from "path";
 import * as vscode from "vscode";
-import { Env } from "./client";
+import type { Env } from "./client";
 import { log } from "./util";
 import { expectNotUndefined, unwrapUndefinable } from "./undefinable";
 
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index a72b5391ff1..1ae0c96c6e7 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -1,5 +1,5 @@
 import * as vscode from "vscode";
-import * as lc from "vscode-languageclient/node";
+import type * as lc from "vscode-languageclient/node";
 import * as ra from "./lsp_ext";
 import * as path from "path";
 
@@ -12,19 +12,19 @@ import {
     isRustEditor,
     LazyOutputChannel,
     log,
-    RustEditor,
+    type RustEditor,
 } from "./util";
-import { ServerStatusParams } from "./lsp_ext";
+import type { ServerStatusParams } from "./lsp_ext";
 import {
-    Dependency,
-    DependencyFile,
+    type Dependency,
+    type DependencyFile,
     RustDependenciesProvider,
-    DependencyId,
+    type DependencyId,
 } from "./dependencies_provider";
 import { execRevealDependency } from "./commands";
 import { PersistentState } from "./persistent_state";
 import { bootstrap } from "./bootstrap";
-import { ExecOptions } from "child_process";
+import type { ExecOptions } from "child_process";
 
 // We only support local folders, not eg. Live Share (`vlsl:` scheme), so don't activate if
 // only those are in use. We use "Empty" to represent these scenarios
diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
index 29758feafe4..484f547230f 100644
--- a/editors/code/src/debug.ts
+++ b/editors/code/src/debug.ts
@@ -1,10 +1,10 @@
 import * as os from "os";
 import * as vscode from "vscode";
 import * as path from "path";
-import * as ra from "./lsp_ext";
+import type * as ra from "./lsp_ext";
 
 import { Cargo, getRustcId, getSysroot } from "./toolchain";
-import { Ctx } from "./ctx";
+import type { Ctx } from "./ctx";
 import { prepareEnv } from "./run";
 import { unwrapUndefinable } from "./undefinable";
 
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 51ba11ecc92..98d6d7001a6 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -1,9 +1,9 @@
 import * as vscode from "vscode";
 import * as fspath from "path";
 import * as fs from "fs";
-import { CtxInit } from "./ctx";
+import type { CtxInit } from "./ctx";
 import * as ra from "./lsp_ext";
-import { FetchDependencyListResult } from "./lsp_ext";
+import type { FetchDependencyListResult } from "./lsp_ext";
 import { unwrapUndefinable } from "./undefinable";
 
 export class RustDependenciesProvider
diff --git a/editors/code/src/diagnostics.ts b/editors/code/src/diagnostics.ts
index a7e0845a278..e573f5a63f5 100644
--- a/editors/code/src/diagnostics.ts
+++ b/editors/code/src/diagnostics.ts
@@ -1,7 +1,13 @@
 import * as anser from "anser";
 import * as vscode from "vscode";
-import { ProviderResult, Range, TextEditorDecorationType, ThemeColor, window } from "vscode";
-import { Ctx } from "./ctx";
+import {
+    type ProviderResult,
+    Range,
+    type TextEditorDecorationType,
+    ThemeColor,
+    window,
+} from "vscode";
+import type { Ctx } from "./ctx";
 import { unwrapUndefinable } from "./undefinable";
 
 export const URI_SCHEME = "rust-analyzer-diagnostics-view";
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 64aea03394a..1121951c07f 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -2,7 +2,7 @@ import * as vscode from "vscode";
 import * as lc from "vscode-languageclient/node";
 
 import * as commands from "./commands";
-import { CommandFactory, Ctx, fetchWorkspace } from "./ctx";
+import { type CommandFactory, Ctx, fetchWorkspace } from "./ctx";
 import * as diagnostics from "./diagnostics";
 import { activateTaskProvider } from "./tasks";
 import { setContextValue } from "./util";
diff --git a/editors/code/src/persistent_state.ts b/editors/code/src/persistent_state.ts
index 8964a78dc32..cebd16a3c90 100644
--- a/editors/code/src/persistent_state.ts
+++ b/editors/code/src/persistent_state.ts
@@ -1,4 +1,4 @@
-import * as vscode from "vscode";
+import type * as vscode from "vscode";
 import { log } from "./util";
 
 export class PersistentState {
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index c20a5487b77..8ec569b6036 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -1,11 +1,11 @@
 import * as vscode from "vscode";
-import * as lc from "vscode-languageclient";
+import type * as lc from "vscode-languageclient";
 import * as ra from "./lsp_ext";
 import * as tasks from "./tasks";
 
-import { CtxInit } from "./ctx";
+import type { CtxInit } from "./ctx";
 import { makeDebugConfig } from "./debug";
-import { Config, RunnableEnvCfg } from "./config";
+import type { Config, RunnableEnvCfg } from "./config";
 import { unwrapUndefinable } from "./undefinable";
 
 const quickPickButtons = [
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index 5199508c822..f451e738d5d 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -1,6 +1,6 @@
 import * as vscode from "vscode";
 import * as toolchain from "./toolchain";
-import { Config } from "./config";
+import type { Config } from "./config";
 import { log } from "./util";
 import { unwrapUndefinable } from "./undefinable";
 
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index b6240234aa6..64f4582770b 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -1,6 +1,6 @@
 import * as vscode from "vscode";
 import { strict as nativeAssert } from "assert";
-import { exec, ExecOptions, spawnSync } from "child_process";
+import { exec, type ExecOptions, spawnSync } from "child_process";
 import { inspect } from "util";
 
 export function assert(condition: boolean, explanation: string): asserts condition {
diff --git a/editors/code/tests/unit/launch_config.test.ts b/editors/code/tests/unit/launch_config.test.ts
index 0531e064d2d..eeb8608a42d 100644
--- a/editors/code/tests/unit/launch_config.test.ts
+++ b/editors/code/tests/unit/launch_config.test.ts
@@ -1,6 +1,6 @@
 import * as assert from "assert";
 import { Cargo } from "../../src/toolchain";
-import { Context } from ".";
+import type { Context } from ".";
 
 export async function getTests(ctx: Context) {
     await ctx.suite("Launch configuration/Lens", (suite) => {
diff --git a/editors/code/tests/unit/runnable_env.test.ts b/editors/code/tests/unit/runnable_env.test.ts
index b7d59e399dd..b1407ce0193 100644
--- a/editors/code/tests/unit/runnable_env.test.ts
+++ b/editors/code/tests/unit/runnable_env.test.ts
@@ -1,8 +1,8 @@
 import * as assert from "assert";
 import { prepareEnv } from "../../src/run";
-import { RunnableEnvCfg } from "../../src/config";
-import { Context } from ".";
-import * as ra from "../../src/lsp_ext";
+import type { RunnableEnvCfg } from "../../src/config";
+import type { Context } from ".";
+import type * as ra from "../../src/lsp_ext";
 
 function makeRunnable(label: string): ra.Runnable {
     return {
diff --git a/editors/code/tests/unit/settings.test.ts b/editors/code/tests/unit/settings.test.ts
index f171f5f74f3..bafb9569a1c 100644
--- a/editors/code/tests/unit/settings.test.ts
+++ b/editors/code/tests/unit/settings.test.ts
@@ -1,5 +1,5 @@
 import * as assert from "assert";
-import { Context } from ".";
+import type { Context } from ".";
 import { substituteVariablesInEnv } from "../../src/config";
 
 export async function getTests(ctx: Context) {
-- 
cgit 1.4.1-3-g733a5


From f7823f31069c6ec5be24d0497847bf1bb8a4c683 Mon Sep 17 00:00:00 2001
From: Tetsuharu Ohzeki <tetsuharu.ohzeki@gmail.com>
Date: Tue, 11 Jul 2023 22:35:10 +0900
Subject: editor/code: Re-apply code format

---
 editors/code/src/ast_inspector.ts         | 16 +++---
 editors/code/src/bootstrap.ts             | 16 +++---
 editors/code/src/client.ts                | 67 +++++++++++++------------
 editors/code/src/commands.ts              | 82 +++++++++++++++----------------
 editors/code/src/config.ts                | 14 +++---
 editors/code/src/ctx.ts                   | 34 ++++++-------
 editors/code/src/debug.ts                 | 14 +++---
 editors/code/src/dependencies_provider.ts | 12 ++---
 editors/code/src/diagnostics.ts           |  6 +--
 editors/code/src/lsp_ext.ts               | 36 +++++++-------
 editors/code/src/main.ts                  | 20 ++++----
 editors/code/src/run.ts                   |  8 +--
 editors/code/src/snippets.ts              | 10 ++--
 editors/code/src/tasks.ts                 |  8 +--
 editors/code/src/toolchain.ts             |  8 +--
 editors/code/src/util.ts                  |  2 +-
 editors/code/tests/unit/index.ts          |  2 +-
 17 files changed, 180 insertions(+), 175 deletions(-)

(limited to 'editors/code/src')

diff --git a/editors/code/src/ast_inspector.ts b/editors/code/src/ast_inspector.ts
index 2ebfd564ca3..688c53a9b1f 100644
--- a/editors/code/src/ast_inspector.ts
+++ b/editors/code/src/ast_inspector.ts
@@ -37,23 +37,23 @@ export class AstInspector implements vscode.HoverProvider, vscode.DefinitionProv
 
     constructor(ctx: Ctx) {
         ctx.pushExtCleanup(
-            vscode.languages.registerHoverProvider({ scheme: "rust-analyzer" }, this)
+            vscode.languages.registerHoverProvider({ scheme: "rust-analyzer" }, this),
         );
         ctx.pushExtCleanup(vscode.languages.registerDefinitionProvider({ language: "rust" }, this));
         vscode.workspace.onDidCloseTextDocument(
             this.onDidCloseTextDocument,
             this,
-            ctx.subscriptions
+            ctx.subscriptions,
         );
         vscode.workspace.onDidChangeTextDocument(
             this.onDidChangeTextDocument,
             this,
-            ctx.subscriptions
+            ctx.subscriptions,
         );
         vscode.window.onDidChangeVisibleTextEditors(
             this.onDidChangeVisibleTextEditors,
             this,
-            ctx.subscriptions
+            ctx.subscriptions,
         );
     }
     dispose() {
@@ -85,7 +85,7 @@ export class AstInspector implements vscode.HoverProvider, vscode.DefinitionProv
 
     private findAstTextEditor(): undefined | vscode.TextEditor {
         return vscode.window.visibleTextEditors.find(
-            (it) => it.document.uri.scheme === "rust-analyzer"
+            (it) => it.document.uri.scheme === "rust-analyzer",
         );
     }
 
@@ -100,7 +100,7 @@ export class AstInspector implements vscode.HoverProvider, vscode.DefinitionProv
     // additional positional params are omitted
     provideDefinition(
         doc: vscode.TextDocument,
-        pos: vscode.Position
+        pos: vscode.Position,
     ): vscode.ProviderResult<vscode.DefinitionLink[]> {
         if (!this.rustEditor || doc.uri.toString() !== this.rustEditor.document.uri.toString()) {
             return;
@@ -132,7 +132,7 @@ export class AstInspector implements vscode.HoverProvider, vscode.DefinitionProv
     // additional positional params are omitted
     provideHover(
         doc: vscode.TextDocument,
-        hoverPosition: vscode.Position
+        hoverPosition: vscode.Position,
     ): vscode.ProviderResult<vscode.Hover> {
         if (!this.rustEditor) return;
 
@@ -159,7 +159,7 @@ export class AstInspector implements vscode.HoverProvider, vscode.DefinitionProv
 
     private parseRustTextRange(
         doc: vscode.TextDocument,
-        astLine: string
+        astLine: string,
     ): undefined | vscode.Range {
         const parsedRange = /(\d+)\.\.(\d+)/.exec(astLine);
         if (!parsedRange) return;
diff --git a/editors/code/src/bootstrap.ts b/editors/code/src/bootstrap.ts
index 85668a23f37..ef4dff095cf 100644
--- a/editors/code/src/bootstrap.ts
+++ b/editors/code/src/bootstrap.ts
@@ -8,13 +8,13 @@ import { exec } from "child_process";
 export async function bootstrap(
     context: vscode.ExtensionContext,
     config: Config,
-    state: PersistentState
+    state: PersistentState,
 ): Promise<string> {
     const path = await getServer(context, config, state);
     if (!path) {
         throw new Error(
             "Rust Analyzer Language Server is not available. " +
-                "Please, ensure its [proper installation](https://rust-analyzer.github.io/manual.html#installation)."
+                "Please, ensure its [proper installation](https://rust-analyzer.github.io/manual.html#installation).",
         );
     }
 
@@ -34,7 +34,7 @@ export async function bootstrap(
 async function getServer(
     context: vscode.ExtensionContext,
     config: Config,
-    state: PersistentState
+    state: PersistentState,
 ): Promise<string | undefined> {
     const explicitPath = process.env["__RA_LSP_SERVER_DEBUG"] ?? config.serverPath;
     if (explicitPath) {
@@ -49,7 +49,7 @@ async function getServer(
     const bundled = vscode.Uri.joinPath(context.extensionUri, "server", `rust-analyzer${ext}`);
     const bundledExists = await vscode.workspace.fs.stat(bundled).then(
         () => true,
-        () => false
+        () => false,
     );
     if (bundledExists) {
         let server = bundled;
@@ -58,7 +58,7 @@ async function getServer(
             const dest = vscode.Uri.joinPath(config.globalStorageUri, `rust-analyzer${ext}`);
             let exists = await vscode.workspace.fs.stat(dest).then(
                 () => true,
-                () => false
+                () => false,
             );
             if (exists && config.package.version !== state.serverVersion) {
                 await vscode.workspace.fs.delete(dest);
@@ -81,7 +81,7 @@ async function getServer(
             "run `cargo xtask install --server` to build the language server from sources. " +
             "If you feel that your platform should be supported, please create an issue " +
             "about that [here](https://github.com/rust-lang/rust-analyzer/issues) and we " +
-            "will consider it."
+            "will consider it.",
     );
     return undefined;
 }
@@ -131,7 +131,7 @@ async function patchelf(dest: vscode.Uri): Promise<void> {
                             } else {
                                 resolve(stdout);
                             }
-                        }
+                        },
                     );
                     handle.stdin?.write(expression);
                     handle.stdin?.end();
@@ -139,6 +139,6 @@ async function patchelf(dest: vscode.Uri): Promise<void> {
             } finally {
                 await vscode.workspace.fs.delete(origFile);
             }
-        }
+        },
     );
 }
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 35a114fb04d..ba8546763ec 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -34,21 +34,24 @@ export const LINKED_COMMANDS = new Map<string, ra.CommandLink>();
 // add code to remove a target command from the map after the link is
 // clicked, but assuming most links in hover sheets won't be clicked anyway
 // this code won't change the overall memory use much.
-setInterval(function cleanupOlderCommandLinks() {
-    // keys are returned in insertion order, we'll keep a few
-    // of recent keys available, and clean the rest
-    const keys = [...LINKED_COMMANDS.keys()];
-    const keysToRemove = keys.slice(0, keys.length - 10);
-    for (const key of keysToRemove) {
-        LINKED_COMMANDS.delete(key);
-    }
-}, 10 * 60 * 1000);
+setInterval(
+    function cleanupOlderCommandLinks() {
+        // keys are returned in insertion order, we'll keep a few
+        // of recent keys available, and clean the rest
+        const keys = [...LINKED_COMMANDS.keys()];
+        const keysToRemove = keys.slice(0, keys.length - 10);
+        for (const key of keysToRemove) {
+            LINKED_COMMANDS.delete(key);
+        }
+    },
+    10 * 60 * 1000,
+);
 
 function renderCommand(cmd: ra.CommandLink): string {
     const commandId = randomUUID();
     LINKED_COMMANDS.set(commandId, cmd);
     return `[${cmd.title}](command:rust-analyzer.linkToCommand?${encodeURIComponent(
-        JSON.stringify([commandId])
+        JSON.stringify([commandId]),
     )} '${cmd.tooltip}')`;
 }
 
@@ -57,7 +60,7 @@ function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownStri
         .map(
             (group) =>
                 (group.title ? group.title + " " : "") +
-                group.commands.map(renderCommand).join(" | ")
+                group.commands.map(renderCommand).join(" | "),
         )
         .join("___");
 
@@ -72,7 +75,7 @@ export async function createClient(
     initializationOptions: vscode.WorkspaceConfiguration,
     serverOptions: lc.ServerOptions,
     config: Config,
-    unlinkedFiles: vscode.Uri[]
+    unlinkedFiles: vscode.Uri[],
 ): Promise<lc.LanguageClient> {
     const clientOptions: lc.LanguageClientOptions = {
         documentSelector: [{ scheme: "file", language: "rust" }],
@@ -93,7 +96,7 @@ export async function createClient(
                 async configuration(
                     params: lc.ConfigurationParams,
                     token: vscode.CancellationToken,
-                    next: lc.ConfigurationRequest.HandlerSignature
+                    next: lc.ConfigurationRequest.HandlerSignature,
                 ) {
                     const resp = await next(params, token);
                     if (resp && Array.isArray(resp)) {
@@ -117,7 +120,7 @@ export async function createClient(
             async handleDiagnostics(
                 uri: vscode.Uri,
                 diagnosticList: vscode.Diagnostic[],
-                next: lc.HandleDiagnosticsSignature
+                next: lc.HandleDiagnosticsSignature,
             ) {
                 const preview = config.previewRustcOutput;
                 const errorCode = config.useRustcErrorCode;
@@ -137,20 +140,20 @@ export async function createClient(
                             const folder = vscode.workspace.getWorkspaceFolder(uri)?.uri.fsPath;
                             if (folder) {
                                 const parentBackslash = uri.fsPath.lastIndexOf(
-                                    pathSeparator + "src"
+                                    pathSeparator + "src",
                                 );
                                 const parent = uri.fsPath.substring(0, parentBackslash);
 
                                 if (parent.startsWith(folder)) {
                                     const path = vscode.Uri.file(
-                                        parent + pathSeparator + "Cargo.toml"
+                                        parent + pathSeparator + "Cargo.toml",
                                     );
                                     void vscode.workspace.fs.stat(path).then(async () => {
                                         const choice = await vscode.window.showInformationMessage(
                                             `This rust file does not belong to a loaded cargo project. It looks like it might belong to the workspace at ${path.path}, do you want to add it to the linked Projects?`,
                                             "Yes",
                                             "No",
-                                            "Don't show this again"
+                                            "Don't show this again",
                                         );
                                         switch (choice) {
                                             case undefined:
@@ -168,14 +171,14 @@ export async function createClient(
                                                     config
                                                         .get<any[]>("linkedProjects")
                                                         ?.concat(pathToInsert),
-                                                    false
+                                                    false,
                                                 );
                                                 break;
                                             case "Don't show this again":
                                                 await config.update(
                                                     "showUnlinkedFileNotification",
                                                     false,
-                                                    false
+                                                    false,
                                                 );
                                                 break;
                                         }
@@ -222,7 +225,7 @@ export async function createClient(
                 document: vscode.TextDocument,
                 position: vscode.Position,
                 token: vscode.CancellationToken,
-                _next: lc.ProvideHoverSignature
+                _next: lc.ProvideHoverSignature,
             ) {
                 const editor = vscode.window.activeTextEditor;
                 const positionOrRange = editor?.selection?.contains(position)
@@ -236,7 +239,7 @@ export async function createClient(
                                 client.code2ProtocolConverter.asTextDocumentIdentifier(document),
                             position: positionOrRange,
                         },
-                        token
+                        token,
                     )
                     .then(
                         (result) => {
@@ -250,7 +253,7 @@ export async function createClient(
                         (error) => {
                             client.handleFailedRequest(lc.HoverRequest.type, token, error, null);
                             return Promise.resolve(null);
-                        }
+                        },
                     );
             },
             // Using custom handling of CodeActions to support action groups and snippet edits.
@@ -260,14 +263,14 @@ export async function createClient(
                 range: vscode.Range,
                 context: vscode.CodeActionContext,
                 token: vscode.CancellationToken,
-                _next: lc.ProvideCodeActionsSignature
+                _next: lc.ProvideCodeActionsSignature,
             ) {
                 const params: lc.CodeActionParams = {
                     textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
                     range: client.code2ProtocolConverter.asRange(range),
                     context: await client.code2ProtocolConverter.asCodeActionContext(
                         context,
-                        token
+                        token,
                     ),
                 };
                 return client.sendRequest(lc.CodeActionRequest.type, params, token).then(
@@ -283,21 +286,21 @@ export async function createClient(
                             if (lc.CodeAction.is(item)) {
                                 assert(
                                     !item.command,
-                                    "We don't expect to receive commands in CodeActions"
+                                    "We don't expect to receive commands in CodeActions",
                                 );
                                 const action = await client.protocol2CodeConverter.asCodeAction(
                                     item,
-                                    token
+                                    token,
                                 );
                                 result.push(action);
                                 continue;
                             }
                             assert(
                                 isCodeActionWithoutEditsAndCommands(item),
-                                "We don't expect edits or commands here"
+                                "We don't expect edits or commands here",
                             );
                             const kind = client.protocol2CodeConverter.asCodeActionKind(
-                                (item as any).kind
+                                (item as any).kind,
                             );
                             const action = new vscode.CodeAction(item.title, kind);
                             const group = (item as any).group;
@@ -351,7 +354,7 @@ export async function createClient(
                         }
                         return result;
                     },
-                    (_error) => undefined
+                    (_error) => undefined,
                 );
             },
         },
@@ -364,7 +367,7 @@ export async function createClient(
         "rust-analyzer",
         "Rust Analyzer Language Server",
         serverOptions,
-        clientOptions
+        clientOptions,
     );
 
     // To turn on all proposed features use: client.registerProposedFeatures();
@@ -400,7 +403,7 @@ class ExperimentalFeatures implements lc.StaticFeature {
     }
     initialize(
         _capabilities: lc.ServerCapabilities,
-        _documentSelector: lc.DocumentSelector | undefined
+        _documentSelector: lc.DocumentSelector | undefined,
     ): void {}
     dispose(): void {}
 }
@@ -419,7 +422,7 @@ class OverrideFeatures implements lc.StaticFeature {
     }
     initialize(
         _capabilities: lc.ServerCapabilities,
-        _documentSelector: lc.DocumentSelector | undefined
+        _documentSelector: lc.DocumentSelector | undefined,
     ): void {}
     dispose(): void {}
 }
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 1289fa2ac73..e21f536f26a 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -48,7 +48,7 @@ export function analyzerStatus(ctx: CtxInit): Cmd {
     })();
 
     ctx.pushExtCleanup(
-        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-status", tdcp)
+        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-status", tdcp),
     );
 
     return async () => {
@@ -80,7 +80,7 @@ export function memoryUsage(ctx: CtxInit): Cmd {
     })();
 
     ctx.pushExtCleanup(
-        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-memory", tdcp)
+        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-memory", tdcp),
     );
 
     return async () => {
@@ -126,7 +126,7 @@ export function matchingBrace(ctx: CtxInit): Cmd {
         const response = await client.sendRequest(ra.matchingBrace, {
             textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
             positions: editor.selections.map((s) =>
-                client.code2ProtocolConverter.asPosition(s.active)
+                client.code2ProtocolConverter.asPosition(s.active),
             ),
         });
         editor.selections = editor.selections.map((sel, idx) => {
@@ -196,7 +196,7 @@ export function onEnter(ctx: CtxInit): Cmd {
         const lcEdits = await client
             .sendRequest(ra.onEnter, {
                 textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
-                    editor.document
+                    editor.document,
                 ),
                 position: client.code2ProtocolConverter.asPosition(editor.selection.active),
             })
@@ -249,7 +249,7 @@ export function parentModule(ctx: CtxInit): Cmd {
                 client,
                 uri,
                 position,
-                locations.map((loc) => lc.Location.create(loc.targetUri, loc.targetRange))
+                locations.map((loc) => lc.Location.create(loc.targetUri, loc.targetRange)),
             );
         }
     };
@@ -357,7 +357,7 @@ export function ssr(ctx: CtxInit): Cmd {
         const position = editor.selection.active;
         const selections = editor.selections;
         const textDocument = client.code2ProtocolConverter.asTextDocumentIdentifier(
-            editor.document
+            editor.document,
         );
 
         const options: vscode.InputBoxOptions = {
@@ -397,9 +397,9 @@ export function ssr(ctx: CtxInit): Cmd {
                 });
 
                 await vscode.workspace.applyEdit(
-                    await client.protocol2CodeConverter.asWorkspaceEdit(edit, token)
+                    await client.protocol2CodeConverter.asWorkspaceEdit(edit, token),
                 );
-            }
+            },
         );
     };
 }
@@ -428,12 +428,12 @@ export function syntaxTree(ctx: CtxInit): Cmd {
             vscode.workspace.onDidChangeTextDocument(
                 this.onDidChangeTextDocument,
                 this,
-                ctx.subscriptions
+                ctx.subscriptions,
             );
             vscode.window.onDidChangeActiveTextEditor(
                 this.onDidChangeActiveTextEditor,
                 this,
-                ctx.subscriptions
+                ctx.subscriptions,
             );
         }
 
@@ -452,7 +452,7 @@ export function syntaxTree(ctx: CtxInit): Cmd {
 
         async provideTextDocumentContent(
             uri: vscode.Uri,
-            ct: vscode.CancellationToken
+            ct: vscode.CancellationToken,
         ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
             if (!rustEditor) return "";
@@ -475,12 +475,12 @@ export function syntaxTree(ctx: CtxInit): Cmd {
 
     ctx.pushExtCleanup(new AstInspector(ctx));
     ctx.pushExtCleanup(
-        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-syntax-tree", tdcp)
+        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-syntax-tree", tdcp),
     );
     ctx.pushExtCleanup(
         vscode.languages.setLanguageConfiguration("ra_syntax_tree", {
             brackets: [["[", ")"]],
-        })
+        }),
     );
 
     return async () => {
@@ -513,7 +513,7 @@ function viewFileUsingTextDocumentContentProvider(
     requestType: lc.RequestType<lc.TextDocumentPositionParams, string, void>,
     uri: string,
     scheme: string,
-    shouldUpdate: boolean
+    shouldUpdate: boolean,
 ): Cmd {
     const tdcp = new (class implements vscode.TextDocumentContentProvider {
         readonly uri = vscode.Uri.parse(uri);
@@ -522,12 +522,12 @@ function viewFileUsingTextDocumentContentProvider(
             vscode.workspace.onDidChangeTextDocument(
                 this.onDidChangeTextDocument,
                 this,
-                ctx.subscriptions
+                ctx.subscriptions,
             );
             vscode.window.onDidChangeActiveTextEditor(
                 this.onDidChangeActiveTextEditor,
                 this,
-                ctx.subscriptions
+                ctx.subscriptions,
             );
         }
 
@@ -546,7 +546,7 @@ function viewFileUsingTextDocumentContentProvider(
 
         async provideTextDocumentContent(
             _uri: vscode.Uri,
-            ct: vscode.CancellationToken
+            ct: vscode.CancellationToken,
         ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
             if (!rustEditor) return "";
@@ -554,7 +554,7 @@ function viewFileUsingTextDocumentContentProvider(
             const client = ctx.client;
             const params = {
                 textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
-                    rustEditor.document
+                    rustEditor.document,
                 ),
                 position: client.code2ProtocolConverter.asPosition(rustEditor.selection.active),
             };
@@ -602,7 +602,7 @@ export function interpretFunction(ctx: CtxInit): Cmd {
         ra.interpretFunction,
         uri,
         `rust-analyzer-interpret-function`,
-        false
+        false,
     );
 }
 
@@ -614,12 +614,12 @@ export function viewFileText(ctx: CtxInit): Cmd {
             vscode.workspace.onDidChangeTextDocument(
                 this.onDidChangeTextDocument,
                 this,
-                ctx.subscriptions
+                ctx.subscriptions,
             );
             vscode.window.onDidChangeActiveTextEditor(
                 this.onDidChangeActiveTextEditor,
                 this,
-                ctx.subscriptions
+                ctx.subscriptions,
             );
         }
 
@@ -638,14 +638,14 @@ export function viewFileText(ctx: CtxInit): Cmd {
 
         async provideTextDocumentContent(
             _uri: vscode.Uri,
-            ct: vscode.CancellationToken
+            ct: vscode.CancellationToken,
         ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
             if (!rustEditor) return "";
             const client = ctx.client;
 
             const params = client.code2ProtocolConverter.asTextDocumentIdentifier(
-                rustEditor.document
+                rustEditor.document,
             );
             return client.sendRequest(ra.viewFileText, params, ct);
         }
@@ -656,7 +656,7 @@ export function viewFileText(ctx: CtxInit): Cmd {
     })();
 
     ctx.pushExtCleanup(
-        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-file-text", tdcp)
+        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-file-text", tdcp),
     );
 
     return async () => {
@@ -677,12 +677,12 @@ export function viewItemTree(ctx: CtxInit): Cmd {
             vscode.workspace.onDidChangeTextDocument(
                 this.onDidChangeTextDocument,
                 this,
-                ctx.subscriptions
+                ctx.subscriptions,
             );
             vscode.window.onDidChangeActiveTextEditor(
                 this.onDidChangeActiveTextEditor,
                 this,
-                ctx.subscriptions
+                ctx.subscriptions,
             );
         }
 
@@ -701,7 +701,7 @@ export function viewItemTree(ctx: CtxInit): Cmd {
 
         async provideTextDocumentContent(
             _uri: vscode.Uri,
-            ct: vscode.CancellationToken
+            ct: vscode.CancellationToken,
         ): Promise<string> {
             const rustEditor = ctx.activeRustEditor;
             if (!rustEditor) return "";
@@ -709,7 +709,7 @@ export function viewItemTree(ctx: CtxInit): Cmd {
 
             const params = {
                 textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
-                    rustEditor.document
+                    rustEditor.document,
                 ),
             };
             return client.sendRequest(ra.viewItemTree, params, ct);
@@ -721,7 +721,7 @@ export function viewItemTree(ctx: CtxInit): Cmd {
     })();
 
     ctx.pushExtCleanup(
-        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-item-tree", tdcp)
+        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-item-tree", tdcp),
     );
 
     return async () => {
@@ -746,7 +746,7 @@ function crateGraph(ctx: CtxInit, full: boolean): Cmd {
                 enableScripts: true,
                 retainContextWhenHidden: true,
                 localResourceRoots: [nodeModulesPath],
-            }
+            },
         );
         const params = {
             full: full,
@@ -835,7 +835,7 @@ export function expandMacro(ctx: CtxInit): Cmd {
 
             const expanded = await client.sendRequest(ra.expandMacro, {
                 textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(
-                    editor.document
+                    editor.document,
                 ),
                 position,
             });
@@ -851,7 +851,7 @@ export function expandMacro(ctx: CtxInit): Cmd {
     })();
 
     ctx.pushExtCleanup(
-        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-expand-macro", tdcp)
+        vscode.workspace.registerTextDocumentContentProvider("rust-analyzer-expand-macro", tdcp),
     );
 
     return async () => {
@@ -883,7 +883,7 @@ export function addProject(ctx: CtxInit): Cmd {
                     return discoverWorkspace([file], discoverProjectCommand, {
                         cwd: path.dirname(file.uri.fsPath),
                     });
-                })
+                }),
         );
 
         ctx.addToDiscoveredWorkspaces(workspaces);
@@ -901,14 +901,14 @@ async function showReferencesImpl(
     client: LanguageClient | undefined,
     uri: string,
     position: lc.Position,
-    locations: lc.Location[]
+    locations: lc.Location[],
 ) {
     if (client) {
         await vscode.commands.executeCommand(
             "editor.action.showReferences",
             vscode.Uri.parse(uri),
             client.protocol2CodeConverter.asPosition(position),
-            locations.map(client.protocol2CodeConverter.asLocation)
+            locations.map(client.protocol2CodeConverter.asLocation),
         );
     }
 }
@@ -925,7 +925,7 @@ export function applyActionGroup(_ctx: CtxInit): Cmd {
         if (!selectedAction) return;
         await vscode.commands.executeCommand(
             "rust-analyzer.resolveCodeAction",
-            selectedAction.arguments
+            selectedAction.arguments,
         );
     };
 }
@@ -1000,7 +1000,7 @@ export function resolveCodeAction(ctx: CtxInit): Cmd {
             documentChanges: itemEdit.documentChanges?.filter((change) => "kind" in change),
         };
         const fileSystemEdit = await client.protocol2CodeConverter.asWorkspaceEdit(
-            lcFileSystemEdit
+            lcFileSystemEdit,
         );
         await vscode.workspace.applyEdit(fileSystemEdit);
         await applySnippetWorkspaceEdit(edit);
@@ -1053,12 +1053,12 @@ export function peekTests(ctx: CtxInit): Cmd {
                 const locations: lc.Location[] = tests.map((it) =>
                     lc.Location.create(
                         it.runnable.location!.targetUri,
-                        it.runnable.location!.targetSelectionRange
-                    )
+                        it.runnable.location!.targetSelectionRange,
+                    ),
                 );
 
                 await showReferencesImpl(client, uri, position, locations);
-            }
+            },
         );
     };
 }
@@ -1146,7 +1146,7 @@ export function viewMemoryLayout(ctx: CtxInit): Cmd {
             "memory_layout",
             "[Memory Layout]",
             vscode.ViewColumn.Two,
-            { enableScripts: true }
+            { enableScripts: true },
         );
 
         document.webview.html = `<!DOCTYPE html>
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 7dbc4bdd47b..a047f9659a9 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -38,7 +38,7 @@ export class Config {
         vscode.workspace.onDidChangeConfiguration(
             this.onDidChangeConfiguration,
             this,
-            ctx.subscriptions
+            ctx.subscriptions,
         );
         this.refreshLogging();
         this.configureLanguage();
@@ -64,7 +64,7 @@ export class Config {
         this.configureLanguage();
 
         const requiresReloadOpt = this.requiresReloadOpts.find((opt) =>
-            event.affectsConfiguration(opt)
+            event.affectsConfiguration(opt),
         );
 
         if (!requiresReloadOpt) return;
@@ -210,8 +210,8 @@ export class Config {
                 Object.entries(extraEnv).map(([k, v]) => [
                     k,
                     typeof v !== "string" ? v.toString() : v,
-                ])
-            )
+                ]),
+            ),
         );
     }
     get traceExtension() {
@@ -306,7 +306,7 @@ export class Config {
 // to interact with.
 export function prepareVSCodeConfig<T>(
     resp: T,
-    cb?: (key: Extract<keyof T, string>, res: { [key: string]: any }) => void
+    cb?: (key: Extract<keyof T, string>, res: { [key: string]: any }) => void,
 ): T {
     if (Is.string(resp)) {
         return substituteVSCodeVariableInString(resp) as T;
@@ -349,7 +349,7 @@ export function substituteVariablesInEnv(env: Env): Env {
                 }
             }
             return [`env:${key}`, { deps: [...deps], value }];
-        })
+        }),
     );
 
     const resolved = new Set<string>();
@@ -457,7 +457,7 @@ function computeVscodeVar(varName: string): string | null {
     if (varName in supportedVariables) {
         const fn = expectNotUndefined(
             supportedVariables[varName],
-            `${varName} should not be undefined here`
+            `${varName} should not be undefined here`,
         );
         return fn();
     } else {
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 1ae0c96c6e7..ac144cbebb2 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -42,10 +42,10 @@ export type Workspace =
 
 export function fetchWorkspace(): Workspace {
     const folders = (vscode.workspace.workspaceFolders || []).filter(
-        (folder) => folder.uri.scheme === "file"
+        (folder) => folder.uri.scheme === "file",
     );
     const rustDocuments = vscode.workspace.textDocuments.filter((document) =>
-        isRustDocument(document)
+        isRustDocument(document),
     );
 
     return folders.length === 0
@@ -61,7 +61,7 @@ export function fetchWorkspace(): Workspace {
 export async function discoverWorkspace(
     files: readonly vscode.TextDocument[],
     command: string[],
-    options: ExecOptions
+    options: ExecOptions,
 ): Promise<JsonProject> {
     const paths = files.map((f) => `"${f.uri.fsPath}"`).join(" ");
     const joinedCommand = command.join(" ");
@@ -110,7 +110,7 @@ export class Ctx {
     constructor(
         readonly extCtx: vscode.ExtensionContext,
         commandFactories: Record<string, CommandFactory>,
-        workspace: Workspace
+        workspace: Workspace,
     ) {
         extCtx.subscriptions.push(this);
         this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
@@ -186,7 +186,7 @@ export class Ctx {
 
                     log.error("Bootstrap error", err);
                     throw new Error(message);
-                }
+                },
             );
             const newEnv = Object.assign({}, process.env, this.config.serverExtraEnv);
             const run: lc.Executable = {
@@ -216,7 +216,7 @@ export class Ctx {
                             return discoverWorkspace([file], discoverProjectCommand, {
                                 cwd: path.dirname(file.uri.fsPath),
                             });
-                        })
+                        }),
                 );
 
                 this.addToDiscoveredWorkspaces(workspaces);
@@ -230,7 +230,7 @@ export class Ctx {
                     if (key === "linkedProjects" && this.config.discoveredWorkspaces.length > 0) {
                         obj["linkedProjects"] = this.config.discoveredWorkspaces;
                     }
-                }
+                },
             );
 
             this._client = await createClient(
@@ -239,17 +239,17 @@ export class Ctx {
                 initializationOptions,
                 serverOptions,
                 this.config,
-                this.unlinkedFiles
+                this.unlinkedFiles,
             );
             this.pushClientCleanup(
                 this._client.onNotification(ra.serverStatus, (params) =>
-                    this.setServerStatus(params)
-                )
+                    this.setServerStatus(params),
+                ),
             );
             this.pushClientCleanup(
                 this._client.onNotification(ra.openServerLogs, () => {
                     this.outputChannel!.show();
-                })
+                }),
             );
         }
         return this._client;
@@ -395,7 +395,7 @@ export class Ctx {
             } else {
                 callback = () =>
                     vscode.window.showErrorMessage(
-                        `command ${fullName} failed: rust-analyzer server is not running`
+                        `command ${fullName} failed: rust-analyzer server is not running`,
                     );
             }
 
@@ -423,7 +423,7 @@ export class Ctx {
                 }
                 statusBar.color = new vscode.ThemeColor("statusBarItem.warningForeground");
                 statusBar.backgroundColor = new vscode.ThemeColor(
-                    "statusBarItem.warningBackground"
+                    "statusBarItem.warningBackground",
                 );
                 statusBar.command = "rust-analyzer.openLogs";
                 icon = "$(warning) ";
@@ -440,7 +440,7 @@ export class Ctx {
             case "stopped":
                 statusBar.tooltip.appendText("Server is stopped");
                 statusBar.tooltip.appendMarkdown(
-                    "\n\n[Start server](command:rust-analyzer.startServer)"
+                    "\n\n[Start server](command:rust-analyzer.startServer)",
                 );
                 statusBar.color = undefined;
                 statusBar.backgroundColor = undefined;
@@ -453,13 +453,13 @@ export class Ctx {
         }
         statusBar.tooltip.appendMarkdown("\n\n[Open logs](command:rust-analyzer.openLogs)");
         statusBar.tooltip.appendMarkdown(
-            "\n\n[Reload Workspace](command:rust-analyzer.reloadWorkspace)"
+            "\n\n[Reload Workspace](command:rust-analyzer.reloadWorkspace)",
         );
         statusBar.tooltip.appendMarkdown(
-            "\n\n[Rebuild Proc Macros](command:rust-analyzer.rebuildProcMacros)"
+            "\n\n[Rebuild Proc Macros](command:rust-analyzer.rebuildProcMacros)",
         );
         statusBar.tooltip.appendMarkdown(
-            "\n\n[Restart server](command:rust-analyzer.restartServer)"
+            "\n\n[Restart server](command:rust-analyzer.restartServer)",
         );
         statusBar.tooltip.appendMarkdown("\n\n[Stop server](command:rust-analyzer.stopServer)");
         if (!status.quiescent) icon = "$(sync~spin) ";
diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
index 484f547230f..f3d6238d51b 100644
--- a/editors/code/src/debug.ts
+++ b/editors/code/src/debug.ts
@@ -13,7 +13,7 @@ type DebugConfigProvider = (
     config: ra.Runnable,
     executable: string,
     env: Record<string, string>,
-    sourceFileMap?: Record<string, string>
+    sourceFileMap?: Record<string, string>,
 ) => vscode.DebugConfiguration;
 
 export async function makeDebugConfig(ctx: Ctx, runnable: ra.Runnable): Promise<void> {
@@ -31,7 +31,7 @@ export async function makeDebugConfig(ctx: Ctx, runnable: ra.Runnable): Promise<
         const answer = await vscode.window.showErrorMessage(
             `Launch configuration '${debugConfig.name}' already exists!`,
             "Cancel",
-            "Update"
+            "Update",
         );
         if (answer === "Cancel") return;
 
@@ -68,7 +68,7 @@ export async function startDebugSession(ctx: Ctx, runnable: ra.Runnable): Promis
 
 async function getDebugConfiguration(
     ctx: Ctx,
-    runnable: ra.Runnable
+    runnable: ra.Runnable,
 ): Promise<vscode.DebugConfiguration | undefined> {
     const editor = ctx.activeRustEditor;
     if (!editor) return;
@@ -92,7 +92,7 @@ async function getDebugConfiguration(
     if (!debugEngine) {
         await vscode.window.showErrorMessage(
             `Install [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)` +
-                ` or [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) extension for debugging.`
+                ` or [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) extension for debugging.`,
         );
         return;
     }
@@ -157,7 +157,7 @@ async function getDebugConfiguration(
 
 async function getDebugExecutable(
     runnable: ra.Runnable,
-    env: Record<string, string>
+    env: Record<string, string>,
 ): Promise<string> {
     const cargo = new Cargo(runnable.args.workspaceRoot || ".", debugOutput, env);
     const executable = await cargo.executableFromArgs(runnable.args.cargoArgs);
@@ -170,7 +170,7 @@ function getLldbDebugConfig(
     runnable: ra.Runnable,
     executable: string,
     env: Record<string, string>,
-    sourceFileMap?: Record<string, string>
+    sourceFileMap?: Record<string, string>,
 ): vscode.DebugConfiguration {
     return {
         type: "lldb",
@@ -189,7 +189,7 @@ function getCppvsDebugConfig(
     runnable: ra.Runnable,
     executable: string,
     env: Record<string, string>,
-    sourceFileMap?: Record<string, string>
+    sourceFileMap?: Record<string, string>,
 ): vscode.DebugConfiguration {
     return {
         type: os.platform() === "win32" ? "cppvsdbg" : "cppdbg",
diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts
index 98d6d7001a6..863ace07801 100644
--- a/editors/code/src/dependencies_provider.ts
+++ b/editors/code/src/dependencies_provider.ts
@@ -43,7 +43,7 @@ export class RustDependenciesProvider
     }
 
     getParent?(
-        element: Dependency | DependencyFile
+        element: Dependency | DependencyFile,
     ): vscode.ProviderResult<Dependency | DependencyFile> {
         if (element instanceof Dependency) return undefined;
         return element.parent;
@@ -60,7 +60,7 @@ export class RustDependenciesProvider
     }
 
     getChildren(
-        element?: Dependency | DependencyFile
+        element?: Dependency | DependencyFile,
     ): vscode.ProviderResult<Dependency[] | DependencyFile[]> {
         return new Promise((resolve, _reject) => {
             if (!vscode.workspace.workspaceFolders) {
@@ -87,7 +87,7 @@ export class RustDependenciesProvider
     private async getRootDependencies(): Promise<Dependency[]> {
         const dependenciesResult: FetchDependencyListResult = await this.ctx.client.sendRequest(
             ra.fetchDependencyList,
-            {}
+            {},
         );
         const crates = dependenciesResult.crates;
 
@@ -107,7 +107,7 @@ export class RustDependenciesProvider
             moduleName,
             version,
             vscode.Uri.parse(path).fsPath,
-            vscode.TreeItemCollapsibleState.Collapsed
+            vscode.TreeItemCollapsibleState.Collapsed,
         );
     }
 }
@@ -117,7 +117,7 @@ export class Dependency extends vscode.TreeItem {
         public override readonly label: string,
         private version: string,
         readonly dependencyPath: string,
-        public override readonly collapsibleState: vscode.TreeItemCollapsibleState
+        public override readonly collapsibleState: vscode.TreeItemCollapsibleState,
     ) {
         super(label, collapsibleState);
         this.resourceUri = vscode.Uri.file(dependencyPath);
@@ -136,7 +136,7 @@ export class DependencyFile extends vscode.TreeItem {
         override readonly label: string,
         readonly dependencyPath: string,
         readonly parent: Dependency | DependencyFile,
-        public override readonly collapsibleState: vscode.TreeItemCollapsibleState
+        public override readonly collapsibleState: vscode.TreeItemCollapsibleState,
     ) {
         super(vscode.Uri.file(dependencyPath), collapsibleState);
         this.id = this.resourceUri!.fsPath.toLowerCase();
diff --git a/editors/code/src/diagnostics.ts b/editors/code/src/diagnostics.ts
index e573f5a63f5..e31a1cdcef9 100644
--- a/editors/code/src/diagnostics.ts
+++ b/editors/code/src/diagnostics.ts
@@ -89,7 +89,7 @@ export class AnsiDecorationProvider implements vscode.Disposable {
     }
 
     private _getDecorations(
-        uri: vscode.Uri
+        uri: vscode.Uri,
     ): ProviderResult<[TextEditorDecorationType, Range[]][]> {
         const stringContents = getRenderedDiagnostic(this.ctx, uri);
         const lines = stringContents.split("\n");
@@ -117,7 +117,7 @@ export class AnsiDecorationProvider implements vscode.Disposable {
                     lineNumber,
                     offset - totalEscapeLength,
                     lineNumber,
-                    offset + content.length - totalEscapeLength
+                    offset + content.length - totalEscapeLength,
                 );
 
                 offset += content.length;
@@ -183,7 +183,7 @@ export class AnsiDecorationProvider implements vscode.Disposable {
 
     private static _convertColor(
         color?: string,
-        truecolor?: string
+        truecolor?: string,
     ): ThemeColor | string | undefined {
         if (!color) {
             return undefined;
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 5af2cab0ee1..bb7896973f1 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -27,17 +27,17 @@ export type CommandLinkGroup = {
 // rust-analyzer extensions
 
 export const analyzerStatus = new lc.RequestType<AnalyzerStatusParams, string, void>(
-    "rust-analyzer/analyzerStatus"
+    "rust-analyzer/analyzerStatus",
 );
 export const cancelFlycheck = new lc.NotificationType0("rust-analyzer/cancelFlycheck");
 export const clearFlycheck = new lc.NotificationType0("rust-analyzer/clearFlycheck");
 export const expandMacro = new lc.RequestType<ExpandMacroParams, ExpandedMacro | null, void>(
-    "rust-analyzer/expandMacro"
+    "rust-analyzer/expandMacro",
 );
 export const memoryUsage = new lc.RequestType0<string, void>("rust-analyzer/memoryUsage");
 export const openServerLogs = new lc.NotificationType0("rust-analyzer/openServerLogs");
 export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, TestInfo[], void>(
-    "rust-analyzer/relatedTests"
+    "rust-analyzer/relatedTests",
 );
 export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");
 export const rebuildProcMacros = new lc.RequestType0<null, void>("rust-analyzer/rebuildProcMacros");
@@ -47,25 +47,25 @@ export const runFlycheck = new lc.NotificationType<{
 }>("rust-analyzer/runFlycheck");
 export const shuffleCrateGraph = new lc.RequestType0<null, void>("rust-analyzer/shuffleCrateGraph");
 export const syntaxTree = new lc.RequestType<SyntaxTreeParams, string, void>(
-    "rust-analyzer/syntaxTree"
+    "rust-analyzer/syntaxTree",
 );
 export const viewCrateGraph = new lc.RequestType<ViewCrateGraphParams, string, void>(
-    "rust-analyzer/viewCrateGraph"
+    "rust-analyzer/viewCrateGraph",
 );
 export const viewFileText = new lc.RequestType<lc.TextDocumentIdentifier, string, void>(
-    "rust-analyzer/viewFileText"
+    "rust-analyzer/viewFileText",
 );
 export const viewHir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(
-    "rust-analyzer/viewHir"
+    "rust-analyzer/viewHir",
 );
 export const viewMir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(
-    "rust-analyzer/viewMir"
+    "rust-analyzer/viewMir",
 );
 export const interpretFunction = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(
-    "rust-analyzer/interpretFunction"
+    "rust-analyzer/interpretFunction",
 );
 export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>(
-    "rust-analyzer/viewItemTree"
+    "rust-analyzer/viewItemTree",
 );
 
 export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };
@@ -121,22 +121,22 @@ export type ViewItemTreeParams = { textDocument: lc.TextDocumentIdentifier };
 // experimental extensions
 
 export const joinLines = new lc.RequestType<JoinLinesParams, lc.TextEdit[], void>(
-    "experimental/joinLines"
+    "experimental/joinLines",
 );
 export const matchingBrace = new lc.RequestType<MatchingBraceParams, lc.Position[], void>(
-    "experimental/matchingBrace"
+    "experimental/matchingBrace",
 );
 export const moveItem = new lc.RequestType<MoveItemParams, lc.TextEdit[], void>(
-    "experimental/moveItem"
+    "experimental/moveItem",
 );
 export const onEnter = new lc.RequestType<lc.TextDocumentPositionParams, lc.TextEdit[], void>(
-    "experimental/onEnter"
+    "experimental/onEnter",
 );
 export const openCargoToml = new lc.RequestType<OpenCargoTomlParams, lc.Location, void>(
-    "experimental/openCargoToml"
+    "experimental/openCargoToml",
 );
 export const openDocs = new lc.RequestType<lc.TextDocumentPositionParams, string | void, void>(
-    "experimental/externalDocs"
+    "experimental/externalDocs",
 );
 export const parentModule = new lc.RequestType<
     lc.TextDocumentPositionParams,
@@ -144,10 +144,10 @@ export const parentModule = new lc.RequestType<
     void
 >("experimental/parentModule");
 export const runnables = new lc.RequestType<RunnablesParams, Runnable[], void>(
-    "experimental/runnables"
+    "experimental/runnables",
 );
 export const serverStatus = new lc.NotificationType<ServerStatusParams>(
-    "experimental/serverStatus"
+    "experimental/serverStatus",
 );
 export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>("experimental/ssr");
 export const viewRecursiveMemoryLayout = new lc.RequestType<
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 1121951c07f..448150bac06 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -18,7 +18,7 @@ export async function deactivate() {
 }
 
 export async function activate(
-    context: vscode.ExtensionContext
+    context: vscode.ExtensionContext,
 ): Promise<RustAnalyzerExtensionApi> {
     if (vscode.extensions.getExtension("rust-lang.rust")) {
         vscode.window
@@ -26,7 +26,7 @@ export async function activate(
                 `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.",
-                "Got it"
+                "Got it",
             )
             .then(() => {}, console.error);
     }
@@ -36,7 +36,7 @@ export async function activate(
     // so we do it ourselves.
     const api = await activateServer(ctx).catch((err) => {
         void vscode.window.showErrorMessage(
-            `Cannot activate rust-analyzer extension: ${err.message}`
+            `Cannot activate rust-analyzer extension: ${err.message}`,
         );
         throw err;
     });
@@ -53,8 +53,8 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
     ctx.pushExtCleanup(
         vscode.workspace.registerTextDocumentContentProvider(
             diagnostics.URI_SCHEME,
-            diagnosticProvider
-        )
+            diagnosticProvider,
+        ),
     );
 
     const decorationProvider = new diagnostics.AnsiDecorationProvider(ctx);
@@ -71,7 +71,7 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
     vscode.workspace.onDidChangeTextDocument(
         async (event) => await decorateVisibleEditors(event.document),
         null,
-        ctx.subscriptions
+        ctx.subscriptions,
     );
     vscode.workspace.onDidOpenTextDocument(decorateVisibleEditors, null, ctx.subscriptions);
     vscode.window.onDidChangeActiveTextEditor(
@@ -82,7 +82,7 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
             }
         },
         null,
-        ctx.subscriptions
+        ctx.subscriptions,
     );
     vscode.window.onDidChangeVisibleTextEditors(
         async (visibleEditors) => {
@@ -92,13 +92,13 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
             }
         },
         null,
-        ctx.subscriptions
+        ctx.subscriptions,
     );
 
     vscode.workspace.onDidChangeWorkspaceFolders(
         async (_) => ctx.onWorkspaceFolderChanges(),
         null,
-        ctx.subscriptions
+        ctx.subscriptions,
     );
     vscode.workspace.onDidChangeConfiguration(
         async (_) => {
@@ -107,7 +107,7 @@ async function activateServer(ctx: Ctx): Promise<RustAnalyzerExtensionApi> {
             });
         },
         null,
-        ctx.subscriptions
+        ctx.subscriptions,
     );
 
     await ctx.start();
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index 8ec569b6036..c893d390554 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -16,7 +16,7 @@ export async function selectRunnable(
     ctx: CtxInit,
     prevRunnable?: RunnableQuickPick,
     debuggeeOnly = false,
-    showButtons: boolean = true
+    showButtons: boolean = true,
 ): Promise<RunnableQuickPick | undefined> {
     const editor = ctx.activeRustEditor;
     if (!editor) return;
@@ -84,7 +84,7 @@ export async function selectRunnable(
                     }
                 }
             }),
-            quickPick
+            quickPick,
         );
         quickPick.show();
     });
@@ -103,7 +103,7 @@ export class RunnableQuickPick implements vscode.QuickPickItem {
 
 export function prepareEnv(
     runnable: ra.Runnable,
-    runnableEnvCfg: RunnableEnvCfg
+    runnableEnvCfg: RunnableEnvCfg,
 ): Record<string, string> {
     const env: Record<string, string> = { RUST_BACKTRACE: "short" };
 
@@ -156,7 +156,7 @@ export async function createTask(runnable: ra.Runnable, config: Config): Promise
         args,
         config.problemMatcher,
         config.cargoRunner,
-        true
+        true,
     );
 
     cargoTask.presentationOptions.clear = true;
diff --git a/editors/code/src/snippets.ts b/editors/code/src/snippets.ts
index 1ad93d280ba..d81765649ff 100644
--- a/editors/code/src/snippets.ts
+++ b/editors/code/src/snippets.ts
@@ -17,7 +17,9 @@ export async function applySnippetWorkspaceEdit(edit: vscode.WorkspaceEdit) {
                 for (const indel of edits) {
                     assert(
                         !parseSnippet(indel.newText),
-                        `bad ws edit: snippet received with multiple edits: ${JSON.stringify(edit)}`
+                        `bad ws edit: snippet received with multiple edits: ${JSON.stringify(
+                            edit,
+                        )}`,
                     );
                     builder.replace(indel.range, indel.newText);
                 }
@@ -32,7 +34,7 @@ async function editorFromUri(uri: vscode.Uri): Promise<vscode.TextEditor | undef
         await vscode.window.showTextDocument(uri, {});
     }
     return vscode.window.visibleTextEditors.find(
-        (it) => it.document.uri.toString() === uri.toString()
+        (it) => it.document.uri.toString() === uri.toString(),
     );
 }
 
@@ -56,8 +58,8 @@ export async function applySnippetTextEdits(editor: vscode.TextEditor, edits: vs
                 selections.push(
                     new vscode.Selection(
                         new vscode.Position(startLine, startColumn),
-                        new vscode.Position(startLine, endColumn)
-                    )
+                        new vscode.Position(startLine, endColumn),
+                    ),
                 );
                 builder.replace(indel.range, newText);
             } else {
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index f451e738d5d..1d5ab82aa04 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -48,7 +48,7 @@ class CargoTaskProvider implements vscode.TaskProvider {
                     `cargo ${def.command}`,
                     [def.command],
                     this.config.problemMatcher,
-                    this.config.cargoRunner
+                    this.config.cargoRunner,
                 );
                 vscodeTask.group = def.group;
                 tasks.push(vscodeTask);
@@ -73,7 +73,7 @@ class CargoTaskProvider implements vscode.TaskProvider {
                 task.name,
                 args,
                 this.config.problemMatcher,
-                this.config.cargoRunner
+                this.config.cargoRunner,
             );
         }
 
@@ -88,7 +88,7 @@ export async function buildCargoTask(
     args: string[],
     problemMatcher: string[],
     customRunner?: string,
-    throwOnError: boolean = false
+    throwOnError: boolean = false,
 ): Promise<vscode.Task> {
     let exec: vscode.ProcessExecution | vscode.ShellExecution | undefined = undefined;
 
@@ -133,7 +133,7 @@ export async function buildCargoTask(
         name,
         TASK_SOURCE,
         exec,
-        problemMatcher
+        problemMatcher,
     );
 }
 
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 014e6b66f64..58e5fc747a1 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -23,7 +23,7 @@ export class Cargo {
     constructor(
         readonly rootFolder: string,
         readonly output: vscode.OutputChannel,
-        readonly env: Record<string, string>
+        readonly env: Record<string, string>,
     ) {}
 
     // Made public for testing purposes
@@ -76,7 +76,7 @@ export class Cargo {
                         this.output.append(message.message.rendered);
                     }
                 },
-                (stderr) => this.output.append(stderr)
+                (stderr) => this.output.append(stderr),
             );
         } catch (err) {
             this.output.show(true);
@@ -102,7 +102,7 @@ export class Cargo {
     private async runCargo(
         cargoArgs: string[],
         onStdoutJson: (obj: any) => void,
-        onStderrString: (data: string) => void
+        onStderrString: (data: string) => void,
     ): Promise<number> {
         const path = await cargoPath();
         return await new Promise((resolve, reject) => {
@@ -172,7 +172,7 @@ export const getPathForExecutable = memoizeAsync(
             if (await isFileAtUri(standardPath)) return standardPath.fsPath;
         }
         return executableName;
-    }
+    },
 );
 
 async function lookupInPath(exec: string): Promise<boolean> {
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 64f4582770b..38ce6761578 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -114,7 +114,7 @@ export function setContextValue(key: string, value: any): Thenable<void> {
  * underlying async function.
  */
 export function memoizeAsync<Ret, TThis, Param extends string>(
-    func: (this: TThis, arg: Param) => Promise<Ret>
+    func: (this: TThis, arg: Param) => Promise<Ret>,
 ) {
     const cache = new Map<string, Ret>();
 
diff --git a/editors/code/tests/unit/index.ts b/editors/code/tests/unit/index.ts
index c231927bb00..8ad46546abd 100644
--- a/editors/code/tests/unit/index.ts
+++ b/editors/code/tests/unit/index.ts
@@ -63,7 +63,7 @@ export async function run(): Promise<void> {
     const context = new Context();
 
     const testFiles = (await readdir(path.resolve(__dirname))).filter((name) =>
-        name.endsWith(".test.js")
+        name.endsWith(".test.js"),
     );
     for (const testFile of testFiles) {
         try {
-- 
cgit 1.4.1-3-g733a5