diff --git a/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml b/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml
index 9cc18fc69ede6..0cc7ce77ddb64 100644
--- a/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml
@@ -24,7 +24,7 @@ jobs:
       run: rustup update --no-self-update stable
 
     - name: Build Documentation
-      run: cargo doc --all --no-deps
+      run: cargo doc --all --no-deps --document-private-items
 
     - name: Deploy Docs
       uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 42eaeb01f1f2a..d6c6250e13dc7 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1864,6 +1864,7 @@ dependencies = [
  "intern",
  "libc",
  "libloading",
+ "line-index 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "memmap2",
  "object",
  "paths",
@@ -1878,9 +1879,15 @@ name = "proc-macro-srv-cli"
 version = "0.0.0"
 dependencies = [
  "clap",
+ "expect-test",
+ "intern",
+ "paths",
  "postcard",
  "proc-macro-api",
  "proc-macro-srv",
+ "proc-macro-test",
+ "span",
+ "tt",
 ]
 
 [[package]]
@@ -2628,7 +2635,7 @@ dependencies = [
 
 [[package]]
 name = "smol_str"
-version = "0.3.4"
+version = "0.3.5"
 dependencies = [
  "arbitrary",
  "borsh",
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/attrs.rs b/src/tools/rust-analyzer/crates/hir-def/src/attrs.rs
index 83df11f2d2a45..0b8f65687218c 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/attrs.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/attrs.rs
@@ -135,6 +135,7 @@ fn match_attr_flags(attr_flags: &mut AttrFlags, attr: Meta) -> ControlFlow<Infal
     match attr {
         Meta::NamedKeyValue { name: Some(name), value, .. } => match name.text() {
             "deprecated" => attr_flags.insert(AttrFlags::IS_DEPRECATED),
+            "ignore" => attr_flags.insert(AttrFlags::IS_IGNORE),
             "lang" => attr_flags.insert(AttrFlags::LANG_ITEM),
             "path" => attr_flags.insert(AttrFlags::HAS_PATH),
             "unstable" => attr_flags.insert(AttrFlags::IS_UNSTABLE),
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/builtin_derive.rs b/src/tools/rust-analyzer/crates/hir-def/src/builtin_derive.rs
index 32385516ab583..946f08ec3682e 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/builtin_derive.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/builtin_derive.rs
@@ -8,7 +8,8 @@ use intern::{Symbol, sym};
 use tt::TextRange;
 
 use crate::{
-    AdtId, BuiltinDeriveImplId, BuiltinDeriveImplLoc, FunctionId, HasModule, db::DefDatabase,
+    AdtId, BuiltinDeriveImplId, BuiltinDeriveImplLoc, FunctionId, HasModule, MacroId,
+    db::DefDatabase, lang_item::LangItems,
 };
 
 macro_rules! declare_enum {
@@ -86,6 +87,25 @@ declare_enum!(
     DispatchFromDyn => [],
 );
 
+impl BuiltinDeriveImplTrait {
+    pub fn derive_macro(self, lang_items: &LangItems) -> Option<MacroId> {
+        match self {
+            BuiltinDeriveImplTrait::Copy => lang_items.CopyDerive,
+            BuiltinDeriveImplTrait::Clone => lang_items.CloneDerive,
+            BuiltinDeriveImplTrait::Default => lang_items.DefaultDerive,
+            BuiltinDeriveImplTrait::Debug => lang_items.DebugDerive,
+            BuiltinDeriveImplTrait::Hash => lang_items.HashDerive,
+            BuiltinDeriveImplTrait::Ord => lang_items.OrdDerive,
+            BuiltinDeriveImplTrait::PartialOrd => lang_items.PartialOrdDerive,
+            BuiltinDeriveImplTrait::Eq => lang_items.EqDerive,
+            BuiltinDeriveImplTrait::PartialEq => lang_items.PartialEqDerive,
+            BuiltinDeriveImplTrait::CoerceUnsized | BuiltinDeriveImplTrait::DispatchFromDyn => {
+                lang_items.CoercePointeeDerive
+            }
+        }
+    }
+}
+
 impl BuiltinDeriveImplMethod {
     pub fn trait_method(
         self,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs b/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs
index 7d3a94b038330..4308d0ef1c296 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs
@@ -27,14 +27,15 @@
 pub mod keys {
     use std::marker::PhantomData;
 
+    use either::Either;
     use hir_expand::{MacroCallId, attrs::AttrId};
     use rustc_hash::FxHashMap;
     use syntax::{AstNode, AstPtr, ast};
 
     use crate::{
-        BlockId, ConstId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId, FieldId, FunctionId,
-        ImplId, LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, StructId, TraitId,
-        TypeAliasId, TypeOrConstParamId, UnionId, UseId,
+        BlockId, BuiltinDeriveImplId, ConstId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId,
+        FieldId, FunctionId, ImplId, LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId,
+        StaticId, StructId, TraitId, TypeAliasId, TypeOrConstParamId, UnionId, UseId,
         dyn_map::{DynMap, Policy},
     };
 
@@ -71,7 +72,8 @@ pub mod keys {
         (
             AttrId,
             /* derive() */ MacroCallId,
-            /* actual derive macros */ Box<[Option<MacroCallId>]>,
+            /* actual derive macros */
+            Box<[Option<Either<MacroCallId, BuiltinDeriveImplId>>]>,
         ),
     > = Key::new();
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
index a3278dd76c868..9e1efb9777869 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
@@ -4,6 +4,7 @@
 use std::{fmt, sync::LazyLock};
 
 use base_db::Crate;
+use either::Either;
 use hir_expand::{AstId, MacroCallId, attrs::AttrId, name::Name};
 use indexmap::map::Entry;
 use itertools::Itertools;
@@ -199,7 +200,7 @@ struct DeriveMacroInvocation {
     attr_id: AttrId,
     /// The `#[derive]` call
     attr_call_id: MacroCallId,
-    derive_call_ids: SmallVec<[Option<MacroCallId>; 4]>,
+    derive_call_ids: SmallVec<[Option<Either<MacroCallId, BuiltinDeriveImplId>>; 4]>,
 }
 
 pub(crate) static BUILTIN_SCOPE: LazyLock<FxIndexMap<Name, PerNs>> = LazyLock::new(|| {
@@ -345,7 +346,9 @@ impl ItemScope {
     pub fn all_macro_calls(&self) -> impl Iterator<Item = MacroCallId> + '_ {
         self.macro_invocations.values().copied().chain(self.attr_macros.values().copied()).chain(
             self.derive_macros.values().flat_map(|it| {
-                it.iter().flat_map(|it| it.derive_call_ids.iter().copied().flatten())
+                it.iter().flat_map(|it| {
+                    it.derive_call_ids.iter().copied().flatten().flat_map(|it| it.left())
+                })
             }),
         )
     }
@@ -379,6 +382,10 @@ impl ItemScope {
         self.types.get(name).map(|item| (item.def, item.vis))
     }
 
+    pub(crate) fn makro(&self, name: &Name) -> Option<MacroId> {
+        self.macros.get(name).map(|item| item.def)
+    }
+
     /// XXX: this is O(N) rather than O(1), try to not introduce new usages.
     pub(crate) fn name_of(&self, item: ItemInNs) -> Option<(&Name, Visibility, /*declared*/ bool)> {
         match item {
@@ -519,7 +526,7 @@ impl ItemScope {
     pub(crate) fn set_derive_macro_invoc(
         &mut self,
         adt: AstId<ast::Adt>,
-        call: MacroCallId,
+        call: Either<MacroCallId, BuiltinDeriveImplId>,
         id: AttrId,
         idx: usize,
     ) {
@@ -539,7 +546,7 @@ impl ItemScope {
         adt: AstId<ast::Adt>,
         attr_id: AttrId,
         attr_call_id: MacroCallId,
-        mut derive_call_ids: SmallVec<[Option<MacroCallId>; 4]>,
+        mut derive_call_ids: SmallVec<[Option<Either<MacroCallId, BuiltinDeriveImplId>>; 4]>,
     ) {
         derive_call_ids.shrink_to_fit();
         self.derive_macros.entry(adt).or_default().push(DeriveMacroInvocation {
@@ -554,7 +561,9 @@ impl ItemScope {
     ) -> impl Iterator<
         Item = (
             AstId<ast::Adt>,
-            impl Iterator<Item = (AttrId, MacroCallId, &[Option<MacroCallId>])>,
+            impl Iterator<
+                Item = (AttrId, MacroCallId, &[Option<Either<MacroCallId, BuiltinDeriveImplId>>]),
+            >,
         ),
     > + '_ {
         self.derive_macros.iter().map(|(k, v)| {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
index eba4d87ec9f8a..092ff6e486717 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
@@ -7,8 +7,8 @@ use intern::{Symbol, sym};
 use stdx::impl_from;
 
 use crate::{
-    AdtId, AssocItemId, AttrDefId, Crate, EnumId, EnumVariantId, FunctionId, ImplId, ModuleDefId,
-    StaticId, StructId, TraitId, TypeAliasId, UnionId,
+    AdtId, AssocItemId, AttrDefId, Crate, EnumId, EnumVariantId, FunctionId, ImplId, MacroId,
+    ModuleDefId, StaticId, StructId, TraitId, TypeAliasId, UnionId,
     attrs::AttrFlags,
     db::DefDatabase,
     nameres::{DefMap, assoc::TraitItems, crate_def_map, crate_local_def_map},
@@ -99,7 +99,7 @@ pub fn crate_lang_items(db: &dyn DefDatabase, krate: Crate) -> Option<Box<LangIt
     }
 
     if matches!(krate.data(db).origin, base_db::CrateOrigin::Lang(base_db::LangCrateOrigin::Core)) {
-        lang_items.fill_non_lang_core_traits(db, crate_def_map);
+        lang_items.fill_non_lang_core_items(db, crate_def_map);
     }
 
     if lang_items.is_empty() { None } else { Some(Box::new(lang_items)) }
@@ -169,6 +169,27 @@ fn resolve_core_trait(
     Some(trait_)
 }
 
+fn resolve_core_macro(
+    db: &dyn DefDatabase,
+    core_def_map: &DefMap,
+    modules: &[Symbol],
+    name: Symbol,
+) -> Option<MacroId> {
+    let mut current = &core_def_map[core_def_map.root];
+    for module in modules {
+        let Some((ModuleDefId::ModuleId(cur), _)) =
+            current.scope.type_(&Name::new_symbol_root(module.clone()))
+        else {
+            return None;
+        };
+        if cur.krate(db) != core_def_map.krate() || cur.block(db) != core_def_map.block_id() {
+            return None;
+        }
+        current = &core_def_map[cur];
+    }
+    current.scope.makro(&Name::new_symbol_root(name))
+}
+
 #[salsa::tracked(returns(as_deref))]
 pub(crate) fn crate_notable_traits(db: &dyn DefDatabase, krate: Crate) -> Option<Box<[TraitId]>> {
     let mut traits = Vec::new();
@@ -195,7 +216,11 @@ macro_rules! language_item_table {
 
         @non_lang_core_traits:
 
-        $( core::$($non_lang_module:ident)::*, $non_lang_trait:ident; )*
+        $( core::$($non_lang_trait_module:ident)::*, $non_lang_trait:ident; )*
+
+        @non_lang_core_macros:
+
+        $( core::$($non_lang_macro_module:ident)::*, $non_lang_macro:ident, $non_lang_macro_field:ident; )*
     ) => {
         #[allow(non_snake_case)] // FIXME: Should we remove this?
         #[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
@@ -207,6 +232,9 @@ macro_rules! language_item_table {
             $(
                 pub $non_lang_trait: Option<TraitId>,
             )*
+            $(
+                pub $non_lang_macro_field: Option<MacroId>,
+            )*
         }
 
         impl LangItems {
@@ -218,6 +246,7 @@ macro_rules! language_item_table {
             fn merge_prefer_self(&mut self, other: &Self) {
                 $( self.$lang_item = self.$lang_item.or(other.$lang_item); )*
                 $( self.$non_lang_trait = self.$non_lang_trait.or(other.$non_lang_trait); )*
+                $( self.$non_lang_macro_field = self.$non_lang_macro_field.or(other.$non_lang_macro_field); )*
             }
 
             fn assign_lang_item(&mut self, name: Symbol, target: LangItemTarget) {
@@ -233,8 +262,9 @@ macro_rules! language_item_table {
                 }
             }
 
-            fn fill_non_lang_core_traits(&mut self, db: &dyn DefDatabase, core_def_map: &DefMap) {
-                $( self.$non_lang_trait = resolve_core_trait(db, core_def_map, &[ $(sym::$non_lang_module),* ], sym::$non_lang_trait); )*
+            fn fill_non_lang_core_items(&mut self, db: &dyn DefDatabase, core_def_map: &DefMap) {
+                $( self.$non_lang_trait = resolve_core_trait(db, core_def_map, &[ $(sym::$non_lang_trait_module),* ], sym::$non_lang_trait); )*
+                $( self.$non_lang_macro_field = resolve_core_macro(db, core_def_map, &[ $(sym::$non_lang_macro_module),* ], sym::$non_lang_macro); )*
             }
         }
 
@@ -479,4 +509,16 @@ language_item_table! { LangItems =>
     core::hash, Hash;
     core::cmp, Ord;
     core::cmp, Eq;
+
+    @non_lang_core_macros:
+    core::default, Default, DefaultDerive;
+    core::fmt, Debug, DebugDerive;
+    core::hash, Hash, HashDerive;
+    core::cmp, PartialOrd, PartialOrdDerive;
+    core::cmp, Ord, OrdDerive;
+    core::cmp, PartialEq, PartialEqDerive;
+    core::cmp, Eq, EqDerive;
+    core::marker, CoercePointee, CoercePointeeDerive;
+    core::marker, Copy, CopyDerive;
+    core::clone, Clone, CloneDerive;
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
index 5f05cdb1e2ba2..1e3ea50c5a0f3 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
@@ -61,6 +61,7 @@ mod tests;
 use std::ops::{Deref, DerefMut, Index, IndexMut};
 
 use base_db::Crate;
+use either::Either;
 use hir_expand::{
     EditionedFileId, ErasedAstId, HirFileId, InFile, MacroCallId, mod_path::ModPath, name::Name,
     proc_macro::ProcMacroKind,
@@ -75,8 +76,8 @@ use triomphe::Arc;
 use tt::TextRange;
 
 use crate::{
-    AstId, BlockId, BlockLoc, ExternCrateId, FunctionId, FxIndexMap, Lookup, MacroCallStyles,
-    MacroExpander, MacroId, ModuleId, ModuleIdLt, ProcMacroId, UseId,
+    AstId, BlockId, BlockLoc, BuiltinDeriveImplId, ExternCrateId, FunctionId, FxIndexMap, Lookup,
+    MacroCallStyles, MacroExpander, MacroId, ModuleId, ModuleIdLt, ProcMacroId, UseId,
     db::DefDatabase,
     item_scope::{BuiltinShadowMode, ItemScope},
     item_tree::TreeId,
@@ -192,7 +193,8 @@ pub struct DefMap {
     /// Tracks which custom derives are in scope for an item, to allow resolution of derive helper
     /// attributes.
     // FIXME: Figure out a better way for the IDE layer to resolve these?
-    derive_helpers_in_scope: FxHashMap<AstId<ast::Item>, Vec<(Name, MacroId, MacroCallId)>>,
+    derive_helpers_in_scope:
+        FxHashMap<AstId<ast::Item>, Vec<(Name, MacroId, Either<MacroCallId, BuiltinDeriveImplId>)>>,
     /// A mapping from [`hir_expand::MacroDefId`] to [`crate::MacroId`].
     pub macro_def_to_macro_id: FxHashMap<ErasedAstId, MacroId>,
 
@@ -214,7 +216,7 @@ struct DefMapCrateData {
     registered_tools: Vec<Symbol>,
     /// Unstable features of Rust enabled with `#![feature(A, B)]`.
     unstable_features: FxHashSet<Symbol>,
-    /// #[rustc_coherence_is_core]
+    /// `#[rustc_coherence_is_core]`
     rustc_coherence_is_core: bool,
     no_core: bool,
     no_std: bool,
@@ -540,7 +542,7 @@ impl DefMap {
     pub fn derive_helpers_in_scope(
         &self,
         id: AstId<ast::Adt>,
-    ) -> Option<&[(Name, MacroId, MacroCallId)]> {
+    ) -> Option<&[(Name, MacroId, Either<MacroCallId, BuiltinDeriveImplId>)]> {
         self.derive_helpers_in_scope.get(&id.map(|it| it.upcast())).map(Deref::deref)
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
index 87ade0651762f..323060f61d155 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
@@ -3,7 +3,7 @@
 //! `DefCollector::collect` contains the fixed-point iteration loop which
 //! resolves imports and expands macros.
 
-use std::{iter, mem};
+use std::{iter, mem, ops::Range};
 
 use base_db::{BuiltDependency, Crate, CrateOrigin, LangCrateOrigin};
 use cfg::{CfgAtom, CfgExpr, CfgOptions};
@@ -226,6 +226,7 @@ struct DeferredBuiltinDerive {
     container: ItemContainerId,
     derive_attr_id: AttrId,
     derive_index: u32,
+    helpers_range: Range<usize>,
 }
 
 /// Walks the tree of module recursively
@@ -1354,7 +1355,7 @@ impl<'db> DefCollector<'db> {
                     if let Ok((macro_id, def_id, call_id)) = id {
                         self.def_map.modules[directive.module_id].scope.set_derive_macro_invoc(
                             ast_id.ast_id,
-                            call_id,
+                            Either::Left(call_id),
                             *derive_attr,
                             *derive_pos,
                         );
@@ -1369,7 +1370,7 @@ impl<'db> DefCollector<'db> {
                                     .extend(izip!(
                                         helpers.iter().cloned(),
                                         iter::repeat(macro_id),
-                                        iter::repeat(call_id),
+                                        iter::repeat(Either::Left(call_id)),
                                     ));
                             }
                         }
@@ -1492,6 +1493,8 @@ impl<'db> DefCollector<'db> {
                                         Interned::new(path),
                                     );
 
+                                    derive_call_ids.push(None);
+
                                     // Try to resolve the derive immediately. If we succeed, we can also use the fast path
                                     // for builtin derives. If not, we cannot use it, as it can cause the ADT to become
                                     // interned while the derive is still unresolved, which will cause it to get forgotten.
@@ -1506,23 +1509,42 @@ impl<'db> DefCollector<'db> {
                                         call_id,
                                     );
 
+                                    let ast_id_without_path = ast_id.ast_id;
+                                    let directive = MacroDirective {
+                                        module_id: directive.module_id,
+                                        depth: directive.depth + 1,
+                                        kind: MacroDirectiveKind::Derive {
+                                            ast_id,
+                                            derive_attr: *attr_id,
+                                            derive_pos: idx,
+                                            ctxt: call_site.ctx,
+                                            derive_macro_id: call_id,
+                                        },
+                                        container: directive.container,
+                                    };
+
                                     if let Ok((macro_id, def_id, call_id)) = id {
-                                        derive_call_ids.push(Some(call_id));
+                                        let (mut helpers_start, mut helpers_end) = (0, 0);
                                         // Record its helper attributes.
                                         if def_id.krate != self.def_map.krate {
                                             let def_map = crate_def_map(self.db, def_id.krate);
                                             if let Some(helpers) =
                                                 def_map.data.exported_derives.get(&macro_id)
                                             {
-                                                self.def_map
+                                                let derive_helpers = self
+                                                    .def_map
                                                     .derive_helpers_in_scope
-                                                    .entry(ast_id.ast_id.map(|it| it.upcast()))
-                                                    .or_default()
-                                                    .extend(izip!(
-                                                        helpers.iter().cloned(),
-                                                        iter::repeat(macro_id),
-                                                        iter::repeat(call_id),
-                                                    ));
+                                                    .entry(
+                                                        ast_id_without_path.map(|it| it.upcast()),
+                                                    )
+                                                    .or_default();
+                                                helpers_start = derive_helpers.len();
+                                                derive_helpers.extend(izip!(
+                                                    helpers.iter().cloned(),
+                                                    iter::repeat(macro_id),
+                                                    iter::repeat(Either::Left(call_id)),
+                                                ));
+                                                helpers_end = derive_helpers.len();
                                             }
                                         }
 
@@ -1531,7 +1553,7 @@ impl<'db> DefCollector<'db> {
                                                 def_id.kind
                                         {
                                             self.deferred_builtin_derives
-                                                .entry(ast_id.ast_id.upcast())
+                                                .entry(ast_id_without_path.upcast())
                                                 .or_default()
                                                 .push(DeferredBuiltinDerive {
                                                     call_id,
@@ -1541,24 +1563,15 @@ impl<'db> DefCollector<'db> {
                                                     depth: directive.depth,
                                                     derive_attr_id: *attr_id,
                                                     derive_index: idx as u32,
+                                                    helpers_range: helpers_start..helpers_end,
                                                 });
                                         } else {
-                                            push_resolved(&mut resolved, directive, call_id);
+                                            push_resolved(&mut resolved, &directive, call_id);
+                                            *derive_call_ids.last_mut().unwrap() =
+                                                Some(Either::Left(call_id));
                                         }
                                     } else {
-                                        derive_call_ids.push(None);
-                                        self.unresolved_macros.push(MacroDirective {
-                                            module_id: directive.module_id,
-                                            depth: directive.depth + 1,
-                                            kind: MacroDirectiveKind::Derive {
-                                                ast_id,
-                                                derive_attr: *attr_id,
-                                                derive_pos: idx,
-                                                ctxt: call_site.ctx,
-                                                derive_macro_id: call_id,
-                                            },
-                                            container: directive.container,
-                                        });
+                                        self.unresolved_macros.push(directive);
                                     }
                                 }
 
@@ -1858,9 +1871,8 @@ impl ModCollector<'_, '_> {
              ast_id: FileAstId<ast::Adt>,
              id: AdtId,
              def_map: &mut DefMap| {
-                let Some(deferred_derives) =
-                    deferred_derives.remove(&InFile::new(file_id, ast_id.upcast()))
-                else {
+                let ast_id = InFile::new(file_id, ast_id.upcast());
+                let Some(deferred_derives) = deferred_derives.remove(&ast_id.upcast()) else {
                     return;
                 };
                 let module = &mut def_map.modules[module_id];
@@ -1876,6 +1888,22 @@ impl ModCollector<'_, '_> {
                             },
                         );
                         module.scope.define_builtin_derive_impl(impl_id);
+                        module.scope.set_derive_macro_invoc(
+                            ast_id,
+                            Either::Right(impl_id),
+                            deferred_derive.derive_attr_id,
+                            deferred_derive.derive_index as usize,
+                        );
+                        // Change its helper attributes to the new id.
+                        if let Some(derive_helpers) =
+                            def_map.derive_helpers_in_scope.get_mut(&ast_id.map(|it| it.upcast()))
+                        {
+                            for (_, _, call_id) in
+                                &mut derive_helpers[deferred_derive.helpers_range.clone()]
+                            {
+                                *call_id = Either::Right(impl_id);
+                            }
+                        }
                     });
                 }
             };
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/attr_macro.rs b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/attr_macro.rs
index 06b9b5418e372..c94663ca0cbcb 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/attr_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/attr_macro.rs
@@ -115,7 +115,7 @@ fn dummy_gate_test_expand(
 /// wasting a lot of memory, and it would also require some way to use a path in a way that makes it
 /// always resolve as a derive without nameres recollecting them.
 /// So this hacky approach is a lot more friendly for us, though it does require a bit of support in
-/// [`hir::Semantics`] to make this work.
+/// hir::Semantics to make this work.
 fn derive_expand(
     db: &dyn ExpandDatabase,
     id: MacroCallId,
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/cfg_process.rs b/src/tools/rust-analyzer/crates/hir-expand/src/cfg_process.rs
index a0de36548e9f0..ccef9168ac3a2 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/cfg_process.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/cfg_process.rs
@@ -1,4 +1,4 @@
-//! Processes out #[cfg] and #[cfg_attr] attributes from the input for the derive macro
+//! Processes out `#[cfg]` and `#[cfg_attr]` attributes from the input for the derive macro
 use std::{cell::OnceCell, ops::ControlFlow};
 
 use ::tt::TextRange;
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/declarative.rs b/src/tools/rust-analyzer/crates/hir-expand/src/declarative.rs
index d10e122a5deb2..1726412275991 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/declarative.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/declarative.rs
@@ -101,7 +101,9 @@ impl DeclarativeMacroExpander {
                         match &*value {
                             "transparent" => ControlFlow::Break(Transparency::Transparent),
                             // "semitransparent" is for old rustc versions.
-                            "semiopaque" | "semitransparent" => ControlFlow::Break(Transparency::SemiOpaque),
+                            "semiopaque" | "semitransparent" => {
+                                ControlFlow::Break(Transparency::SemiOpaque)
+                            }
                             "opaque" => ControlFlow::Break(Transparency::Opaque),
                             _ => ControlFlow::Continue(()),
                         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index d1391ad24e4df..ce99016470c14 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -466,7 +466,7 @@ impl<'db> InferenceContext<'_, 'db> {
     }
 
     /// Given an `FnOnce::Output` or `AsyncFn::Output` projection, extract the args
-    /// and return type to infer a [`ty::PolyFnSig`] for the closure.
+    /// and return type to infer a `PolyFnSig` for the closure.
     fn extract_sig_from_projection(
         &self,
         projection: PolyProjectionPredicate<'db>,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index 226e9f5cd6674..62339779a5625 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -1704,7 +1704,7 @@ impl<'db> InferenceContext<'_, 'db> {
                 });
                 match resolved {
                     Ok((func, _is_visible)) => {
-                        self.check_method_call(tgt_expr, &[], func.sig, receiver_ty, expected)
+                        self.check_method_call(tgt_expr, &[], func.sig, expected)
                     }
                     Err(_) => self.err_ty(),
                 }
@@ -1844,7 +1844,7 @@ impl<'db> InferenceContext<'_, 'db> {
                         item: func.def_id.into(),
                     })
                 }
-                self.check_method_call(tgt_expr, args, func.sig, receiver_ty, expected)
+                self.check_method_call(tgt_expr, args, func.sig, expected)
             }
             // Failed to resolve, report diagnostic and try to resolve as call to field access or
             // assoc function
@@ -1934,16 +1934,14 @@ impl<'db> InferenceContext<'_, 'db> {
         tgt_expr: ExprId,
         args: &[ExprId],
         sig: FnSig<'db>,
-        receiver_ty: Ty<'db>,
         expected: &Expectation<'db>,
     ) -> Ty<'db> {
-        let (formal_receiver_ty, param_tys) = if !sig.inputs_and_output.inputs().is_empty() {
-            (sig.inputs_and_output.as_slice()[0], &sig.inputs_and_output.inputs()[1..])
+        let param_tys = if !sig.inputs_and_output.inputs().is_empty() {
+            &sig.inputs_and_output.inputs()[1..]
         } else {
-            (self.types.types.error, &[] as _)
+            &[]
         };
         let ret_ty = sig.output();
-        self.table.unify(formal_receiver_ty, receiver_ty);
 
         self.check_call_arguments(tgt_expr, param_tys, ret_ty, expected, args, &[], sig.c_variadic);
         ret_ty
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 8e1ea9c478501..9befca11b3e5c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -27,8 +27,8 @@ use hir_def::{
     resolver::{HasResolver, LifetimeNs, Resolver, TypeNs, ValueNs},
     signatures::{FunctionSignature, TraitFlags, TypeAliasFlags},
     type_ref::{
-        ConstRef, LifetimeRefId, PathId, TraitBoundModifier, TraitRef as HirTraitRef, TypeBound,
-        TypeRef, TypeRefId,
+        ConstRef, FnType, LifetimeRefId, PathId, TraitBoundModifier, TraitRef as HirTraitRef,
+        TypeBound, TypeRef, TypeRefId,
     },
 };
 use hir_expand::name::Name;
@@ -77,6 +77,7 @@ pub struct ImplTraits {
 #[derive(PartialEq, Eq, Debug, Hash)]
 pub struct ImplTrait {
     pub(crate) predicates: StoredClauses,
+    pub(crate) assoc_ty_bounds_start: u32,
 }
 
 pub type ImplTraitIdx = Idx<ImplTrait>;
@@ -97,7 +98,7 @@ impl ImplTraitLoweringState {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub enum LifetimeElisionKind<'db> {
     /// Create a new anonymous lifetime parameter and reference it.
     ///
@@ -166,6 +167,12 @@ impl<'db> LifetimeElisionKind<'db> {
     }
 }
 
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub(crate) enum GenericPredicateSource {
+    SelfOnly,
+    AssocTyBound,
+}
+
 #[derive(Debug)]
 pub struct TyLoweringContext<'db, 'a> {
     pub db: &'db dyn HirDatabase,
@@ -430,26 +437,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                 Ty::new_ref(interner, lifetime, inner_ty, lower_mutability(ref_.mutability))
             }
             TypeRef::Placeholder => Ty::new_error(interner, ErrorGuaranteed),
-            TypeRef::Fn(fn_) => {
-                let substs = self.with_shifted_in(
-                    DebruijnIndex::from_u32(1),
-                    |ctx: &mut TyLoweringContext<'_, '_>| {
-                        Tys::new_from_iter(
-                            interner,
-                            fn_.params.iter().map(|&(_, tr)| ctx.lower_ty(tr)),
-                        )
-                    },
-                );
-                Ty::new_fn_ptr(
-                    interner,
-                    Binder::dummy(FnSig {
-                        abi: fn_.abi.as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),
-                        safety: if fn_.is_unsafe { Safety::Unsafe } else { Safety::Safe },
-                        c_variadic: fn_.is_varargs,
-                        inputs_and_output: substs,
-                    }),
-                )
-            }
+            TypeRef::Fn(fn_) => self.lower_fn_ptr(fn_),
             TypeRef::DynTrait(bounds) => self.lower_dyn_trait(bounds),
             TypeRef::ImplTrait(bounds) => {
                 match self.impl_trait_mode.mode {
@@ -465,10 +453,10 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                         // this dance is to make sure the data is in the right
                         // place even if we encounter more opaque types while
                         // lowering the bounds
-                        let idx = self
-                            .impl_trait_mode
-                            .opaque_type_data
-                            .alloc(ImplTrait { predicates: Clauses::empty(interner).store() });
+                        let idx = self.impl_trait_mode.opaque_type_data.alloc(ImplTrait {
+                            predicates: Clauses::empty(interner).store(),
+                            assoc_ty_bounds_start: 0,
+                        });
 
                         let impl_trait_id = origin.either(
                             |f| ImplTraitId::ReturnTypeImplTrait(f, idx),
@@ -510,6 +498,30 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         (ty, res)
     }
 
+    fn lower_fn_ptr(&mut self, fn_: &FnType) -> Ty<'db> {
+        let interner = self.interner;
+        let (params, ret_ty) = fn_.split_params_and_ret();
+        let old_lifetime_elision = self.lifetime_elision;
+        let mut args = Vec::with_capacity(fn_.params.len());
+        self.with_shifted_in(DebruijnIndex::from_u32(1), |ctx: &mut TyLoweringContext<'_, '_>| {
+            ctx.lifetime_elision =
+                LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false };
+            args.extend(params.iter().map(|&(_, tr)| ctx.lower_ty(tr)));
+            ctx.lifetime_elision = LifetimeElisionKind::for_fn_ret(interner);
+            args.push(ctx.lower_ty(ret_ty));
+        });
+        self.lifetime_elision = old_lifetime_elision;
+        Ty::new_fn_ptr(
+            interner,
+            Binder::dummy(FnSig {
+                abi: fn_.abi.as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),
+                safety: if fn_.is_unsafe { Safety::Unsafe } else { Safety::Safe },
+                c_variadic: fn_.is_varargs,
+                inputs_and_output: Tys::new_from_slice(&args),
+            }),
+        )
+    }
+
     /// This is only for `generic_predicates_for_param`, where we can't just
     /// lower the self types of the predicates since that could lead to cycles.
     /// So we just check here if the `type_ref` resolves to a generic param, and which.
@@ -608,7 +620,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         ignore_bindings: bool,
         generics: &Generics,
         predicate_filter: PredicateFilter,
-    ) -> impl Iterator<Item = Clause<'db>> + use<'a, 'b, 'db> {
+    ) -> impl Iterator<Item = (Clause<'db>, GenericPredicateSource)> + use<'a, 'b, 'db> {
         match where_predicate {
             WherePredicate::ForLifetime { target, bound, .. }
             | WherePredicate::TypeBound { target, bound } => {
@@ -634,8 +646,8 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                 let self_ty = self.lower_ty(*target);
                 Either::Left(Either::Right(self.lower_type_bound(bound, self_ty, ignore_bindings)))
             }
-            &WherePredicate::Lifetime { bound, target } => {
-                Either::Right(iter::once(Clause(Predicate::new(
+            &WherePredicate::Lifetime { bound, target } => Either::Right(iter::once((
+                Clause(Predicate::new(
                     self.interner,
                     Binder::dummy(rustc_type_ir::PredicateKind::Clause(
                         rustc_type_ir::ClauseKind::RegionOutlives(OutlivesPredicate(
@@ -643,8 +655,9 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                             self.lower_lifetime(target),
                         )),
                     )),
-                ))))
-            }
+                )),
+                GenericPredicateSource::SelfOnly,
+            ))),
         }
         .into_iter()
     }
@@ -654,7 +667,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         bound: &'b TypeBound,
         self_ty: Ty<'db>,
         ignore_bindings: bool,
-    ) -> impl Iterator<Item = Clause<'db>> + use<'b, 'a, 'db> {
+    ) -> impl Iterator<Item = (Clause<'db>, GenericPredicateSource)> + use<'b, 'a, 'db> {
         let interner = self.interner;
         let meta_sized = self.lang_items.MetaSized;
         let pointee_sized = self.lang_items.PointeeSized;
@@ -712,7 +725,10 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             }
             TypeBound::Use(_) | TypeBound::Error => {}
         }
-        clause.into_iter().chain(assoc_bounds.into_iter().flatten())
+        clause
+            .into_iter()
+            .map(|pred| (pred, GenericPredicateSource::SelfOnly))
+            .chain(assoc_bounds.into_iter().flatten())
     }
 
     fn lower_dyn_trait(&mut self, bounds: &[TypeBound]) -> Ty<'db> {
@@ -732,7 +748,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
 
             for b in bounds {
                 let db = ctx.db;
-                ctx.lower_type_bound(b, dummy_self_ty, false).for_each(|b| {
+                ctx.lower_type_bound(b, dummy_self_ty, false).for_each(|(b, _)| {
                     match b.kind().skip_binder() {
                         rustc_type_ir::ClauseKind::Trait(t) => {
                             let id = t.def_id();
@@ -990,35 +1006,49 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             rustc_type_ir::AliasTyKind::Opaque,
             AliasTy::new_from_args(interner, def_id, args),
         );
-        let predicates = self.with_shifted_in(DebruijnIndex::from_u32(1), |ctx| {
-            let mut predicates = Vec::new();
-            for b in bounds {
-                predicates.extend(ctx.lower_type_bound(b, self_ty, false));
-            }
+        let (predicates, assoc_ty_bounds_start) =
+            self.with_shifted_in(DebruijnIndex::from_u32(1), |ctx| {
+                let mut predicates = Vec::new();
+                let mut assoc_ty_bounds = Vec::new();
+                for b in bounds {
+                    for (pred, source) in ctx.lower_type_bound(b, self_ty, false) {
+                        match source {
+                            GenericPredicateSource::SelfOnly => predicates.push(pred),
+                            GenericPredicateSource::AssocTyBound => assoc_ty_bounds.push(pred),
+                        }
+                    }
+                }
 
-            if !ctx.unsized_types.contains(&self_ty) {
-                let sized_trait = self.lang_items.Sized;
-                let sized_clause = sized_trait.map(|trait_id| {
-                    let trait_ref = TraitRef::new_from_args(
-                        interner,
-                        trait_id.into(),
-                        GenericArgs::new_from_slice(&[self_ty.into()]),
-                    );
-                    Clause(Predicate::new(
-                        interner,
-                        Binder::dummy(rustc_type_ir::PredicateKind::Clause(
-                            rustc_type_ir::ClauseKind::Trait(TraitPredicate {
-                                trait_ref,
-                                polarity: rustc_type_ir::PredicatePolarity::Positive,
-                            }),
-                        )),
-                    ))
-                });
-                predicates.extend(sized_clause);
-            }
-            predicates
-        });
-        ImplTrait { predicates: Clauses::new_from_slice(&predicates).store() }
+                if !ctx.unsized_types.contains(&self_ty) {
+                    let sized_trait = self.lang_items.Sized;
+                    let sized_clause = sized_trait.map(|trait_id| {
+                        let trait_ref = TraitRef::new_from_args(
+                            interner,
+                            trait_id.into(),
+                            GenericArgs::new_from_slice(&[self_ty.into()]),
+                        );
+                        Clause(Predicate::new(
+                            interner,
+                            Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                                rustc_type_ir::ClauseKind::Trait(TraitPredicate {
+                                    trait_ref,
+                                    polarity: rustc_type_ir::PredicatePolarity::Positive,
+                                }),
+                            )),
+                        ))
+                    });
+                    predicates.extend(sized_clause);
+                }
+
+                let assoc_ty_bounds_start = predicates.len() as u32;
+                predicates.extend(assoc_ty_bounds);
+                (predicates, assoc_ty_bounds_start)
+            });
+
+        ImplTrait {
+            predicates: Clauses::new_from_slice(&predicates).store(),
+            assoc_ty_bounds_start,
+        }
     }
 
     pub(crate) fn lower_lifetime(&mut self, lifetime: LifetimeRefId) -> Region<'db> {
@@ -1139,6 +1169,31 @@ impl ImplTraitId {
             .expect("owner should have opaque type")
             .get_with(|it| it.impl_traits[idx].predicates.as_ref().as_slice())
     }
+
+    #[inline]
+    pub fn self_predicates<'db>(
+        self,
+        db: &'db dyn HirDatabase,
+    ) -> EarlyBinder<'db, &'db [Clause<'db>]> {
+        let (impl_traits, idx) = match self {
+            ImplTraitId::ReturnTypeImplTrait(owner, idx) => {
+                (ImplTraits::return_type_impl_traits(db, owner), idx)
+            }
+            ImplTraitId::TypeAliasImplTrait(owner, idx) => {
+                (ImplTraits::type_alias_impl_traits(db, owner), idx)
+            }
+        };
+        let predicates =
+            impl_traits.as_deref().expect("owner should have opaque type").get_with(|it| {
+                let impl_trait = &it.impl_traits[idx];
+                (
+                    impl_trait.predicates.as_ref().as_slice(),
+                    impl_trait.assoc_ty_bounds_start as usize,
+                )
+            });
+
+        predicates.map_bound(|(preds, len)| &preds[..len])
+    }
 }
 
 impl InternedOpaqueTyId {
@@ -1146,6 +1201,14 @@ impl InternedOpaqueTyId {
     pub fn predicates<'db>(self, db: &'db dyn HirDatabase) -> EarlyBinder<'db, &'db [Clause<'db>]> {
         self.loc(db).predicates(db)
     }
+
+    #[inline]
+    pub fn self_predicates<'db>(
+        self,
+        db: &'db dyn HirDatabase,
+    ) -> EarlyBinder<'db, &'db [Clause<'db>]> {
+        self.loc(db).self_predicates(db)
+    }
 }
 
 #[salsa::tracked]
@@ -1655,12 +1718,15 @@ pub(crate) fn generic_predicates_for_param<'db>(
         ctx.store = maybe_parent_generics.store();
         for pred in maybe_parent_generics.where_predicates() {
             if predicate(pred, &mut ctx) {
-                predicates.extend(ctx.lower_where_predicate(
-                    pred,
-                    true,
-                    maybe_parent_generics,
-                    PredicateFilter::All,
-                ));
+                predicates.extend(
+                    ctx.lower_where_predicate(
+                        pred,
+                        true,
+                        maybe_parent_generics,
+                        PredicateFilter::All,
+                    )
+                    .map(|(pred, _)| pred),
+                );
             }
         }
     }
@@ -1696,21 +1762,44 @@ pub(crate) fn type_alias_bounds<'db>(
     db: &'db dyn HirDatabase,
     type_alias: TypeAliasId,
 ) -> EarlyBinder<'db, &'db [Clause<'db>]> {
-    type_alias_bounds_with_diagnostics(db, type_alias).0.map_bound(|it| it.as_slice())
+    type_alias_bounds_with_diagnostics(db, type_alias).0.predicates.map_bound(|it| it.as_slice())
 }
 
-pub(crate) fn type_alias_bounds_with_diagnostics<'db>(
+#[inline]
+pub(crate) fn type_alias_self_bounds<'db>(
     db: &'db dyn HirDatabase,
     type_alias: TypeAliasId,
-) -> (EarlyBinder<'db, Clauses<'db>>, Diagnostics) {
-    let (bounds, diags) = type_alias_bounds_with_diagnostics_query(db, type_alias);
-    return (bounds.get(), diags.clone());
+) -> EarlyBinder<'db, &'db [Clause<'db>]> {
+    let (TypeAliasBounds { predicates, assoc_ty_bounds_start }, _) =
+        type_alias_bounds_with_diagnostics(db, type_alias);
+    predicates.map_bound(|it| &it.as_slice()[..assoc_ty_bounds_start as usize])
+}
+
+#[derive(PartialEq, Eq, Debug, Hash)]
+struct TypeAliasBounds<T> {
+    predicates: T,
+    assoc_ty_bounds_start: u32,
+}
+
+fn type_alias_bounds_with_diagnostics<'db>(
+    db: &'db dyn HirDatabase,
+    type_alias: TypeAliasId,
+) -> (TypeAliasBounds<EarlyBinder<'db, Clauses<'db>>>, Diagnostics) {
+    let (TypeAliasBounds { predicates, assoc_ty_bounds_start }, diags) =
+        type_alias_bounds_with_diagnostics_query(db, type_alias);
+    return (
+        TypeAliasBounds {
+            predicates: predicates.get(),
+            assoc_ty_bounds_start: *assoc_ty_bounds_start,
+        },
+        diags.clone(),
+    );
 
     #[salsa::tracked(returns(ref))]
     pub fn type_alias_bounds_with_diagnostics_query<'db>(
         db: &'db dyn HirDatabase,
         type_alias: TypeAliasId,
-    ) -> (StoredEarlyBinder<StoredClauses>, Diagnostics) {
+    ) -> (TypeAliasBounds<StoredEarlyBinder<StoredClauses>>, Diagnostics) {
         let type_alias_data = db.type_alias_signature(type_alias);
         let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);
         let mut ctx = TyLoweringContext::new(
@@ -1727,10 +1816,18 @@ pub(crate) fn type_alias_bounds_with_diagnostics<'db>(
         let interner_ty = Ty::new_projection_from_args(interner, def_id, item_args);
 
         let mut bounds = Vec::new();
+        let mut assoc_ty_bounds = Vec::new();
         for bound in &type_alias_data.bounds {
-            ctx.lower_type_bound(bound, interner_ty, false).for_each(|pred| {
-                bounds.push(pred);
-            });
+            ctx.lower_type_bound(bound, interner_ty, false).for_each(
+                |(pred, source)| match source {
+                    GenericPredicateSource::SelfOnly => {
+                        bounds.push(pred);
+                    }
+                    GenericPredicateSource::AssocTyBound => {
+                        assoc_ty_bounds.push(pred);
+                    }
+                },
+            );
         }
 
         if !ctx.unsized_types.contains(&interner_ty) {
@@ -1745,8 +1842,14 @@ pub(crate) fn type_alias_bounds_with_diagnostics<'db>(
             };
         }
 
+        let assoc_ty_bounds_start = bounds.len() as u32;
+        bounds.extend(assoc_ty_bounds);
+
         (
-            StoredEarlyBinder::bind(Clauses::new_from_slice(&bounds).store()),
+            TypeAliasBounds {
+                predicates: StoredEarlyBinder::bind(Clauses::new_from_slice(&bounds).store()),
+                assoc_ty_bounds_start,
+            },
             create_diagnostics(ctx.diagnostics),
         )
     }
@@ -1754,11 +1857,15 @@ pub(crate) fn type_alias_bounds_with_diagnostics<'db>(
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct GenericPredicates {
-    // The order is the following: first, if `parent_is_trait == true`, comes the implicit trait predicate for the
-    // parent. Then come the explicit predicates for the parent, then the explicit trait predicate for the child,
+    // The order is the following: first, if `parent_is_trait == true`, comes the implicit trait
+    // predicate for the parent. Then come the bounds of the associated types of the parents,
+    // then the explicit, self-only predicates for the parent, then the explicit, self-only trait
+    // predicate for the child, then the bounds of the associated types of the child,
     // then the implicit trait predicate for the child, if `is_trait` is `true`.
     predicates: StoredEarlyBinder<StoredClauses>,
+    parent_explicit_self_predicates_start: u32,
     own_predicates_start: u32,
+    own_assoc_ty_bounds_start: u32,
     is_trait: bool,
     parent_is_trait: bool,
 }
@@ -1782,7 +1889,15 @@ impl GenericPredicates {
     pub(crate) fn from_explicit_own_predicates(
         predicates: StoredEarlyBinder<StoredClauses>,
     ) -> Self {
-        Self { predicates, own_predicates_start: 0, is_trait: false, parent_is_trait: false }
+        let len = predicates.get().skip_binder().len() as u32;
+        Self {
+            predicates,
+            parent_explicit_self_predicates_start: 0,
+            own_predicates_start: 0,
+            own_assoc_ty_bounds_start: len,
+            is_trait: false,
+            parent_is_trait: false,
+        }
     }
 
     #[inline]
@@ -1814,6 +1929,14 @@ impl GenericPredicates {
         Self::query(db, def).explicit_predicates()
     }
 
+    #[inline]
+    pub fn query_explicit_implied<'db>(
+        db: &'db dyn HirDatabase,
+        def: GenericDefId,
+    ) -> EarlyBinder<'db, &'db [Clause<'db>]> {
+        Self::query(db, def).explicit_implied_predicates()
+    }
+
     #[inline]
     pub fn all_predicates(&self) -> EarlyBinder<'_, &[Clause<'_>]> {
         self.predicates.get().map_bound(|it| it.as_slice())
@@ -1824,9 +1947,18 @@ impl GenericPredicates {
         self.predicates.get().map_bound(|it| &it.as_slice()[self.own_predicates_start as usize..])
     }
 
-    /// Returns the predicates, minus the implicit `Self: Trait` predicate for a trait.
+    /// Returns the predicates, minus the implicit `Self: Trait` predicate and bounds of the
+    /// associated types for a trait.
     #[inline]
     pub fn explicit_predicates(&self) -> EarlyBinder<'_, &[Clause<'_>]> {
+        self.predicates.get().map_bound(|it| {
+            &it.as_slice()[self.parent_explicit_self_predicates_start as usize
+                ..self.own_assoc_ty_bounds_start as usize]
+        })
+    }
+
+    #[inline]
+    pub fn explicit_implied_predicates(&self) -> EarlyBinder<'_, &[Clause<'_>]> {
         self.predicates.get().map_bound(|it| {
             &it.as_slice()[usize::from(self.parent_is_trait)..it.len() - usize::from(self.is_trait)]
         })
@@ -1902,26 +2034,22 @@ where
     );
     let sized_trait = ctx.lang_items.Sized;
 
-    let mut predicates = Vec::new();
+    // We need to lower parents and self separately - see the comment below lowering of implicit
+    // `Sized` predicates for why.
+    let mut own_predicates = Vec::new();
+    let mut parent_predicates = Vec::new();
+    let mut own_assoc_ty_bounds = Vec::new();
+    let mut parent_assoc_ty_bounds = Vec::new();
     let all_generics =
         std::iter::successors(Some(&generics), |generics| generics.parent_generics())
             .collect::<ArrayVec<_, 2>>();
-    let mut is_trait = false;
-    let mut parent_is_trait = false;
-    if all_generics.len() > 1 {
-        add_implicit_trait_predicate(
-            interner,
-            all_generics.last().unwrap().def(),
-            predicate_filter,
-            &mut predicates,
-            &mut parent_is_trait,
-        );
-    }
-    // We need to lower parent predicates first - see the comment below lowering of implicit `Sized` predicates
-    // for why.
-    let mut own_predicates_start = 0;
+    let own_implicit_trait_predicate = implicit_trait_predicate(interner, def, predicate_filter);
+    let parent_implicit_trait_predicate = if all_generics.len() > 1 {
+        implicit_trait_predicate(interner, all_generics.last().unwrap().def(), predicate_filter)
+    } else {
+        None
+    };
     for &maybe_parent_generics in all_generics.iter().rev() {
-        let current_def_predicates_start = predicates.len();
         // Collect only diagnostics from the child, not including parents.
         ctx.diagnostics.clear();
 
@@ -1929,15 +2057,37 @@ where
             ctx.store = maybe_parent_generics.store();
             for pred in maybe_parent_generics.where_predicates() {
                 tracing::debug!(?pred);
-                predicates.extend(ctx.lower_where_predicate(
-                    pred,
-                    false,
-                    maybe_parent_generics,
-                    predicate_filter,
-                ));
+                for (pred, source) in
+                    ctx.lower_where_predicate(pred, false, maybe_parent_generics, predicate_filter)
+                {
+                    match source {
+                        GenericPredicateSource::SelfOnly => {
+                            if maybe_parent_generics.def() == def {
+                                own_predicates.push(pred);
+                            } else {
+                                parent_predicates.push(pred);
+                            }
+                        }
+                        GenericPredicateSource::AssocTyBound => {
+                            if maybe_parent_generics.def() == def {
+                                own_assoc_ty_bounds.push(pred);
+                            } else {
+                                parent_assoc_ty_bounds.push(pred);
+                            }
+                        }
+                    }
+                }
             }
 
-            push_const_arg_has_type_predicates(db, &mut predicates, maybe_parent_generics);
+            if maybe_parent_generics.def() == def {
+                push_const_arg_has_type_predicates(db, &mut own_predicates, maybe_parent_generics);
+            } else {
+                push_const_arg_has_type_predicates(
+                    db,
+                    &mut parent_predicates,
+                    maybe_parent_generics,
+                );
+            }
 
             if let Some(sized_trait) = sized_trait {
                 let mut add_sized_clause = |param_idx, param_id, param_data| {
@@ -1971,7 +2121,11 @@ where
                             }),
                         )),
                     ));
-                    predicates.push(clause);
+                    if maybe_parent_generics.def() == def {
+                        own_predicates.push(clause);
+                    } else {
+                        parent_predicates.push(clause);
+                    }
                 };
                 let parent_params_len = maybe_parent_generics.len_parent();
                 maybe_parent_generics.iter_self().enumerate().for_each(
@@ -1990,30 +2144,55 @@ where
             // predicates before lowering the child, as a child cannot define a `?Sized` predicate for its parent.
             // But we do have to lower the parent first.
         }
-
-        if maybe_parent_generics.def() == def {
-            own_predicates_start = current_def_predicates_start as u32;
-        }
     }
 
-    add_implicit_trait_predicate(interner, def, predicate_filter, &mut predicates, &mut is_trait);
-
     let diagnostics = create_diagnostics(ctx.diagnostics);
+
+    // The order is:
+    //
+    // 1. parent implicit trait pred
+    // 2. parent assoc bounds
+    // 3. parent self only preds
+    // 4. own self only preds
+    // 5. own assoc ty bounds
+    // 6. own implicit trait pred
+    //
+    // The purpose of this is to index the slice of the followings, without making extra `Vec`s or
+    // iterators:
+    // - explicit self only predicates, of own or own + self
+    // - explicit predicates, of own or own + self
+    let predicates = parent_implicit_trait_predicate
+        .iter()
+        .chain(parent_assoc_ty_bounds.iter())
+        .chain(parent_predicates.iter())
+        .chain(own_predicates.iter())
+        .chain(own_assoc_ty_bounds.iter())
+        .chain(own_implicit_trait_predicate.iter())
+        .copied()
+        .collect::<Vec<_>>();
+    let parent_is_trait = parent_implicit_trait_predicate.is_some();
+    let is_trait = own_implicit_trait_predicate.is_some();
+    let parent_explicit_self_predicates_start =
+        parent_is_trait as u32 + parent_assoc_ty_bounds.len() as u32;
+    let own_predicates_start =
+        parent_explicit_self_predicates_start + parent_predicates.len() as u32;
+    let own_assoc_ty_bounds_start = own_predicates_start + own_predicates.len() as u32;
+
     let predicates = GenericPredicates {
+        parent_explicit_self_predicates_start,
         own_predicates_start,
+        own_assoc_ty_bounds_start,
         is_trait,
         parent_is_trait,
         predicates: StoredEarlyBinder::bind(Clauses::new_from_slice(&predicates).store()),
     };
     return (predicates, diagnostics);
 
-    fn add_implicit_trait_predicate<'db>(
+    fn implicit_trait_predicate<'db>(
         interner: DbInterner<'db>,
         def: GenericDefId,
         predicate_filter: PredicateFilter,
-        predicates: &mut Vec<Clause<'db>>,
-        set_is_trait: &mut bool,
-    ) {
+    ) -> Option<Clause<'db>> {
         // For traits, add `Self: Trait` predicate. This is
         // not part of the predicates that a user writes, but it
         // is something that one must prove in order to invoke a
@@ -2029,8 +2208,9 @@ where
         if let GenericDefId::TraitId(def_id) = def
             && predicate_filter == PredicateFilter::All
         {
-            *set_is_trait = true;
-            predicates.push(TraitRef::identity(interner, def_id.into()).upcast(interner));
+            Some(TraitRef::identity(interner, def_id.into()).upcast(interner))
+        } else {
+            None
         }
     }
 }
@@ -2327,7 +2507,7 @@ pub(crate) fn associated_ty_item_bounds<'db>(
 
     let mut bounds = Vec::new();
     for bound in &type_alias_data.bounds {
-        ctx.lower_type_bound(bound, self_ty, false).for_each(|pred| {
+        ctx.lower_type_bound(bound, self_ty, false).for_each(|(pred, _)| {
             if let Some(bound) = pred
                 .kind()
                 .map_bound(|c| match c {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
index a79f547c2a44f..f3d0de12275ed 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
@@ -32,7 +32,8 @@ use crate::{
     db::HirDatabase,
     generics::{Generics, generics},
     lower::{
-        LifetimeElisionKind, PathDiagnosticCallbackData, named_associated_type_shorthand_candidates,
+        GenericPredicateSource, LifetimeElisionKind, PathDiagnosticCallbackData,
+        named_associated_type_shorthand_candidates,
     },
     next_solver::{
         Binder, Clause, Const, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs, Predicate,
@@ -598,7 +599,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
         explicit_self_ty: Option<Ty<'db>>,
         lowering_assoc_type_generics: bool,
     ) -> GenericArgs<'db> {
-        let old_lifetime_elision = self.ctx.lifetime_elision.clone();
+        let old_lifetime_elision = self.ctx.lifetime_elision;
 
         if let Some(args) = self.current_or_prev_segment.args_and_bindings
             && args.parenthesized != GenericArgsParentheses::No
@@ -639,7 +640,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
             explicit_self_ty,
             PathGenericsSource::Segment(self.current_segment_u32()),
             lowering_assoc_type_generics,
-            self.ctx.lifetime_elision.clone(),
+            self.ctx.lifetime_elision,
         );
         self.ctx.lifetime_elision = old_lifetime_elision;
         result
@@ -853,7 +854,8 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
     pub(super) fn assoc_type_bindings_from_type_bound<'c>(
         mut self,
         trait_ref: TraitRef<'db>,
-    ) -> Option<impl Iterator<Item = Clause<'db>> + use<'a, 'b, 'c, 'db>> {
+    ) -> Option<impl Iterator<Item = (Clause<'db>, GenericPredicateSource)> + use<'a, 'b, 'c, 'db>>
+    {
         let interner = self.ctx.interner;
         self.current_or_prev_segment.args_and_bindings.map(|args_and_bindings| {
             args_and_bindings.bindings.iter().enumerate().flat_map(move |(binding_idx, binding)| {
@@ -882,7 +884,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                                 assoc_type: binding_idx as u32,
                             },
                             false,
-                            this.ctx.lifetime_elision.clone(),
+                            this.ctx.lifetime_elision,
                         )
                     });
                 let args = GenericArgs::new_from_iter(
@@ -900,7 +902,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                             // `Fn()`-style generics are elided like functions. This is `Output` (we lower to it in hir-def).
                             LifetimeElisionKind::for_fn_ret(self.ctx.interner)
                         } else {
-                            self.ctx.lifetime_elision.clone()
+                            self.ctx.lifetime_elision
                         };
                     self.with_lifetime_elision(lifetime_elision, |this| {
                         match (&this.ctx.store[type_ref], this.ctx.impl_trait_mode.mode) {
@@ -921,21 +923,29 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                                         ),
                                     )),
                                 ));
-                                predicates.push(pred);
+                                predicates.push((pred, GenericPredicateSource::SelfOnly));
                             }
                         }
                     })
                 }
                 for bound in binding.bounds.iter() {
-                    predicates.extend(self.ctx.lower_type_bound(
-                        bound,
-                        Ty::new_alias(
-                            self.ctx.interner,
-                            AliasTyKind::Projection,
-                            AliasTy::new_from_args(self.ctx.interner, associated_ty.into(), args),
-                        ),
-                        false,
-                    ));
+                    predicates.extend(
+                        self.ctx
+                            .lower_type_bound(
+                                bound,
+                                Ty::new_alias(
+                                    self.ctx.interner,
+                                    AliasTyKind::Projection,
+                                    AliasTy::new_from_args(
+                                        self.ctx.interner,
+                                        associated_ty.into(),
+                                        args,
+                                    ),
+                                ),
+                                false,
+                            )
+                            .map(|(pred, _)| (pred, GenericPredicateSource::AssocTyBound)),
+                    );
                 }
                 predicates
             })
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index e4681b464fec3..ad4d79e68a9f5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -206,11 +206,11 @@ impl<'a, 'db> InferenceContext<'a, 'db> {
     }
 }
 
-/// Used by [FnCtxt::lookup_method_for_operator] with `-Znext-solver`.
+/// Used by `FnCtxt::lookup_method_for_operator` with `-Znext-solver`.
 ///
 /// With `AsRigid` we error on `impl Opaque: NotInItemBounds` while
 /// `AsInfer` just treats it as ambiguous and succeeds. This is necessary
-/// as we want [FnCtxt::check_expr_call] to treat not-yet-defined opaque
+/// as we want `FnCtxt::check_expr_call` to treat not-yet-defined opaque
 /// types as rigid to support `impl Deref<Target = impl FnOnce()>` and
 /// `Box<impl FnOnce()>`.
 ///
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs
index 4a7c7d93539e6..42a590e8b4cb3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs
@@ -1740,7 +1740,7 @@ impl<'a, 'db, Choice: ProbeChoice<'db>> ProbeContext<'a, 'db, Choice> {
     /// We want to only accept trait methods if they were hold even if the
     /// opaque types were rigid. To handle this, we both check that for trait
     /// candidates the goal were to hold even when treating opaques as rigid,
-    /// see [OpaqueTypesJank](rustc_trait_selection::solve::OpaqueTypesJank).
+    /// see `rustc_trait_selection::solve::OpaqueTypesJank`.
     ///
     /// We also check that all opaque types encountered as self types in the
     /// autoderef chain don't get constrained when applying the candidate.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
index 0fe073297279a..a8bff44a02583 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
@@ -48,6 +48,7 @@ pub struct FulfillmentCtxt<'db> {
     /// use the context in exactly this snapshot.
     #[expect(unused)]
     usable_in_snapshot: usize,
+    try_evaluate_obligations_scratch: PendingObligations<'db>,
 }
 
 #[derive(Default, Debug, Clone)]
@@ -115,6 +116,7 @@ impl<'db> FulfillmentCtxt<'db> {
         FulfillmentCtxt {
             obligations: Default::default(),
             usable_in_snapshot: infcx.num_open_snapshots(),
+            try_evaluate_obligations_scratch: Default::default(),
         }
     }
 }
@@ -162,12 +164,12 @@ impl<'db> FulfillmentCtxt<'db> {
         // and select. They should use a different `ObligationCtxt` instead. Then we'll be also able
         // to not put the obligations queue in `InferenceTable`'s snapshots.
         // assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
+        self.try_evaluate_obligations_scratch.clear();
         let mut errors = Vec::new();
-        let mut obligations = Vec::new();
         loop {
             let mut any_changed = false;
-            obligations.extend(self.obligations.drain_pending(|_| true));
-            for (mut obligation, stalled_on) in obligations.drain(..) {
+            self.try_evaluate_obligations_scratch.extend(self.obligations.drain_pending(|_| true));
+            for (mut obligation, stalled_on) in self.try_evaluate_obligations_scratch.drain(..) {
                 if obligation.recursion_depth >= infcx.interner.recursion_limit() {
                     self.obligations.on_fulfillment_overflow(infcx);
                     // Only return true errors that we have accumulated while processing.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
index 7d291f7ddbedb..21baacb116938 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
@@ -140,7 +140,7 @@ pub struct InferCtxtInner<'db> {
     ///
     /// Before running `resolve_regions_and_report_errors`, the creator
     /// of the inference context is expected to invoke
-    /// [`InferCtxt::process_registered_region_obligations`]
+    /// `InferCtxt::process_registered_region_obligations`
     /// for each body-id in this map, which will process the
     /// obligations within. This is expected to be done 'late enough'
     /// that all type inference variables have been bound and so forth.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs
index 14df42dc2aebe..dde623483642f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs
@@ -55,6 +55,13 @@ impl ObligationCause {
     }
 }
 
+impl Default for ObligationCause {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// An `Obligation` represents some trait reference (e.g., `i32: Eq`) for
 /// which the "impl_source" must be found. The process of finding an "impl_source" is
 /// called "resolving" the `Obligation`. This process consists of
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 2a3df1d32a30d..e17bdac68cdd0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -41,7 +41,8 @@ use crate::{
         AdtIdWrapper, AnyImplId, BoundConst, CallableIdWrapper, CanonicalVarKind, ClosureIdWrapper,
         CoroutineIdWrapper, Ctor, FnSig, FxIndexMap, GeneralConstIdWrapper, OpaqueTypeKey,
         RegionAssumptions, SimplifiedType, SolverContext, SolverDefIds, TraitIdWrapper,
-        TypeAliasIdWrapper, UnevaluatedConst, util::explicit_item_bounds,
+        TypeAliasIdWrapper, UnevaluatedConst,
+        util::{explicit_item_bounds, explicit_item_self_bounds},
     },
 };
 
@@ -1421,7 +1422,7 @@ impl<'db> Interner for DbInterner<'db> {
         self,
         def_id: Self::DefId,
     ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
-        explicit_item_bounds(self, def_id)
+        explicit_item_self_bounds(self, def_id)
             .map_bound(|bounds| elaborate(self, bounds).filter_only_self())
     }
 
@@ -1500,7 +1501,7 @@ impl<'db> Interner for DbInterner<'db> {
             }
         }
 
-        predicates_of(self.db, def_id).explicit_predicates().map_bound(|predicates| {
+        predicates_of(self.db, def_id).explicit_implied_predicates().map_bound(|predicates| {
             predicates
                 .iter()
                 .copied()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
index 34ecfed08f29d..9a1b476976e34 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
@@ -455,6 +455,21 @@ pub fn explicit_item_bounds<'db>(
     clauses.map_bound(|clauses| clauses.iter().copied())
 }
 
+pub fn explicit_item_self_bounds<'db>(
+    interner: DbInterner<'db>,
+    def_id: SolverDefId,
+) -> EarlyBinder<'db, impl DoubleEndedIterator<Item = Clause<'db>> + ExactSizeIterator> {
+    let db = interner.db();
+    let clauses = match def_id {
+        SolverDefId::TypeAliasId(type_alias) => {
+            crate::lower::type_alias_self_bounds(db, type_alias)
+        }
+        SolverDefId::InternedOpaqueTyId(id) => id.self_predicates(db),
+        _ => panic!("Unexpected GenericDefId"),
+    };
+    clauses.map_bound(|clauses| clauses.iter().copied())
+}
+
 pub struct ContainsTypeErrors;
 
 impl<'db> TypeVisitor<DbInterner<'db>> for ContainsTypeErrors {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index c805f030446cb..df49d7999feea 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -891,13 +891,14 @@ use core::ops::Deref;
 
 struct BufWriter {}
 
-struct Mutex<T> {}
-struct MutexGuard<'a, T> {}
+struct Mutex<T>(T);
+struct MutexGuard<'a, T>(&'a T);
 impl<T> Mutex<T> {
     fn lock(&self) -> MutexGuard<'_, T> {}
 }
 impl<'a, T: 'a> Deref for MutexGuard<'a, T> {
     type Target = T;
+    fn deref(&self) -> &Self::Target { loop {} }
 }
 fn flush(&self) {
     let w: &Mutex<BufWriter>;
@@ -905,14 +906,18 @@ fn flush(&self) {
 }
 "#,
         expect![[r#"
-            123..127 'self': &'? Mutex<T>
-            150..152 '{}': MutexGuard<'?, T>
-            234..238 'self': &'? {unknown}
-            240..290 '{     ...()); }': ()
-            250..251 'w': &'? Mutex<BufWriter>
-            276..287 '*(w.lock())': BufWriter
-            278..279 'w': &'? Mutex<BufWriter>
-            278..286 'w.lock()': MutexGuard<'?, BufWriter>
+            129..133 'self': &'? Mutex<T>
+            156..158 '{}': MutexGuard<'?, T>
+            242..246 'self': &'? MutexGuard<'a, T>
+            265..276 '{ loop {} }': &'? T
+            267..274 'loop {}': !
+            272..274 '{}': ()
+            289..293 'self': &'? {unknown}
+            295..345 '{     ...()); }': ()
+            305..306 'w': &'? Mutex<BufWriter>
+            331..342 '*(w.lock())': BufWriter
+            333..334 'w': &'? Mutex<BufWriter>
+            333..341 'w.lock()': MutexGuard<'?, BufWriter>
         "#]],
     );
 }
@@ -2563,3 +2568,33 @@ fn main() {
         "#,
     );
 }
+
+#[test]
+fn regression_21429() {
+    check_no_mismatches(
+        r#"
+trait DatabaseLike {
+    type ForeignKey: ForeignKeyLike<DB = Self>;
+}
+
+trait ForeignKeyLike {
+    type DB: DatabaseLike;
+
+    fn host_columns(&self, database: &Self::DB);
+}
+
+trait ColumnLike {
+    type DB: DatabaseLike;
+
+    fn foo() -> &&<<Self as ColumnLike>::DB as DatabaseLike>::ForeignKey {
+        loop {}
+    }
+
+    fn foreign_keys(&self, database: &Self::DB) {
+        let fk = Self::foo();
+        fk.host_columns(database);
+    }
+}
+    "#,
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index a4554673cdd5e..be6ab23ad761e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -750,3 +750,63 @@ fn main() {
         "#]],
     );
 }
+
+#[test]
+fn regression_19339() {
+    check_infer(
+        r#"
+trait Bar {
+    type Baz;
+
+    fn baz(&self) -> Self::Baz;
+}
+
+trait Foo {
+    type Bar;
+
+    fn bar(&self) -> Self::Bar;
+}
+
+trait FooFactory {
+    type Output: Foo<Bar: Bar<Baz = u8>>;
+
+    fn foo(&self) -> Self::Output;
+
+    fn foo_rpit(&self) -> impl Foo<Bar: Bar<Baz = u8>>;
+}
+
+fn test1(foo: impl Foo<Bar: Bar<Baz = u8>>) {
+    let baz = foo.bar().baz();
+}
+
+fn test2<T: FooFactory>(factory: T) {
+    let baz = factory.foo().bar().baz();
+    let baz = factory.foo_rpit().bar().baz();
+}
+"#,
+        expect![[r#"
+            39..43 'self': &'? Self
+            101..105 'self': &'? Self
+            198..202 'self': &'? Self
+            239..243 'self': &'? Self
+            290..293 'foo': impl Foo + ?Sized
+            325..359 '{     ...z(); }': ()
+            335..338 'baz': u8
+            341..344 'foo': impl Foo + ?Sized
+            341..350 'foo.bar()': impl Bar
+            341..356 'foo.bar().baz()': u8
+            385..392 'factory': T
+            397..487 '{     ...z(); }': ()
+            407..410 'baz': u8
+            413..420 'factory': T
+            413..426 'factory.foo()': <T as FooFactory>::Output
+            413..432 'factor....bar()': <<T as FooFactory>::Output as Foo>::Bar
+            413..438 'factor....baz()': u8
+            448..451 'baz': u8
+            454..461 'factory': T
+            454..472 'factor...rpit()': impl Foo + Bar<Baz = u8> + ?Sized
+            454..478 'factor....bar()': <impl Foo + Bar<Baz = u8> + ?Sized as Foo>::Bar
+            454..484 'factor....baz()': u8
+        "#]],
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index 38591f486e971..b825a0a8f0e5a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -429,7 +429,7 @@ fn associated_type_shorthand_from_method_bound() {
 trait Iterable {
     type Item;
 }
-struct S<T>;
+struct S<T>(T);
 impl<T> S<T> {
     fn foo(self) -> T::Item where T: Iterable { loop {} }
 }
@@ -1103,40 +1103,50 @@ fn test() {
 fn argument_impl_trait_type_args_2() {
     check_infer_with_mismatches(
         r#"
-//- minicore: sized
+//- minicore: sized, phantom_data
+use core::marker::PhantomData;
+
 trait Trait {}
 struct S;
 impl Trait for S {}
-struct F<T>;
+struct F<T>(PhantomData<T>);
 impl<T> F<T> {
     fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} }
 }
 
 fn test() {
-    F.foo(S);
-    F::<u32>.foo(S);
-    F::<u32>.foo::<i32>(S);
-    F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored
+    F(PhantomData).foo(S);
+    F::<u32>(PhantomData).foo(S);
+    F::<u32>(PhantomData).foo::<i32>(S);
+    F::<u32>(PhantomData).foo::<i32, u32>(S); // extraneous argument should be ignored
 }"#,
         expect![[r#"
-            87..91 'self': F<T>
-            93..94 'x': impl Trait
-            118..129 '{ loop {} }': (T, U)
-            120..127 'loop {}': !
-            125..127 '{}': ()
-            143..283 '{     ...ored }': ()
-            149..150 'F': F<{unknown}>
-            149..157 'F.foo(S)': ({unknown}, {unknown})
-            155..156 'S': S
-            163..171 'F::<u32>': F<u32>
-            163..178 'F::<u32>.foo(S)': (u32, {unknown})
-            176..177 'S': S
-            184..192 'F::<u32>': F<u32>
-            184..206 'F::<u3...32>(S)': (u32, i32)
-            204..205 'S': S
-            212..220 'F::<u32>': F<u32>
-            212..239 'F::<u3...32>(S)': (u32, i32)
-            237..238 'S': S
+            135..139 'self': F<T>
+            141..142 'x': impl Trait
+            166..177 '{ loop {} }': (T, U)
+            168..175 'loop {}': !
+            173..175 '{}': ()
+            191..383 '{     ...ored }': ()
+            197..198 'F': fn F<{unknown}>(PhantomData<{unknown}>) -> F<{unknown}>
+            197..211 'F(PhantomData)': F<{unknown}>
+            197..218 'F(Phan...foo(S)': ({unknown}, {unknown})
+            199..210 'PhantomData': PhantomData<{unknown}>
+            216..217 'S': S
+            224..232 'F::<u32>': fn F<u32>(PhantomData<u32>) -> F<u32>
+            224..245 'F::<u3...mData)': F<u32>
+            224..252 'F::<u3...foo(S)': (u32, {unknown})
+            233..244 'PhantomData': PhantomData<u32>
+            250..251 'S': S
+            258..266 'F::<u32>': fn F<u32>(PhantomData<u32>) -> F<u32>
+            258..279 'F::<u3...mData)': F<u32>
+            258..293 'F::<u3...32>(S)': (u32, i32)
+            267..278 'PhantomData': PhantomData<u32>
+            291..292 'S': S
+            299..307 'F::<u32>': fn F<u32>(PhantomData<u32>) -> F<u32>
+            299..320 'F::<u3...mData)': F<u32>
+            299..339 'F::<u3...32>(S)': (u32, i32)
+            308..319 'PhantomData': PhantomData<u32>
+            337..338 'S': S
         "#]],
     );
 }
@@ -4012,7 +4022,7 @@ fn f<F: Foo>() {
 fn dyn_map() {
     check_types(
         r#"
-pub struct Key<K, V, P = (K, V)> {}
+pub struct Key<K, V, P = (K, V)>(K, V, P);
 
 pub trait Policy {
     type K;
@@ -4024,7 +4034,7 @@ impl<K, V> Policy for (K, V) {
     type V = V;
 }
 
-pub struct KeyMap<KEY> {}
+pub struct KeyMap<KEY>(KEY);
 
 impl<P: Policy> KeyMap<Key<P::K, P::V, P>> {
     pub fn get(&self, key: &P::K) -> P::V {
@@ -5023,7 +5033,7 @@ fn main() {
             278..280 '{}': ()
             290..291 '_': Box<dyn Iterator<Item = &'? [u8]> + '?>
             294..298 'iter': Box<dyn Iterator<Item = &'? [u8]> + 'static>
-            294..310 'iter.i...iter()': Box<dyn Iterator<Item = &'? [u8]> + 'static>
+            294..310 'iter.i...iter()': Box<dyn Iterator<Item = &'? [u8]> + '?>
             152..156 'self': &'? mut Box<I>
             177..208 '{     ...     }': Option<<I as Iterator>::Item>
             191..198 'loop {}': !
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index f4c42537de939..e55b693ef0186 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -13,7 +13,7 @@ use std::{
 use base_db::FxIndexSet;
 use either::Either;
 use hir_def::{
-    DefWithBodyId, MacroId, StructId, TraitId, VariantId,
+    BuiltinDeriveImplId, DefWithBodyId, HasModule, MacroId, StructId, TraitId, VariantId,
     attrs::parse_extra_crate_attrs,
     expr_store::{Body, ExprOrPatSource, HygieneId, path::Path},
     hir::{BindingId, Expr, ExprId, ExprOrPatId, Pat},
@@ -622,7 +622,20 @@ impl<'db> SemanticsImpl<'db> {
             Some(
                 calls
                     .into_iter()
-                    .map(|call| macro_call_to_macro_id(ctx, call?).map(|id| Macro { id }))
+                    .map(|call| {
+                        let call = call?;
+                        match call {
+                            Either::Left(call) => {
+                                macro_call_to_macro_id(ctx, call).map(|id| Macro { id })
+                            }
+                            Either::Right(call) => {
+                                let call = call.loc(self.db);
+                                let krate = call.krate(self.db);
+                                let lang_items = hir_def::lang_item::lang_items(self.db, krate);
+                                call.trait_.derive_macro(lang_items).map(|id| Macro { id })
+                            }
+                        }
+                    })
                     .collect(),
             )
         })
@@ -633,7 +646,7 @@ impl<'db> SemanticsImpl<'db> {
             .derive_macro_calls(attr)?
             .into_iter()
             .flat_map(|call| {
-                let file_id = call?;
+                let file_id = call?.left()?;
                 let ExpandResult { value, err } = self.db.parse_macro_expansion(file_id);
                 let root_node = value.0.syntax_node();
                 self.cache(root_node.clone(), file_id.into());
@@ -643,7 +656,10 @@ impl<'db> SemanticsImpl<'db> {
         Some(res)
     }
 
-    fn derive_macro_calls(&self, attr: &ast::Attr) -> Option<Vec<Option<MacroCallId>>> {
+    fn derive_macro_calls(
+        &self,
+        attr: &ast::Attr,
+    ) -> Option<Vec<Option<Either<MacroCallId, BuiltinDeriveImplId>>>> {
         let adt = attr.syntax().parent().and_then(ast::Adt::cast)?;
         let file_id = self.find_file(adt.syntax()).file_id;
         let adt = InFile::new(file_id, &adt);
@@ -690,8 +706,9 @@ impl<'db> SemanticsImpl<'db> {
             .derive_helpers_in_scope(InFile::new(sa.file_id, id))?
             .iter()
             .filter(|&(name, _, _)| *name == attr_name)
-            .map(|&(_, macro_, call)| (macro_.into(), call))
+            .filter_map(|&(_, macro_, call)| Some((macro_.into(), call.left()?)))
             .collect();
+        // FIXME: We filter our builtin derive "fake" expansions, is this correct? Should we still expose them somehow?
         res.is_empty().not().then_some(res)
     }
 
@@ -1338,6 +1355,7 @@ impl<'db> SemanticsImpl<'db> {
                                 // FIXME: We need to call `f` for all of them as well though!
                                 process_expansion_for_token(ctx, &mut stack, derive_attr);
                                 for derive in derives.into_iter().flatten() {
+                                    let Either::Left(derive) = derive else { continue };
                                     process_expansion_for_token(ctx, &mut stack, derive);
                                 }
                             }
@@ -1467,11 +1485,12 @@ impl<'db> SemanticsImpl<'db> {
                                 for (.., derive) in
                                     helpers.iter().filter(|(helper, ..)| *helper == attr_name)
                                 {
+                                    let Either::Left(derive) = *derive else { continue };
                                     // as there may be multiple derives registering the same helper
                                     // name, we gotta make sure to call this for all of them!
                                     // FIXME: We need to call `f` for all of them as well though!
                                     res = res
-                                        .or(process_expansion_for_token(ctx, &mut stack, *derive));
+                                        .or(process_expansion_for_token(ctx, &mut stack, derive));
                                 }
                                 res
                             })
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
index 2574059927313..d222c3dc7ed1a 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
@@ -87,10 +87,10 @@
 
 use either::Either;
 use hir_def::{
-    AdtId, BlockId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId, ExternBlockId,
-    ExternCrateId, FieldId, FunctionId, GenericDefId, GenericParamId, ImplId, LifetimeParamId,
-    Lookup, MacroId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
-    UseId, VariantId,
+    AdtId, BlockId, BuiltinDeriveImplId, ConstId, ConstParamId, DefWithBodyId, EnumId,
+    EnumVariantId, ExternBlockId, ExternCrateId, FieldId, FunctionId, GenericDefId, GenericParamId,
+    ImplId, LifetimeParamId, Lookup, MacroId, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
+    TypeParamId, UnionId, UseId, VariantId,
     dyn_map::{
         DynMap,
         keys::{self, Key},
@@ -394,7 +394,7 @@ impl SourceToDefCtx<'_, '_> {
         &mut self,
         item: InFile<&ast::Adt>,
         src: InFile<ast::Attr>,
-    ) -> Option<(AttrId, MacroCallId, &[Option<MacroCallId>])> {
+    ) -> Option<(AttrId, MacroCallId, &[Option<Either<MacroCallId, BuiltinDeriveImplId>>])> {
         let map = self.dyn_map(item)?;
         map[keys::DERIVE_MACRO_CALL]
             .get(&AstPtr::new(&src.value))
@@ -409,8 +409,11 @@ impl SourceToDefCtx<'_, '_> {
     pub(super) fn derive_macro_calls<'slf>(
         &'slf mut self,
         adt: InFile<&ast::Adt>,
-    ) -> Option<impl Iterator<Item = (AttrId, MacroCallId, &'slf [Option<MacroCallId>])> + use<'slf>>
-    {
+    ) -> Option<
+        impl Iterator<
+            Item = (AttrId, MacroCallId, &'slf [Option<Either<MacroCallId, BuiltinDeriveImplId>>]),
+        > + use<'slf>,
+    > {
         self.dyn_map(adt).as_ref().map(|&map| {
             let dyn_map = &map[keys::DERIVE_MACRO_CALL];
             adt.value
diff --git a/src/tools/rust-analyzer/crates/hir/src/symbols.rs b/src/tools/rust-analyzer/crates/hir/src/symbols.rs
index 073142670d2af..4461659f5c4e1 100644
--- a/src/tools/rust-analyzer/crates/hir/src/symbols.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/symbols.rs
@@ -9,6 +9,7 @@ use hir_def::{
     ModuleDefId, ModuleId, TraitId,
     db::DefDatabase,
     item_scope::{ImportId, ImportOrExternCrate, ImportOrGlob},
+    nameres::crate_def_map,
     per_ns::Item,
     src::{HasChildSource, HasSource},
     visibility::{Visibility, VisibilityExplicitness},
@@ -22,7 +23,7 @@ use intern::Symbol;
 use rustc_hash::FxHashMap;
 use syntax::{AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, ToSmolStr, ast::HasName};
 
-use crate::{HasCrate, Module, ModuleDef, Semantics};
+use crate::{Crate, HasCrate, Module, ModuleDef, Semantics};
 
 /// The actual data that is stored in the index. It should be as compact as
 /// possible.
@@ -40,14 +41,14 @@ pub struct FileSymbol<'db> {
     _marker: PhantomData<&'db ()>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct DeclarationLocation {
     /// The file id for both the `ptr` and `name_ptr`.
     pub hir_file_id: HirFileId,
     /// This points to the whole syntax node of the declaration.
     pub ptr: SyntaxNodePtr,
     /// This points to the [`syntax::ast::Name`] identifier of the declaration.
-    pub name_ptr: AstPtr<Either<syntax::ast::Name, syntax::ast::NameRef>>,
+    pub name_ptr: Option<AstPtr<Either<syntax::ast::Name, syntax::ast::NameRef>>>,
 }
 
 impl DeclarationLocation {
@@ -108,6 +109,51 @@ impl<'a> SymbolCollector<'a> {
         }
     }
 
+    /// Push a symbol for a crate's root module.
+    /// This allows crate roots to appear in the symbol index for queries like `::` or `::foo`.
+    pub fn push_crate_root(&mut self, krate: Crate) {
+        let Some(display_name) = krate.display_name(self.db) else { return };
+        let crate_name = display_name.crate_name();
+        let canonical_name = display_name.canonical_name();
+
+        let def_map = crate_def_map(self.db, krate.into());
+        let module_data = &def_map[def_map.crate_root(self.db)];
+
+        let definition = module_data.origin.definition_source(self.db);
+        let hir_file_id = definition.file_id;
+        let syntax_node = definition.value.node();
+        let ptr = SyntaxNodePtr::new(&syntax_node);
+
+        let loc = DeclarationLocation { hir_file_id, ptr, name_ptr: None };
+        let root_module = krate.root_module(self.db);
+
+        self.symbols.insert(FileSymbol {
+            name: crate_name.symbol().clone(),
+            def: ModuleDef::Module(root_module),
+            loc,
+            container_name: None,
+            is_alias: false,
+            is_assoc: false,
+            is_import: false,
+            do_not_complete: Complete::Yes,
+            _marker: PhantomData,
+        });
+
+        if canonical_name != crate_name.symbol() {
+            self.symbols.insert(FileSymbol {
+                name: canonical_name.clone(),
+                def: ModuleDef::Module(root_module),
+                loc,
+                container_name: None,
+                is_alias: false,
+                is_assoc: false,
+                is_import: false,
+                do_not_complete: Complete::Yes,
+                _marker: PhantomData,
+            });
+        }
+    }
+
     pub fn finish(self) -> Box<[FileSymbol<'a>]> {
         self.symbols.into_iter().collect()
     }
@@ -209,7 +255,7 @@ impl<'a> SymbolCollector<'a> {
             let dec_loc = DeclarationLocation {
                 hir_file_id: source.file_id,
                 ptr: SyntaxNodePtr::new(use_tree_src.syntax()),
-                name_ptr: AstPtr::new(&name_syntax),
+                name_ptr: Some(AstPtr::new(&name_syntax)),
             };
             this.symbols.insert(FileSymbol {
                 name: name.symbol().clone(),
@@ -244,7 +290,7 @@ impl<'a> SymbolCollector<'a> {
                 let dec_loc = DeclarationLocation {
                     hir_file_id: source.file_id,
                     ptr: SyntaxNodePtr::new(source.value.syntax()),
-                    name_ptr: AstPtr::new(&name_syntax),
+                    name_ptr: Some(AstPtr::new(&name_syntax)),
                 };
                 this.symbols.insert(FileSymbol {
                     name: name.symbol().clone(),
@@ -409,10 +455,10 @@ impl<'a> SymbolCollector<'a> {
         let source = loc.source(self.db);
         let Some(name_node) = source.value.name() else { return Complete::Yes };
         let def = ModuleDef::from(id.into());
-        let dec_loc = DeclarationLocation {
+        let loc = DeclarationLocation {
             hir_file_id: source.file_id,
             ptr: SyntaxNodePtr::new(source.value.syntax()),
-            name_ptr: AstPtr::new(&name_node).wrap_left(),
+            name_ptr: Some(AstPtr::new(&name_node).wrap_left()),
         };
 
         let mut do_not_complete = Complete::Yes;
@@ -427,7 +473,7 @@ impl<'a> SymbolCollector<'a> {
                 self.symbols.insert(FileSymbol {
                     name: alias.clone(),
                     def,
-                    loc: dec_loc.clone(),
+                    loc,
                     container_name: self.current_container_name.clone(),
                     is_alias: true,
                     is_assoc,
@@ -442,7 +488,7 @@ impl<'a> SymbolCollector<'a> {
             name: name.symbol().clone(),
             def,
             container_name: self.current_container_name.clone(),
-            loc: dec_loc,
+            loc,
             is_alias: false,
             is_assoc,
             is_import: false,
@@ -459,10 +505,10 @@ impl<'a> SymbolCollector<'a> {
         let Some(declaration) = module_data.origin.declaration() else { return };
         let module = declaration.to_node(self.db);
         let Some(name_node) = module.name() else { return };
-        let dec_loc = DeclarationLocation {
+        let loc = DeclarationLocation {
             hir_file_id: declaration.file_id,
             ptr: SyntaxNodePtr::new(module.syntax()),
-            name_ptr: AstPtr::new(&name_node).wrap_left(),
+            name_ptr: Some(AstPtr::new(&name_node).wrap_left()),
         };
 
         let def = ModuleDef::Module(module_id.into());
@@ -475,7 +521,7 @@ impl<'a> SymbolCollector<'a> {
                 self.symbols.insert(FileSymbol {
                     name: alias.clone(),
                     def,
-                    loc: dec_loc.clone(),
+                    loc,
                     container_name: self.current_container_name.clone(),
                     is_alias: true,
                     is_assoc: false,
@@ -490,7 +536,7 @@ impl<'a> SymbolCollector<'a> {
             name: name.symbol().clone(),
             def: ModuleDef::Module(module_id.into()),
             container_name: self.current_container_name.clone(),
-            loc: dec_loc,
+            loc,
             is_alias: false,
             is_assoc: false,
             is_import: false,
diff --git a/src/tools/rust-analyzer/crates/hir/src/term_search.rs b/src/tools/rust-analyzer/crates/hir/src/term_search.rs
index e4089218305ce..f2dc1ce798ad9 100644
--- a/src/tools/rust-analyzer/crates/hir/src/term_search.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/term_search.rs
@@ -172,7 +172,7 @@ impl<'db> LookupTable<'db> {
     /// Insert new type trees for type
     ///
     /// Note that the types have to be the same, unification is not enough as unification is not
-    /// transitive. For example Vec<i32> and FxHashSet<i32> both unify with Iterator<Item = i32>,
+    /// transitive. For example `Vec<i32>` and `FxHashSet<i32>` both unify with `Iterator<Item = i32>`,
     /// but they clearly do not unify themselves.
     fn insert(&mut self, ty: Type<'db>, exprs: impl Iterator<Item = Expr<'db>>) {
         match self.data.get_mut(&ty) {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_type_alias.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_type_alias.rs
index ae8d130df23ca..c7a48f3261a9f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_type_alias.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_type_alias.rs
@@ -290,19 +290,23 @@ impl ConstAndTypeMap {
 ///          ^ alias generic params
 ///    let a: A<100>;
 ///            ^ instance generic args
-///    ```
 ///
 ///    generic['a] = '_ due to omission
 ///    generic[N] = 100 due to the instance arg
 ///    generic[T] = u64 due to the default param
+///    ```
 ///
 /// 2. Copy the concrete type and substitute in each found mapping:
 ///
+///    ```ignore
 ///    &'_ [u64; 100]
+///    ```
 ///
 /// 3. Remove wildcard lifetimes entirely:
 ///
+///    ```ignore
 ///    &[u64; 100]
+///    ```
 fn create_replacement(
     lifetime_map: &LifetimeMap,
     const_and_type_map: &ConstAndTypeMap,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/extern_crate.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/extern_crate.rs
index 71a3e4eb4ed6d..91202e8b32fcd 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/extern_crate.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/extern_crate.rs
@@ -17,7 +17,7 @@ pub(crate) fn complete_extern_crate(acc: &mut Completions, ctx: &CompletionConte
         }
 
         let mut item = CompletionItem::new(
-            CompletionItemKind::SymbolKind(SymbolKind::Module),
+            CompletionItemKind::SymbolKind(SymbolKind::CrateRoot),
             ctx.source_range(),
             name.display_no_db(ctx.edition).to_smolstr(),
             ctx.edition,
@@ -48,7 +48,7 @@ mod other_mod {}
 
         let completion_list = completion_list_no_kw(case);
 
-        assert_eq!("md other_crate_a\n".to_owned(), completion_list);
+        assert_eq!("cr other_crate_a\n".to_owned(), completion_list);
     }
 
     #[test]
@@ -68,6 +68,6 @@ mod other_mod {}
 
         let completion_list = completion_list_no_kw(case);
 
-        assert_eq!("md other_crate_a\n".to_owned(), completion_list);
+        assert_eq!("cr other_crate_a\n".to_owned(), completion_list);
     }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
index d116f665adbdd..cab8bced88df1 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
@@ -628,7 +628,7 @@ impl CompletionContext<'_> {
     }
 
     /// A version of [`SemanticsScope::process_all_names`] that filters out `#[doc(hidden)]` items and
-    /// passes all doc-aliases along, to funnel it into [`Completions::add_path_resolution`].
+    /// passes all doc-aliases along, to funnel it into `Completions::add_path_resolution`.
     pub(crate) fn process_all_names(&self, f: &mut dyn FnMut(Name, ScopeDef, Vec<SmolStr>)) {
         let _p = tracing::info_span!("CompletionContext::process_all_names").entered();
         self.scope.process_all_names(&mut |name, def| {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/item.rs b/src/tools/rust-analyzer/crates/ide-completion/src/item.rs
index 71d32da74710d..1a9139d8553be 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/item.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/item.rs
@@ -381,6 +381,7 @@ impl CompletionItemKind {
                 SymbolKind::BuiltinAttr => "ba",
                 SymbolKind::Const => "ct",
                 SymbolKind::ConstParam => "cp",
+                SymbolKind::CrateRoot => "cr",
                 SymbolKind::Derive => "de",
                 SymbolKind::DeriveHelper => "dh",
                 SymbolKind::Enum => "en",
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
index 797df3f163dab..d7db896679dfd 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
@@ -1976,3 +1976,51 @@ fn main() {
         "#]],
     );
 }
+
+#[test]
+fn trait_method_import_across_multiple_crates() {
+    let fixture = r#"
+        //- /lib.rs crate:test-trait
+        pub trait TestTrait {
+            fn test_function(&self) -> u32;
+        }
+
+        //- /lib.rs crate:test-implementation deps:test-trait
+        pub struct TestStruct(pub usize);
+
+        impl test_trait::TestTrait for TestStruct {
+            fn test_function(&self) -> u32 {
+                1
+            }
+        }
+
+        //- /main.rs crate:main deps:test-implementation,test-trait
+        use test_implementation::TestStruct;
+
+        fn main() {
+            let test = TestStruct(42);
+            test.test_f$0
+        }
+    "#;
+
+    check(
+        fixture,
+        expect![[r#"
+            me test_function() (use test_trait::TestTrait) fn(&self) -> u32
+        "#]],
+    );
+
+    check_edit(
+        "test_function",
+        fixture,
+        r#"
+use test_implementation::TestStruct;
+use test_trait::TestTrait;
+
+fn main() {
+    let test = TestStruct(42);
+    test.test_function()$0
+}
+"#,
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs b/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs
index 90e3bb61f44d3..35579eb2590dc 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs
@@ -600,7 +600,19 @@ fn trait_applicable_items<'db>(
         }
         deref_chain
             .into_iter()
-            .filter_map(|ty| Some((ty.krate(db).into(), ty.fingerprint_for_trait_impl()?)))
+            .flat_map(|ty| {
+                let fingerprint = ty.fingerprint_for_trait_impl()?;
+                let mut crates = vec![];
+
+                if let Some(adt) = ty.as_adt() {
+                    // Push crate where ADT was defined
+                    crates.push((adt.krate(db).into(), fingerprint));
+                }
+                // Always include environment crate
+                crates.push((ty.krate(db).into(), fingerprint));
+                Some(crates)
+            })
+            .flatten()
             .unique()
             .collect::<Vec<_>>()
     };
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/items_locator.rs b/src/tools/rust-analyzer/crates/ide-db/src/items_locator.rs
index 0d305530d925e..af0c69c6856d7 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/items_locator.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/items_locator.rs
@@ -110,7 +110,7 @@ pub fn items_with_name_in_module<T>(
             local_query
         }
     };
-    local_query.search(&[SymbolIndex::module_symbols(db, module)], |local_candidate| {
+    local_query.search(db, &[SymbolIndex::module_symbols(db, module)], |local_candidate| {
         cb(match local_candidate.def {
             hir::ModuleDef::Macro(macro_def) => ItemInNs::Macros(macro_def),
             def => ItemInNs::from(def),
@@ -140,7 +140,7 @@ fn find_items(
 
     // Query the local crate using the symbol index.
     let mut local_results = Vec::new();
-    local_query.search(&symbol_index::crate_symbols(db, krate), |local_candidate| {
+    local_query.search(db, &symbol_index::crate_symbols(db, krate), |local_candidate| {
         let def = match local_candidate.def {
             hir::ModuleDef::Macro(macro_def) => ItemInNs::Macros(macro_def),
             def => ItemInNs::from(def),
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
index 413b58bf7980a..023b32b361955 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
@@ -65,7 +65,7 @@ use base_db::{
 };
 use hir::{
     FilePositionWrapper, FileRangeWrapper,
-    db::{DefDatabase, ExpandDatabase},
+    db::{DefDatabase, ExpandDatabase, HirDatabase},
 };
 use triomphe::Arc;
 
@@ -269,6 +269,7 @@ pub enum SymbolKind {
     BuiltinAttr,
     Const,
     ConstParam,
+    CrateRoot,
     Derive,
     DeriveHelper,
     Enum,
@@ -307,14 +308,15 @@ impl From<hir::MacroKind> for SymbolKind {
     }
 }
 
-impl From<hir::ModuleDef> for SymbolKind {
-    fn from(it: hir::ModuleDef) -> Self {
+impl SymbolKind {
+    pub fn from_module_def(db: &dyn HirDatabase, it: hir::ModuleDef) -> Self {
         match it {
             hir::ModuleDef::Const(..) => SymbolKind::Const,
             hir::ModuleDef::Variant(..) => SymbolKind::Variant,
             hir::ModuleDef::Function(..) => SymbolKind::Function,
             hir::ModuleDef::Macro(mac) if mac.is_proc_macro() => SymbolKind::ProcMacro,
             hir::ModuleDef::Macro(..) => SymbolKind::Macro,
+            hir::ModuleDef::Module(m) if m.is_crate_root(db) => SymbolKind::CrateRoot,
             hir::ModuleDef::Module(..) => SymbolKind::Module,
             hir::ModuleDef::Static(..) => SymbolKind::Static,
             hir::ModuleDef::Adt(hir::Adt::Struct(..)) => SymbolKind::Struct,
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs b/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
index eb0529d6b5e75..c95b541748ecc 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
@@ -40,24 +40,78 @@ use salsa::Update;
 
 use crate::RootDatabase;
 
+/// A query for searching symbols in the workspace or dependencies.
+///
+/// This struct configures how symbol search is performed, including the search text,
+/// matching strategy, and filtering options. It is used by [`world_symbols`] to find
+/// symbols across the codebase.
+///
+/// # Example
+/// ```ignore
+/// let mut query = Query::new("MyStruct".to_string());
+/// query.only_types();  // Only search for type definitions
+/// query.libs();        // Include library dependencies
+/// query.exact();       // Use exact matching instead of fuzzy
+/// ```
 #[derive(Debug, Clone)]
 pub struct Query {
+    /// The item name to search for (last segment of the path, or full query if no path).
+    /// When empty with a non-empty `path_filter`, returns all items in that module.
     query: String,
+    /// Lowercase version of [`Self::query`], pre-computed for efficiency.
+    /// Used to build FST automata for case-insensitive index lookups.
     lowercased: String,
+    /// Path segments to filter by (all segments except the last).
+    /// Empty if no `::` in the original query.
+    path_filter: Vec<String>,
+    /// If true, the first path segment must be a crate name (query started with `::`).
+    anchor_to_crate: bool,
+    /// The search strategy to use when matching symbols.
+    /// - [`SearchMode::Exact`]: Symbol name must exactly match the query.
+    /// - [`SearchMode::Fuzzy`]: Symbol name must contain all query characters in order (subsequence match).
+    /// - [`SearchMode::Prefix`]: Symbol name must start with the query string.
+    ///
+    /// Defaults to [`SearchMode::Fuzzy`].
     mode: SearchMode,
+    /// Controls filtering of trait-associated items (methods, constants, types).
+    /// - [`AssocSearchMode::Include`]: Include both associated and non-associated items.
+    /// - [`AssocSearchMode::Exclude`]: Exclude trait-associated items from results.
+    /// - [`AssocSearchMode::AssocItemsOnly`]: Only return trait-associated items.
+    ///
+    /// Defaults to [`AssocSearchMode::Include`].
     assoc_mode: AssocSearchMode,
+    /// Whether the final symbol name comparison should be case-sensitive.
+    /// When `false`, matching is case-insensitive (e.g., "foo" matches "Foo").
+    ///
+    /// Defaults to `false`.
     case_sensitive: bool,
+    /// When `true`, only return type definitions: structs, enums, unions,
+    /// type aliases, built-in types, and traits. Functions, constants, statics,
+    /// and modules are excluded.
+    ///
+    /// Defaults to `false`.
     only_types: bool,
+    /// When `true`, search library dependency roots instead of local workspace crates.
+    /// This enables finding symbols in external dependencies including the standard library.
+    ///
+    /// Defaults to `false` (search local workspace only).
     libs: bool,
+    /// When `true`, exclude re-exported/imported symbols from results,
+    /// showing only the original definitions.
+    ///
+    /// Defaults to `false`.
     exclude_imports: bool,
 }
 
 impl Query {
     pub fn new(query: String) -> Query {
-        let lowercased = query.to_lowercase();
+        let (path_filter, item_query, anchor_to_crate) = Self::parse_path_query(&query);
+        let lowercased = item_query.to_lowercase();
         Query {
-            query,
+            query: item_query,
             lowercased,
+            path_filter,
+            anchor_to_crate,
             only_types: false,
             libs: false,
             mode: SearchMode::Fuzzy,
@@ -67,6 +121,35 @@ impl Query {
         }
     }
 
+    /// Parse a query string that may contain path segments.
+    ///
+    /// Returns (path_filter, item_query, anchor_to_crate) where:
+    /// - `path_filter`: Path segments to match (all but the last segment)
+    /// - `item_query`: The item name to search for (last segment)
+    /// - `anchor_to_crate`: Whether the first segment must be a crate name
+    fn parse_path_query(query: &str) -> (Vec<String>, String, bool) {
+        // Check for leading :: (absolute path / crate search)
+        let (query, anchor_to_crate) = match query.strip_prefix("::") {
+            Some(q) => (q, true),
+            None => (query, false),
+        };
+
+        let Some((prefix, query)) = query.rsplit_once("::") else {
+            return (vec![], query.to_owned(), anchor_to_crate);
+        };
+
+        let prefix: Vec<_> =
+            prefix.split("::").filter(|s| !s.is_empty()).map(ToOwned::to_owned).collect();
+
+        (prefix, query.to_owned(), anchor_to_crate)
+    }
+
+    /// Returns true if this query is searching for crates
+    /// (i.e., the query was "::" alone or "::foo" for fuzzy crate search)
+    fn is_crate_search(&self) -> bool {
+        self.anchor_to_crate && self.path_filter.is_empty()
+    }
+
     pub fn only_types(&mut self) {
         self.only_types = true;
     }
@@ -123,19 +206,43 @@ pub fn crate_symbols(db: &dyn HirDatabase, krate: Crate) -> Box<[&SymbolIndex<'_
 // That is, `#` switches from "types" to all symbols, `*` switches from the current
 // workspace to dependencies.
 //
-// Note that filtering does not currently work in VSCode due to the editor never
-// sending the special symbols to the language server. Instead, you can configure
-// the filtering via the `rust-analyzer.workspace.symbol.search.scope` and
-// `rust-analyzer.workspace.symbol.search.kind` settings. Symbols prefixed
-// with `__` are hidden from the search results unless configured otherwise.
+// This also supports general Rust path syntax with the usual rules.
+//
+// Note that paths do not currently work in VSCode due to the editor never
+// sending the special symbols to the language server. Some other editors might not support the # or
+// * search either, instead, you can configure the filtering via the
+// `rust-analyzer.workspace.symbol.search.scope` and `rust-analyzer.workspace.symbol.search.kind`
+// settings. Symbols prefixed with `__` are hidden from the search results unless configured
+// otherwise.
 //
 // | Editor  | Shortcut |
 // |---------|-----------|
 // | VS Code | <kbd>Ctrl+T</kbd>
-pub fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol<'_>> {
+pub fn world_symbols(db: &RootDatabase, mut query: Query) -> Vec<FileSymbol<'_>> {
     let _p = tracing::info_span!("world_symbols", query = ?query.query).entered();
 
-    let indices: Vec<_> = if query.libs {
+    // Search for crates by name (handles "::" and "::foo" queries)
+    let indices: Vec<_> = if query.is_crate_search() {
+        query.only_types = false;
+        query.libs = true;
+        vec![SymbolIndex::extern_prelude_symbols(db)]
+        // If we have a path filter, resolve it to target modules
+    } else if !query.path_filter.is_empty() {
+        query.only_types = false;
+        query.libs = true;
+        let target_modules = resolve_path_to_modules(
+            db,
+            &query.path_filter,
+            query.anchor_to_crate,
+            query.case_sensitive,
+        );
+
+        if target_modules.is_empty() {
+            return vec![];
+        }
+
+        target_modules.iter().map(|&module| SymbolIndex::module_symbols(db, module)).collect()
+    } else if query.libs {
         LibraryRoots::get(db)
             .roots(db)
             .par_iter()
@@ -154,17 +261,100 @@ pub fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol<'_>> {
         crates
             .par_iter()
             .for_each_with(db.clone(), |snap, &krate| _ = crate_symbols(snap, krate.into()));
-        crates.into_iter().flat_map(|krate| Vec::from(crate_symbols(db, krate.into()))).collect()
+        crates
+            .into_iter()
+            .flat_map(|krate| Vec::from(crate_symbols(db, krate.into())))
+            .chain(std::iter::once(SymbolIndex::extern_prelude_symbols(db)))
+            .collect()
     };
 
     let mut res = vec![];
-    query.search::<()>(&indices, |f| {
+
+    // Normal search: use FST to match item name
+    query.search::<()>(db, &indices, |f| {
         res.push(f.clone());
         ControlFlow::Continue(())
     });
+
     res
 }
 
+/// Resolve a path filter to the target module(s) it points to.
+/// Returns the modules whose symbol indices should be searched.
+///
+/// The path_filter contains segments like ["std", "vec"] for a query like "std::vec::Vec".
+/// We resolve this by:
+/// 1. Finding crates matching the first segment
+/// 2. Walking down the module tree following subsequent segments
+fn resolve_path_to_modules(
+    db: &dyn HirDatabase,
+    path_filter: &[String],
+    anchor_to_crate: bool,
+    case_sensitive: bool,
+) -> Vec<Module> {
+    let [first_segment, rest_segments @ ..] = path_filter else {
+        return vec![];
+    };
+
+    // Helper for name comparison
+    let names_match = |actual: &str, expected: &str| -> bool {
+        if case_sensitive { actual == expected } else { actual.eq_ignore_ascii_case(expected) }
+    };
+
+    // Find crates matching the first segment
+    let matching_crates: Vec<Crate> = Crate::all(db)
+        .into_iter()
+        .filter(|krate| {
+            krate
+                .display_name(db)
+                .is_some_and(|name| names_match(name.crate_name().as_str(), first_segment))
+        })
+        .collect();
+
+    // If anchor_to_crate is true, first segment MUST be a crate name
+    // If anchor_to_crate is false, first segment could be a crate OR a module in local crates
+    let mut candidate_modules: Vec<Module> = vec![];
+
+    // Add crate root modules for matching crates
+    for krate in matching_crates {
+        candidate_modules.push(krate.root_module(db));
+    }
+
+    // If not anchored to crate, also search for modules matching first segment in local crates
+    if !anchor_to_crate {
+        for &root in LocalRoots::get(db).roots(db).iter() {
+            for &krate in db.source_root_crates(root).iter() {
+                let root_module = Crate::from(krate).root_module(db);
+                for child in root_module.children(db) {
+                    if let Some(name) = child.name(db)
+                        && names_match(name.as_str(), first_segment)
+                    {
+                        candidate_modules.push(child);
+                    }
+                }
+            }
+        }
+    }
+
+    // Walk down the module tree for remaining path segments
+    for segment in rest_segments {
+        candidate_modules = candidate_modules
+            .into_iter()
+            .flat_map(|module| {
+                module.children(db).filter(|child| {
+                    child.name(db).is_some_and(|name| names_match(name.as_str(), segment))
+                })
+            })
+            .collect();
+
+        if candidate_modules.is_empty() {
+            break;
+        }
+    }
+
+    candidate_modules
+}
+
 #[derive(Default)]
 pub struct SymbolIndex<'db> {
     symbols: Box<[FileSymbol<'db>]>,
@@ -236,6 +426,33 @@ impl<'db> SymbolIndex<'db> {
 
         module_symbols(db, InternedModuleId::new(db, hir::ModuleId::from(module)))
     }
+
+    /// The symbol index for all extern prelude crates.
+    pub fn extern_prelude_symbols(db: &dyn HirDatabase) -> &SymbolIndex<'_> {
+        #[salsa::tracked(returns(ref))]
+        fn extern_prelude_symbols<'db>(db: &'db dyn HirDatabase) -> SymbolIndex<'db> {
+            let _p = tracing::info_span!("extern_prelude_symbols").entered();
+
+            // We call this without attaching because this runs in parallel, so we need to attach here.
+            hir::attach_db(db, || {
+                let mut collector = SymbolCollector::new(db, false);
+
+                for krate in Crate::all(db) {
+                    if krate
+                        .display_name(db)
+                        .is_none_or(|name| name.canonical_name().as_str() == "build-script-build")
+                    {
+                        continue;
+                    }
+                    collector.push_crate_root(krate);
+                }
+
+                SymbolIndex::new(collector.finish())
+            })
+        }
+
+        extern_prelude_symbols(db)
+    }
 }
 
 impl fmt::Debug for SymbolIndex<'_> {
@@ -336,12 +553,15 @@ impl<'db> SymbolIndex<'db> {
 }
 
 impl Query {
+    /// Search symbols in the given indices.
     pub(crate) fn search<'db, T>(
-        self,
+        &self,
+        db: &'db RootDatabase,
         indices: &[&'db SymbolIndex<'db>],
         cb: impl FnMut(&'db FileSymbol<'db>) -> ControlFlow<T>,
     ) -> Option<T> {
         let _p = tracing::info_span!("symbol_index::Query::search").entered();
+
         let mut op = fst::map::OpBuilder::new();
         match self.mode {
             SearchMode::Exact => {
@@ -350,7 +570,7 @@ impl Query {
                 for index in indices.iter() {
                     op = op.add(index.map.search(&automaton));
                 }
-                self.search_maps(indices, op.union(), cb)
+                self.search_maps(db, indices, op.union(), cb)
             }
             SearchMode::Fuzzy => {
                 let automaton = fst::automaton::Subsequence::new(&self.lowercased);
@@ -358,7 +578,7 @@ impl Query {
                 for index in indices.iter() {
                     op = op.add(index.map.search(&automaton));
                 }
-                self.search_maps(indices, op.union(), cb)
+                self.search_maps(db, indices, op.union(), cb)
             }
             SearchMode::Prefix => {
                 let automaton = fst::automaton::Str::new(&self.lowercased).starts_with();
@@ -366,13 +586,14 @@ impl Query {
                 for index in indices.iter() {
                     op = op.add(index.map.search(&automaton));
                 }
-                self.search_maps(indices, op.union(), cb)
+                self.search_maps(db, indices, op.union(), cb)
             }
         }
     }
 
     fn search_maps<'db, T>(
         &self,
+        db: &'db RootDatabase,
         indices: &[&'db SymbolIndex<'db>],
         mut stream: fst::map::Union<'_>,
         mut cb: impl FnMut(&'db FileSymbol<'db>) -> ControlFlow<T>,
@@ -380,18 +601,21 @@ impl Query {
         let ignore_underscore_prefixed = !self.query.starts_with("__");
         while let Some((_, indexed_values)) = stream.next() {
             for &IndexedValue { index, value } in indexed_values {
-                let symbol_index = &indices[index];
+                let symbol_index = indices[index];
                 let (start, end) = SymbolIndex::map_value_to_range(value);
 
                 for symbol in &symbol_index.symbols[start..end] {
                     let non_type_for_type_only_query = self.only_types
-                        && !matches!(
+                        && !(matches!(
                             symbol.def,
                             hir::ModuleDef::Adt(..)
                                 | hir::ModuleDef::TypeAlias(..)
                                 | hir::ModuleDef::BuiltinType(..)
                                 | hir::ModuleDef::Trait(..)
-                        );
+                        ) || matches!(
+                            symbol.def,
+                            hir::ModuleDef::Module(module) if module.is_crate_root(db)
+                        ));
                     if non_type_for_type_only_query || !self.matches_assoc_mode(symbol.is_assoc) {
                         continue;
                     }
@@ -576,4 +800,367 @@ pub struct Foo;
         let symbols = world_symbols(&db, query);
         expect_file!["./test_data/test_symbols_exclude_imports.txt"].assert_debug_eq(&symbols);
     }
+
+    #[test]
+    fn test_parse_path_query() {
+        // Plain query - no path
+        let (path, item, anchor) = Query::parse_path_query("Item");
+        assert_eq!(path, Vec::<String>::new());
+        assert_eq!(item, "Item");
+        assert!(!anchor);
+
+        // Path with item
+        let (path, item, anchor) = Query::parse_path_query("foo::Item");
+        assert_eq!(path, vec!["foo"]);
+        assert_eq!(item, "Item");
+        assert!(!anchor);
+
+        // Multi-segment path
+        let (path, item, anchor) = Query::parse_path_query("foo::bar::Item");
+        assert_eq!(path, vec!["foo", "bar"]);
+        assert_eq!(item, "Item");
+        assert!(!anchor);
+
+        // Leading :: (anchor to crate)
+        let (path, item, anchor) = Query::parse_path_query("::std::vec::Vec");
+        assert_eq!(path, vec!["std", "vec"]);
+        assert_eq!(item, "Vec");
+        assert!(anchor);
+
+        // Just "::" - return all crates
+        let (path, item, anchor) = Query::parse_path_query("::");
+        assert_eq!(path, Vec::<String>::new());
+        assert_eq!(item, "");
+        assert!(anchor);
+
+        // "::foo" - fuzzy search crate names
+        let (path, item, anchor) = Query::parse_path_query("::foo");
+        assert_eq!(path, Vec::<String>::new());
+        assert_eq!(item, "foo");
+        assert!(anchor);
+
+        // Trailing :: (module browsing)
+        let (path, item, anchor) = Query::parse_path_query("foo::");
+        assert_eq!(path, vec!["foo"]);
+        assert_eq!(item, "");
+        assert!(!anchor);
+
+        // Full path with trailing ::
+        let (path, item, anchor) = Query::parse_path_query("foo::bar::");
+        assert_eq!(path, vec!["foo", "bar"]);
+        assert_eq!(item, "");
+        assert!(!anchor);
+
+        // Absolute path with trailing ::
+        let (path, item, anchor) = Query::parse_path_query("::std::vec::");
+        assert_eq!(path, vec!["std", "vec"]);
+        assert_eq!(item, "");
+        assert!(anchor);
+
+        // Empty segments should be filtered
+        let (path, item, anchor) = Query::parse_path_query("foo::::bar");
+        assert_eq!(path, vec!["foo"]);
+        assert_eq!(item, "bar");
+        assert!(!anchor);
+    }
+
+    #[test]
+    fn test_path_search() {
+        let (mut db, _) = RootDatabase::with_many_files(
+            r#"
+//- /lib.rs crate:main
+mod inner;
+pub struct RootStruct;
+
+//- /inner.rs
+pub struct InnerStruct;
+pub mod nested {
+    pub struct NestedStruct;
+}
+"#,
+        );
+
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(WORKSPACE);
+        LocalRoots::get(&db).set_roots(&mut db).to(local_roots);
+
+        // Search for item in specific module
+        let query = Query::new("inner::InnerStruct".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+        assert!(names.contains(&"InnerStruct"), "Expected InnerStruct in {:?}", names);
+
+        // Search for item in nested module
+        let query = Query::new("inner::nested::NestedStruct".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+        assert!(names.contains(&"NestedStruct"), "Expected NestedStruct in {:?}", names);
+
+        // Search with crate prefix
+        let query = Query::new("main::inner::InnerStruct".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+        assert!(names.contains(&"InnerStruct"), "Expected InnerStruct in {:?}", names);
+
+        // Wrong path should return empty
+        let query = Query::new("wrong::InnerStruct".to_owned());
+        let symbols = world_symbols(&db, query);
+        assert!(symbols.is_empty(), "Expected empty results for wrong path");
+    }
+
+    #[test]
+    fn test_module_browsing() {
+        let (mut db, _) = RootDatabase::with_many_files(
+            r#"
+//- /lib.rs crate:main
+mod mymod;
+
+//- /mymod.rs
+pub struct MyStruct;
+pub fn my_func() {}
+pub const MY_CONST: u32 = 1;
+"#,
+        );
+
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(WORKSPACE);
+        LocalRoots::get(&db).set_roots(&mut db).to(local_roots);
+
+        // Browse all items in module
+        let query = Query::new("main::mymod::".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+
+        assert!(names.contains(&"MyStruct"), "Expected MyStruct in {:?}", names);
+        assert!(names.contains(&"my_func"), "Expected my_func in {:?}", names);
+        assert!(names.contains(&"MY_CONST"), "Expected MY_CONST in {:?}", names);
+    }
+
+    #[test]
+    fn test_fuzzy_item_with_path() {
+        let (mut db, _) = RootDatabase::with_many_files(
+            r#"
+//- /lib.rs crate:main
+mod mymod;
+
+//- /mymod.rs
+pub struct MyLongStructName;
+"#,
+        );
+
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(WORKSPACE);
+        LocalRoots::get(&db).set_roots(&mut db).to(local_roots);
+
+        // Fuzzy match on item name with exact path
+        let query = Query::new("main::mymod::MyLong".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+        assert!(
+            names.contains(&"MyLongStructName"),
+            "Expected fuzzy match for MyLongStructName in {:?}",
+            names
+        );
+    }
+
+    #[test]
+    fn test_case_insensitive_path() {
+        let (mut db, _) = RootDatabase::with_many_files(
+            r#"
+//- /lib.rs crate:main
+mod MyMod;
+
+//- /MyMod.rs
+pub struct MyStruct;
+"#,
+        );
+
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(WORKSPACE);
+        LocalRoots::get(&db).set_roots(&mut db).to(local_roots);
+
+        // Case insensitive path matching (default)
+        let query = Query::new("main::mymod::MyStruct".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+        assert!(names.contains(&"MyStruct"), "Expected case-insensitive match in {:?}", names);
+    }
+
+    #[test]
+    fn test_absolute_path_search() {
+        let (mut db, _) = RootDatabase::with_many_files(
+            r#"
+//- /lib.rs crate:mycrate
+mod inner;
+pub struct CrateRoot;
+
+//- /inner.rs
+pub struct InnerItem;
+"#,
+        );
+
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(WORKSPACE);
+        LocalRoots::get(&db).set_roots(&mut db).to(local_roots);
+
+        // Absolute path with leading ::
+        let query = Query::new("::mycrate::inner::InnerItem".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+        assert!(
+            names.contains(&"InnerItem"),
+            "Expected InnerItem with absolute path in {:?}",
+            names
+        );
+
+        // Absolute path should NOT match if crate name is wrong
+        let query = Query::new("::wrongcrate::inner::InnerItem".to_owned());
+        let symbols = world_symbols(&db, query);
+        assert!(symbols.is_empty(), "Expected empty results for wrong crate name");
+    }
+
+    #[test]
+    fn test_wrong_path_returns_empty() {
+        let (mut db, _) = RootDatabase::with_many_files(
+            r#"
+//- /lib.rs crate:main
+mod existing;
+
+//- /existing.rs
+pub struct MyStruct;
+"#,
+        );
+
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(WORKSPACE);
+        LocalRoots::get(&db).set_roots(&mut db).to(local_roots);
+
+        // Non-existent module path
+        let query = Query::new("nonexistent::MyStruct".to_owned());
+        let symbols = world_symbols(&db, query);
+        assert!(symbols.is_empty(), "Expected empty results for non-existent path");
+
+        // Correct item, wrong module
+        let query = Query::new("wrongmod::MyStruct".to_owned());
+        let symbols = world_symbols(&db, query);
+        assert!(symbols.is_empty(), "Expected empty results for wrong module");
+    }
+
+    #[test]
+    fn test_root_module_items() {
+        let (mut db, _) = RootDatabase::with_many_files(
+            r#"
+//- /lib.rs crate:mylib
+pub struct RootItem;
+pub fn root_fn() {}
+"#,
+        );
+
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(WORKSPACE);
+        LocalRoots::get(&db).set_roots(&mut db).to(local_roots);
+
+        // Items at crate root - path is just the crate name
+        let query = Query::new("mylib::RootItem".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+        assert!(names.contains(&"RootItem"), "Expected RootItem at crate root in {:?}", names);
+
+        // Browse crate root
+        let query = Query::new("mylib::".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+        assert!(
+            names.contains(&"RootItem"),
+            "Expected RootItem when browsing crate root in {:?}",
+            names
+        );
+        assert!(
+            names.contains(&"root_fn"),
+            "Expected root_fn when browsing crate root in {:?}",
+            names
+        );
+    }
+
+    #[test]
+    fn test_crate_search_all() {
+        // Test that sole "::" returns all crates
+        let (mut db, _) = RootDatabase::with_many_files(
+            r#"
+//- /lib.rs crate:alpha
+pub struct AlphaStruct;
+
+//- /beta.rs crate:beta
+pub struct BetaStruct;
+
+//- /gamma.rs crate:gamma
+pub struct GammaStruct;
+"#,
+        );
+
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(WORKSPACE);
+        LocalRoots::get(&db).set_roots(&mut db).to(local_roots);
+
+        // Sole "::" should return all crates (as module symbols)
+        let query = Query::new("::".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+
+        assert!(names.contains(&"alpha"), "Expected alpha crate in {:?}", names);
+        assert!(names.contains(&"beta"), "Expected beta crate in {:?}", names);
+        assert!(names.contains(&"gamma"), "Expected gamma crate in {:?}", names);
+        assert_eq!(symbols.len(), 3, "Expected exactly 3 crates, got {:?}", names);
+    }
+
+    #[test]
+    fn test_crate_search_fuzzy() {
+        // Test that "::foo" fuzzy-matches crate names
+        let (mut db, _) = RootDatabase::with_many_files(
+            r#"
+//- /lib.rs crate:my_awesome_lib
+pub struct AwesomeStruct;
+
+//- /other.rs crate:another_lib
+pub struct OtherStruct;
+
+//- /foo.rs crate:foobar
+pub struct FooStruct;
+"#,
+        );
+
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(WORKSPACE);
+        LocalRoots::get(&db).set_roots(&mut db).to(local_roots);
+
+        // "::foo" should fuzzy-match crate names containing "foo"
+        let query = Query::new("::foo".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+
+        assert!(names.contains(&"foobar"), "Expected foobar crate in {:?}", names);
+        assert_eq!(symbols.len(), 1, "Expected only foobar crate, got {:?}", names);
+
+        // "::awesome" should match my_awesome_lib
+        let query = Query::new("::awesome".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+
+        assert!(names.contains(&"my_awesome_lib"), "Expected my_awesome_lib crate in {:?}", names);
+        assert_eq!(symbols.len(), 1, "Expected only my_awesome_lib crate, got {:?}", names);
+
+        // "::lib" should match multiple crates
+        let query = Query::new("::lib".to_owned());
+        let symbols = world_symbols(&db, query);
+        let names: Vec<_> = symbols.iter().map(|s| s.name.as_str()).collect();
+
+        assert!(names.contains(&"my_awesome_lib"), "Expected my_awesome_lib in {:?}", names);
+        assert!(names.contains(&"another_lib"), "Expected another_lib in {:?}", names);
+        assert_eq!(symbols.len(), 2, "Expected 2 crates matching 'lib', got {:?}", names);
+
+        // "::nonexistent" should return empty
+        let query = Query::new("::nonexistent".to_owned());
+        let symbols = world_symbols(&db, query);
+        assert!(symbols.is_empty(), "Expected empty results for non-matching crate pattern");
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_doc_alias.txt b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_doc_alias.txt
index 5783d97564d03..0c28c312f83bc 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_doc_alias.txt
+++ b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_doc_alias.txt
@@ -27,11 +27,13 @@
                         kind: STRUCT,
                         range: 83..119,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 109..118,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 109..118,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -62,11 +64,13 @@
                         kind: STRUCT,
                         range: 0..81,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 74..80,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 74..80,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -97,11 +101,13 @@
                         kind: STRUCT,
                         range: 0..81,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 74..80,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 74..80,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -132,11 +138,13 @@
                         kind: STRUCT,
                         range: 0..81,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 74..80,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 74..80,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -167,11 +175,13 @@
                         kind: STRUCT,
                         range: 0..81,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 74..80,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 74..80,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -202,11 +212,13 @@
                         kind: STRUCT,
                         range: 83..119,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 109..118,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 109..118,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -237,11 +249,13 @@
                         kind: STRUCT,
                         range: 0..81,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 74..80,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 74..80,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt
index 7692a7d61abf5..4b588572d328d 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt
+++ b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt
@@ -25,11 +25,13 @@
                         kind: VARIANT,
                         range: 201..202,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 201..202,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 201..202,
+                            },
+                        ),
                     ),
                 },
                 container_name: Some(
@@ -60,11 +62,13 @@
                         kind: TYPE_ALIAS,
                         range: 470..490,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 475..480,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 475..480,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -93,11 +97,13 @@
                         kind: VARIANT,
                         range: 204..205,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 204..205,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 204..205,
+                            },
+                        ),
                     ),
                 },
                 container_name: Some(
@@ -128,11 +134,13 @@
                         kind: CONST,
                         range: 413..434,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 419..424,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 419..424,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -161,11 +169,13 @@
                         kind: CONST,
                         range: 593..665,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 599..615,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 599..615,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -196,11 +206,13 @@
                         kind: ENUM,
                         range: 185..207,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 190..194,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 190..194,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -231,11 +243,13 @@
                         kind: USE_TREE,
                         range: 727..749,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 736..749,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 736..749,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -266,11 +280,13 @@
                         kind: MACRO_DEF,
                         range: 153..168,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 159..164,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 159..164,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -299,11 +315,13 @@
                         kind: STATIC,
                         range: 435..469,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 442..448,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 442..448,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -334,11 +352,13 @@
                         kind: STRUCT,
                         range: 170..184,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 177..183,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 177..183,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -369,11 +389,13 @@
                         kind: STRUCT,
                         range: 0..22,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 6..21,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 6..21,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -404,11 +426,13 @@
                         kind: STRUCT,
                         range: 391..409,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 398..408,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 398..408,
+                            },
+                        ),
                     ),
                 },
                 container_name: Some(
@@ -441,11 +465,13 @@
                         kind: STRUCT,
                         range: 628..654,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 635..653,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 635..653,
+                            },
+                        ),
                     ),
                 },
                 container_name: Some(
@@ -478,11 +504,13 @@
                         kind: STRUCT,
                         range: 552..580,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 559..579,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 559..579,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -513,11 +541,13 @@
                         kind: STRUCT,
                         range: 261..279,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 268..275,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 268..275,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -546,11 +576,13 @@
                         kind: TRAIT,
                         range: 334..373,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 340..345,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 340..345,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -581,11 +613,13 @@
                         kind: USE_TREE,
                         range: 755..769,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 764..769,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 764..769,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -616,11 +650,13 @@
                         kind: UNION,
                         range: 208..222,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 214..219,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 214..219,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -649,11 +685,13 @@
                         kind: MODULE,
                         range: 492..530,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 496..501,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 496..501,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -682,11 +720,13 @@
                         kind: MODULE,
                         range: 667..677,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 671..676,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 671..676,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -717,11 +757,13 @@
                         kind: MACRO_RULES,
                         range: 51..131,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 64..77,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 64..77,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -750,11 +792,13 @@
                         kind: FN,
                         range: 307..330,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 310..325,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 310..325,
+                            },
+                        ),
                     ),
                 },
                 container_name: Some(
@@ -785,11 +829,13 @@
                         kind: FN,
                         range: 242..257,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 245..252,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 245..252,
+                            },
+                        ),
                     ),
                 },
                 container_name: Some(
@@ -822,11 +868,13 @@
                         kind: MACRO_RULES,
                         range: 1..48,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 14..31,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 14..31,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -855,11 +903,13 @@
                         kind: FN,
                         range: 375..411,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 378..382,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 378..382,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -890,11 +940,13 @@
                         kind: USE_TREE,
                         range: 684..721,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 701..721,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 701..721,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -923,11 +975,13 @@
                         kind: FN,
                         range: 352..371,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 355..363,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 355..363,
+                            },
+                        ),
                     ),
                 },
                 container_name: Some(
@@ -969,11 +1023,13 @@
                         kind: STRUCT,
                         range: 508..528,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 515..527,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 515..527,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -1011,11 +1067,13 @@
                         kind: USE_TREE,
                         range: 141..173,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 157..173,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 157..173,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -1046,11 +1104,13 @@
                         kind: USE_TREE,
                         range: 141..173,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 157..173,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 157..173,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -1081,11 +1141,13 @@
                         kind: STRUCT,
                         range: 0..20,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 7..19,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 7..19,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -1116,11 +1178,13 @@
                         kind: USE_TREE,
                         range: 35..69,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 51..69,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 51..69,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
@@ -1151,11 +1215,13 @@
                         kind: USE_TREE,
                         range: 85..125,
                     },
-                    name_ptr: AstPtr(
-                        SyntaxNodePtr {
-                            kind: NAME,
-                            range: 115..125,
-                        },
+                    name_ptr: Some(
+                        AstPtr(
+                            SyntaxNodePtr {
+                                kind: NAME,
+                                range: 115..125,
+                            },
+                        ),
                     ),
                 },
                 container_name: None,
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt
index 6f5f8f889c7dd..87f0c7d9a8170 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt
+++ b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt
@@ -20,11 +20,13 @@
                 kind: STRUCT,
                 range: 0..15,
             },
-            name_ptr: AstPtr(
-                SyntaxNodePtr {
-                    kind: NAME,
-                    range: 11..14,
-                },
+            name_ptr: Some(
+                AstPtr(
+                    SyntaxNodePtr {
+                        kind: NAME,
+                        range: 11..14,
+                    },
+                ),
             ),
         },
         container_name: None,
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_with_imports.txt b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_with_imports.txt
index 5d3fe4d2658d6..e96aa889ba065 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_with_imports.txt
+++ b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_with_imports.txt
@@ -20,11 +20,13 @@
                 kind: STRUCT,
                 range: 0..15,
             },
-            name_ptr: AstPtr(
-                SyntaxNodePtr {
-                    kind: NAME,
-                    range: 11..14,
-                },
+            name_ptr: Some(
+                AstPtr(
+                    SyntaxNodePtr {
+                        kind: NAME,
+                        range: 11..14,
+                    },
+                ),
             ),
         },
         container_name: None,
@@ -55,11 +57,13 @@
                 kind: USE_TREE,
                 range: 17..25,
             },
-            name_ptr: AstPtr(
-                SyntaxNodePtr {
-                    kind: NAME_REF,
-                    range: 22..25,
-                },
+            name_ptr: Some(
+                AstPtr(
+                    SyntaxNodePtr {
+                        kind: NAME_REF,
+                        range: 22..25,
+                    },
+                ),
             ),
         },
         container_name: None,
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
index b07f9e68f6341..5cb710b66b5fa 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
@@ -100,4 +100,19 @@ fn foo<T: Fn(WithLifetime) -> WithLifetime>() {}
         "#,
         );
     }
+
+    #[test]
+    fn regression_21430() {
+        check_diagnostics(
+            r#"
+struct S {
+    f: fn(A<()>),
+}
+
+struct A<'a, T> {
+    a: &'a T,
+}
+        "#,
+        );
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide/src/expand_macro.rs b/src/tools/rust-analyzer/crates/ide/src/expand_macro.rs
index 7d02b8091890a..ba8b3aa9cafea 100644
--- a/src/tools/rust-analyzer/crates/ide/src/expand_macro.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/expand_macro.rs
@@ -583,26 +583,16 @@ fn main() {
     fn macro_expand_derive() {
         check(
             r#"
-//- proc_macros: identity
-//- minicore: clone, derive
+//- proc_macros: identity, derive_identity
+//- minicore: derive
 
 #[proc_macros::identity]
-#[derive(C$0lone)]
+#[derive(proc_macros::DeriveIde$0ntity)]
 struct Foo {}
 "#,
             expect![[r#"
-                Clone
-                impl <>core::clone::Clone for Foo< >where {
-                    fn clone(&self) -> Self {
-                        match self {
-                            Foo{}
-                             => Foo{}
-                            ,
-
-                            }
-                    }
-
-                    }"#]],
+                proc_macros::DeriveIdentity
+                struct Foo{}"#]],
         );
     }
 
@@ -610,15 +600,17 @@ struct Foo {}
     fn macro_expand_derive2() {
         check(
             r#"
-//- minicore: copy, clone, derive
+//- proc_macros: derive_identity
+//- minicore: derive
 
-#[derive(Cop$0y)]
-#[derive(Clone)]
+#[derive(proc_macros::$0DeriveIdentity)]
+#[derive(proc_macros::DeriveIdentity)]
 struct Foo {}
 "#,
             expect![[r#"
-                Copy
-                impl <>core::marker::Copy for Foo< >where{}"#]],
+                proc_macros::DeriveIdentity
+                #[derive(proc_macros::DeriveIdentity)]
+                struct Foo{}"#]],
         );
     }
 
@@ -626,35 +618,27 @@ struct Foo {}
     fn macro_expand_derive_multi() {
         check(
             r#"
-//- minicore: copy, clone, derive
+//- proc_macros: derive_identity
+//- minicore: derive
 
-#[derive(Cop$0y, Clone)]
+#[derive(proc_macros::DeriveIdent$0ity, proc_macros::DeriveIdentity)]
 struct Foo {}
 "#,
             expect![[r#"
-                Copy
-                impl <>core::marker::Copy for Foo< >where{}"#]],
+                proc_macros::DeriveIdentity
+                struct Foo{}"#]],
         );
         check(
             r#"
-//- minicore: copy, clone, derive
+//- proc_macros: derive_identity
+//- minicore: derive
 
-#[derive(Copy, Cl$0one)]
+#[derive(proc_macros::DeriveIdentity, proc_macros::De$0riveIdentity)]
 struct Foo {}
 "#,
             expect![[r#"
-                Clone
-                impl <>core::clone::Clone for Foo< >where {
-                    fn clone(&self) -> Self {
-                        match self {
-                            Foo{}
-                             => Foo{}
-                            ,
-
-                            }
-                    }
-
-                    }"#]],
+                proc_macros::DeriveIdentity
+                struct Foo{}"#]],
         );
     }
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
index a271cac6fcd07..185df92e2d39d 100644
--- a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
@@ -19,7 +19,7 @@ use ide_db::{
 };
 use stdx::never;
 use syntax::{
-    AstNode, SyntaxNode, TextRange,
+    AstNode, AstPtr, SyntaxNode, TextRange,
     ast::{self, HasName},
 };
 
@@ -253,7 +253,7 @@ impl<'db> TryToNav for FileSymbol<'db> {
                 db,
                 self.loc.hir_file_id,
                 self.loc.ptr.text_range(),
-                Some(self.loc.name_ptr.text_range()),
+                self.loc.name_ptr.map(AstPtr::text_range),
             )
             .map(|(FileRange { file_id, range: full_range }, focus_range)| {
                 NavigationTarget {
@@ -264,7 +264,7 @@ impl<'db> TryToNav for FileSymbol<'db> {
                         .flatten()
                         .map_or_else(|| self.name.clone(), |it| it.symbol().clone()),
                     alias: self.is_alias.then(|| self.name.clone()),
-                    kind: Some(self.def.into()),
+                    kind: Some(SymbolKind::from_module_def(db, self.def)),
                     full_range,
                     focus_range,
                     container_name: self.container_name.clone(),
@@ -480,16 +480,11 @@ impl ToNav for hir::Module {
             ModuleSource::Module(node) => (node.syntax(), node.name()),
             ModuleSource::BlockExpr(node) => (node.syntax(), None),
         };
+        let kind = if self.is_crate_root(db) { SymbolKind::CrateRoot } else { SymbolKind::Module };
 
         orig_range_with_focus(db, file_id, syntax, focus).map(
             |(FileRange { file_id, range: full_range }, focus_range)| {
-                NavigationTarget::from_syntax(
-                    file_id,
-                    name.clone(),
-                    focus_range,
-                    full_range,
-                    SymbolKind::Module,
-                )
+                NavigationTarget::from_syntax(file_id, name.clone(), focus_range, full_range, kind)
             },
         )
     }
@@ -549,7 +544,7 @@ impl TryToNav for hir::ExternCrateDecl {
                     self.alias_or_name(db).unwrap_or_else(|| self.name(db)).symbol().clone(),
                     focus_range,
                     full_range,
-                    SymbolKind::Module,
+                    SymbolKind::CrateRoot,
                 );
 
                 res.docs = self.docs(db).map(Documentation::into_owned);
diff --git a/src/tools/rust-analyzer/crates/ide/src/references.rs b/src/tools/rust-analyzer/crates/ide/src/references.rs
index 4918fe4ff9a47..5443021988d45 100644
--- a/src/tools/rust-analyzer/crates/ide/src/references.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/references.rs
@@ -1079,7 +1079,7 @@ use self$0;
 use self$0;
 "#,
             expect![[r#"
-                _ Module FileId(0) 0..10
+                _ CrateRoot FileId(0) 0..10
 
                 FileId(0) 4..8 import
             "#]],
diff --git a/src/tools/rust-analyzer/crates/ide/src/runnables.rs b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
index 6cec912503515..42efa7142b50b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/runnables.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
@@ -815,7 +815,7 @@ mod not_a_root {
 "#,
             expect![[r#"
                 [
-                    "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 0..331, name: \"_\", kind: Module })",
+                    "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 0..331, name: \"_\", kind: CrateRoot })",
                     "(Bin, NavigationTarget { file_id: FileId(0), full_range: 1..13, focus_range: 4..8, name: \"main\", kind: Function })",
                     "(Bin, NavigationTarget { file_id: FileId(0), full_range: 15..76, focus_range: 42..71, name: \"__cortex_m_rt_main_trampoline\", kind: Function })",
                     "(Bin, NavigationTarget { file_id: FileId(0), full_range: 78..154, focus_range: 113..149, name: \"__cortex_m_rt_main_trampoline_unsafe\", kind: Function })",
@@ -1136,7 +1136,7 @@ fn test_foo1() {}
 "#,
             expect![[r#"
                 [
-                    "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 0..51, name: \"_\", kind: Module })",
+                    "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 0..51, name: \"_\", kind: CrateRoot })",
                     "(Test, NavigationTarget { file_id: FileId(0), full_range: 1..50, focus_range: 36..45, name: \"test_foo1\", kind: Function }, Atom(KeyValue { key: \"feature\", value: \"foo\" }))",
                 ]
             "#]],
@@ -1155,7 +1155,7 @@ fn test_foo1() {}
 "#,
             expect![[r#"
                 [
-                    "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 0..73, name: \"_\", kind: Module })",
+                    "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 0..73, name: \"_\", kind: CrateRoot })",
                     "(Test, NavigationTarget { file_id: FileId(0), full_range: 1..72, focus_range: 58..67, name: \"test_foo1\", kind: Function }, All([Atom(KeyValue { key: \"feature\", value: \"foo\" }), Atom(KeyValue { key: \"feature\", value: \"bar\" })]))",
                 ]
             "#]],
@@ -1234,7 +1234,7 @@ generate_main!();
 "#,
             expect![[r#"
                 [
-                    "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 0..345, name: \"_\", kind: Module })",
+                    "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 0..345, name: \"_\", kind: CrateRoot })",
                     "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 282..312, focus_range: 286..291, name: \"tests\", kind: Module, description: \"mod tests\" })",
                     "(Test, NavigationTarget { file_id: FileId(0), full_range: 298..307, name: \"foo_test\", kind: Function })",
                     "(TestMod, NavigationTarget { file_id: FileId(0), full_range: 313..323, name: \"tests2\", kind: Module, description: \"mod tests2\" }, true)",
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
index e7c5f95a250ee..e64fd6488f2a6 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
@@ -513,21 +513,21 @@ fn string_injections(
             );
 
             if !string.is_raw() {
-                highlight_escape_string(hl, &string);
+                highlight_escape_string(hl, config, &string);
             }
         }
     } else if let Some(byte_string) = ast::ByteString::cast(token.clone()) {
         if !byte_string.is_raw() {
-            highlight_escape_string(hl, &byte_string);
+            highlight_escape_string(hl, config, &byte_string);
         }
     } else if let Some(c_string) = ast::CString::cast(token.clone()) {
         if !c_string.is_raw() {
-            highlight_escape_string(hl, &c_string);
+            highlight_escape_string(hl, config, &c_string);
         }
     } else if let Some(char) = ast::Char::cast(token.clone()) {
-        highlight_escape_char(hl, &char)
+        highlight_escape_char(hl, config, &char)
     } else if let Some(byte) = ast::Byte::cast(token) {
-        highlight_escape_byte(hl, &byte)
+        highlight_escape_byte(hl, config, &byte)
     }
     ControlFlow::Continue(())
 }
@@ -586,7 +586,11 @@ fn descend_token(
 
 fn filter_by_config(highlight: &mut Highlight, config: &HighlightConfig<'_>) -> bool {
     match &mut highlight.tag {
-        HlTag::StringLiteral if !config.strings => return false,
+        HlTag::StringLiteral | HlTag::EscapeSequence | HlTag::InvalidEscapeSequence
+            if !config.strings =>
+        {
+            return false;
+        }
         HlTag::Comment if !config.comments => return false,
         // If punctuation is disabled, make the macro bang part of the macro call again.
         tag @ HlTag::Punctuation(HlPunct::MacroBang) => {
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/escape.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/escape.rs
index 094f88f3a8641..4da69cc43d9ec 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/escape.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/escape.rs
@@ -1,10 +1,14 @@
 //! Syntax highlighting for escape sequences
 use crate::syntax_highlighting::highlights::Highlights;
-use crate::{HlRange, HlTag};
+use crate::{HighlightConfig, HlRange, HlTag};
 use syntax::ast::{Byte, Char, IsString};
 use syntax::{AstToken, TextRange, TextSize};
 
-pub(super) fn highlight_escape_string<T: IsString>(stack: &mut Highlights, string: &T) {
+pub(super) fn highlight_escape_string<T: IsString>(
+    stack: &mut Highlights,
+    config: &HighlightConfig<'_>,
+    string: &T,
+) {
     let text = string.text();
     let start = string.syntax().text_range().start();
     string.escaped_char_ranges(&mut |piece_range, char| {
@@ -13,16 +17,23 @@ pub(super) fn highlight_escape_string<T: IsString>(stack: &mut Highlights, strin
                 Ok(_) => HlTag::EscapeSequence,
                 Err(_) => HlTag::InvalidEscapeSequence,
             };
-            stack.add(HlRange {
-                range: piece_range + start,
-                highlight: highlight.into(),
-                binding_hash: None,
-            });
+            stack.add_with(
+                config,
+                HlRange {
+                    range: piece_range + start,
+                    highlight: highlight.into(),
+                    binding_hash: None,
+                },
+            );
         }
     });
 }
 
-pub(super) fn highlight_escape_char(stack: &mut Highlights, char: &Char) {
+pub(super) fn highlight_escape_char(
+    stack: &mut Highlights,
+    config: &HighlightConfig<'_>,
+    char: &Char,
+) {
     if char.value().is_err() {
         // We do not emit invalid escapes highlighting here. The lexer would likely be in a bad
         // state and this token contains junk, since `'` is not a reliable delimiter (consider
@@ -43,10 +54,17 @@ pub(super) fn highlight_escape_char(stack: &mut Highlights, char: &Char) {
         char.syntax().text_range().start() + TextSize::from(1),
         TextSize::from(text.len() as u32),
     );
-    stack.add(HlRange { range, highlight: HlTag::EscapeSequence.into(), binding_hash: None })
+    stack.add_with(
+        config,
+        HlRange { range, highlight: HlTag::EscapeSequence.into(), binding_hash: None },
+    )
 }
 
-pub(super) fn highlight_escape_byte(stack: &mut Highlights, byte: &Byte) {
+pub(super) fn highlight_escape_byte(
+    stack: &mut Highlights,
+    config: &HighlightConfig<'_>,
+    byte: &Byte,
+) {
     if byte.value().is_err() {
         // See `highlight_escape_char` for why no error highlighting here.
         return;
@@ -65,5 +83,8 @@ pub(super) fn highlight_escape_byte(stack: &mut Highlights, byte: &Byte) {
         byte.syntax().text_range().start() + TextSize::from(2),
         TextSize::from(text.len() as u32),
     );
-    stack.add(HlRange { range, highlight: HlTag::EscapeSequence.into(), binding_hash: None })
+    stack.add_with(
+        config,
+        HlRange { range, highlight: HlTag::EscapeSequence.into(), binding_hash: None },
+    )
 }
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs
index 044fd3f5ac9a8..dcc9a8c0d5f70 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs
@@ -399,7 +399,7 @@ fn highlight_name_ref(
             highlight_def(sema, krate, field_ref.into(), edition, true)
         }
         NameRefClass::ExternCrateShorthand { decl, krate: resolved_krate } => {
-            let mut h = HlTag::Symbol(SymbolKind::Module).into();
+            let mut h = HlTag::Symbol(SymbolKind::CrateRoot).into();
 
             if krate.as_ref().is_some_and(|krate| resolved_krate != *krate) {
                 h |= HlMod::Library;
@@ -417,7 +417,6 @@ fn highlight_name_ref(
             if is_deprecated {
                 h |= HlMod::Deprecated;
             }
-            h |= HlMod::CrateRoot;
             h
         }
     };
@@ -495,16 +494,15 @@ pub(super) fn highlight_def(
             (Highlight::new(HlTag::Symbol(SymbolKind::Field)), Some(field.attrs(sema.db)))
         }
         Definition::TupleField(_) => (Highlight::new(HlTag::Symbol(SymbolKind::Field)), None),
-        Definition::Crate(krate) => (
-            Highlight::new(HlTag::Symbol(SymbolKind::Module)) | HlMod::CrateRoot,
-            Some(krate.attrs(sema.db)),
-        ),
+        Definition::Crate(krate) => {
+            (Highlight::new(HlTag::Symbol(SymbolKind::CrateRoot)), Some(krate.attrs(sema.db)))
+        }
         Definition::Module(module) => {
-            let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Module));
-            if module.is_crate_root(db) {
-                h |= HlMod::CrateRoot;
-            }
-
+            let h = Highlight::new(HlTag::Symbol(if module.is_crate_root(db) {
+                SymbolKind::CrateRoot
+            } else {
+                SymbolKind::Module
+            }));
             (h, Some(module.attrs(sema.db)))
         }
         Definition::Function(func) => {
@@ -662,8 +660,7 @@ pub(super) fn highlight_def(
             (h, None)
         }
         Definition::ExternCrateDecl(extern_crate) => {
-            let mut highlight =
-                Highlight::new(HlTag::Symbol(SymbolKind::Module)) | HlMod::CrateRoot;
+            let mut highlight = Highlight::new(HlTag::Symbol(SymbolKind::CrateRoot));
             if extern_crate.alias(db).is_none() {
                 highlight |= HlMod::Library;
             }
@@ -805,6 +802,7 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
         TYPE_PARAM => SymbolKind::TypeParam,
         RECORD_FIELD => SymbolKind::Field,
         MODULE => SymbolKind::Module,
+        EXTERN_CRATE => SymbolKind::CrateRoot,
         FN => SymbolKind::Function,
         CONST => SymbolKind::Const,
         STATIC => SymbolKind::Static,
@@ -835,7 +833,7 @@ fn highlight_name_ref_by_syntax(
     };
 
     match parent.kind() {
-        EXTERN_CRATE => HlTag::Symbol(SymbolKind::Module) | HlMod::CrateRoot,
+        EXTERN_CRATE => HlTag::Symbol(SymbolKind::CrateRoot).into(),
         METHOD_CALL_EXPR => ast::MethodCallExpr::cast(parent)
             .and_then(|it| highlight_method_call(sema, krate, &it, is_unsafe_node))
             .unwrap_or_else(|| SymbolKind::Method.into()),
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlights.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlights.rs
index 340290eafedbe..6fe4d08443389 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlights.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlights.rs
@@ -4,7 +4,7 @@ use std::iter;
 use stdx::equal_range_by;
 use syntax::TextRange;
 
-use crate::{HlRange, HlTag};
+use crate::{HighlightConfig, HlRange, HlTag};
 
 pub(super) struct Highlights {
     root: Node,
@@ -26,6 +26,12 @@ impl Highlights {
         self.root.add(hl_range);
     }
 
+    pub(super) fn add_with(&mut self, config: &HighlightConfig<'_>, mut hl_range: HlRange) {
+        if super::filter_by_config(&mut hl_range.highlight, config) {
+            self.root.add(hl_range);
+        }
+    }
+
     pub(super) fn to_vec(&self) -> Vec<HlRange> {
         let mut res = Vec::new();
         self.root.flatten(&mut res);
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
index 26d2bb5e02884..291333f09cf88 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
@@ -1,6 +1,6 @@
 //! "Recursive" Syntax highlighting for code in doctests and fixtures.
 
-use hir::{EditionedFileId, HirFileId, InFile, Semantics};
+use hir::{EditionedFileId, HirFileId, InFile, Semantics, db::HirDatabase};
 use ide_db::{
     SymbolKind, defs::Definition, documentation::Documentation, range_mapper::RangeMapper,
     rust_doc::is_rust_fence,
@@ -109,7 +109,7 @@ pub(super) fn doc_comment(
         .for_each(|(range, def)| {
             hl.add(HlRange {
                 range,
-                highlight: module_def_to_hl_tag(def)
+                highlight: module_def_to_hl_tag(sema.db, def)
                     | HlMod::Documentation
                     | HlMod::Injected
                     | HlMod::IntraDocLink,
@@ -200,11 +200,11 @@ pub(super) fn doc_comment(
     }
 }
 
-fn module_def_to_hl_tag(def: Definition) -> HlTag {
+fn module_def_to_hl_tag(db: &dyn HirDatabase, def: Definition) -> HlTag {
     let symbol = match def {
-        Definition::Module(_) | Definition::Crate(_) | Definition::ExternCrateDecl(_) => {
-            SymbolKind::Module
-        }
+        Definition::Crate(_) | Definition::ExternCrateDecl(_) => SymbolKind::CrateRoot,
+        Definition::Module(m) if m.is_crate_root(db) => SymbolKind::CrateRoot,
+        Definition::Module(_) => SymbolKind::Module,
         Definition::Function(_) => SymbolKind::Function,
         Definition::Adt(hir::Adt::Struct(_)) => SymbolKind::Struct,
         Definition::Adt(hir::Adt::Enum(_)) => SymbolKind::Enum,
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs
index ca3c3e3aaace1..0c64d3de1012b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs
@@ -144,6 +144,7 @@ impl HlTag {
                 SymbolKind::BuiltinAttr => "builtin_attr",
                 SymbolKind::Const => "constant",
                 SymbolKind::ConstParam => "const_param",
+                SymbolKind::CrateRoot => "crate_root",
                 SymbolKind::Derive => "derive",
                 SymbolKind::DeriveHelper => "derive_helper",
                 SymbolKind::Enum => "enum",
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_asm.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_asm.html
index 100fdd2155a40..1228849c5bfd2 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_asm.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_asm.html
@@ -45,7 +45,7 @@
     <span class="keyword unsafe">unsafe</span> <span class="brace">{</span>
         <span class="keyword">let</span> <span class="variable declaration">foo</span> <span class="operator">=</span> <span class="numeric_literal">1</span><span class="semicolon">;</span>
         <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">o</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>
-        <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span>
+        <span class="crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span>
             <span class="string_literal macro">"%input = OpLoad _ {</span><span class="variable">0</span><span class="string_literal macro">}"</span><span class="comma macro">,</span>
             <span class="macro default_library library macro">concat</span><span class="macro_bang macro">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"%result = "</span><span class="comma macro">,</span> <span class="string_literal macro">"bar"</span><span class="comma macro">,</span> <span class="string_literal macro">" _ %input"</span><span class="parenthesis macro">)</span><span class="comma macro">,</span>
             <span class="string_literal macro">"OpStore {</span><span class="variable">1</span><span class="string_literal macro">} %result"</span><span class="comma macro">,</span>
@@ -54,7 +54,7 @@
         <span class="parenthesis unsafe">)</span><span class="semicolon">;</span>
 
         <span class="keyword">let</span> <span class="variable declaration">thread_id</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="semicolon">;</span>
-        <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span><span class="string_literal macro">"
+        <span class="crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span><span class="string_literal macro">"
             mov {</span><span class="variable">0</span><span class="string_literal macro">}, gs:[0x30]
             mov {</span><span class="variable">0</span><span class="string_literal macro">}, [{</span><span class="variable">0</span><span class="string_literal macro">}+0x48]
         "</span><span class="comma macro">,</span> <span class="keyword macro">out</span><span class="parenthesis macro">(</span><span class="reg library macro">reg</span><span class="parenthesis macro">)</span> <span class="variable macro">thread_id</span><span class="comma macro">,</span> <span class="keyword macro">options</span><span class="parenthesis macro">(</span><span class="keyword macro">pure</span><span class="comma macro">,</span> <span class="keyword macro">readonly</span><span class="comma macro">,</span> <span class="keyword macro">nostack</span><span class="parenthesis macro">)</span><span class="parenthesis unsafe">)</span><span class="semicolon">;</span>
@@ -64,7 +64,7 @@
         <span class="keyword">static</span> <span class="static declaration">VirtualFree</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="semicolon">;</span>
         <span class="keyword const">const</span> <span class="constant const declaration">OffPtr</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="semicolon">;</span>
         <span class="keyword const">const</span> <span class="constant const declaration">OffFn</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="semicolon">;</span>
-        <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span><span class="string_literal macro">"
+        <span class="crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span><span class="string_literal macro">"
             push {</span><span class="variable">free_type</span><span class="string_literal macro">}
             push {</span><span class="variable">free_size</span><span class="string_literal macro">}
             push {</span><span class="variable">base</span><span class="string_literal macro">}
@@ -97,7 +97,7 @@
     <span class="comment">// Ensure thumb mode is set.</span>
     <span class="keyword">let</span> <span class="variable declaration">rv</span> <span class="operator">=</span> <span class="parenthesis">(</span><span class="value_param">rv</span> <span class="keyword">as</span> <span class="builtin_type">u32</span><span class="parenthesis">)</span> <span class="bitwise">|</span> <span class="numeric_literal">1</span><span class="semicolon">;</span>
     <span class="keyword">let</span> <span class="variable declaration">msp</span> <span class="operator">=</span> <span class="value_param">msp</span> <span class="keyword">as</span> <span class="builtin_type">u32</span><span class="semicolon">;</span>
-    <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span>
+    <span class="crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span>
         <span class="string_literal macro">"mrs {</span><span class="variable">tmp</span><span class="string_literal macro">}, CONTROL"</span><span class="comma macro">,</span>
         <span class="string_literal macro">"bics {</span><span class="variable">tmp</span><span class="string_literal macro">}, {</span><span class="variable">spsel</span><span class="string_literal macro">}"</span><span class="comma macro">,</span>
         <span class="string_literal macro">"msr CONTROL, {</span><span class="variable">tmp</span><span class="string_literal macro">}"</span><span class="comma macro">,</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_attributes.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_attributes.html
index b151ff42fc390..fa7f7b1cbafbe 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_attributes.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_attributes.html
@@ -43,7 +43,7 @@
 </style>
 <pre><code><span class="attribute_bracket attribute macro proc_macro">#</span><span class="attribute_bracket attribute macro proc_macro">[</span><span class="builtin_attr attribute macro proc_macro">allow</span><span class="parenthesis attribute macro proc_macro">(</span><span class="none attribute macro proc_macro">dead_code</span><span class="parenthesis attribute macro proc_macro">)</span><span class="attribute_bracket attribute macro proc_macro">]</span>
 <span class="attribute_bracket attribute macro proc_macro">#</span><span class="attribute_bracket attribute macro proc_macro">[</span><span class="tool_module attribute macro proc_macro">rustfmt</span><span class="operator attribute macro proc_macro">::</span><span class="tool_module attribute macro proc_macro">skip</span><span class="attribute_bracket attribute macro proc_macro">]</span>
-<span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="module attribute crate_root library">proc_macros</span><span class="operator attribute">::</span><span class="attribute attribute library">identity</span><span class="attribute_bracket attribute">]</span>
+<span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="crate_root attribute library">proc_macros</span><span class="operator attribute">::</span><span class="attribute attribute library">identity</span><span class="attribute_bracket attribute">]</span>
 <span class="attribute_bracket attribute macro proc_macro">#</span><span class="attribute_bracket attribute macro proc_macro">[</span><span class="attribute attribute default_library library macro proc_macro">derive</span><span class="parenthesis attribute macro proc_macro">(</span><span class="derive attribute default_library library macro">Default</span><span class="parenthesis attribute macro proc_macro">)</span><span class="attribute_bracket attribute macro proc_macro">]</span>
 <span class="comment documentation">/// This is a doc comment</span>
 <span class="comment">// This is a normal comment</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_crate_root.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_crate_root.html
index a6e6b16bead51..0b32cedca5d8b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_crate_root.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_crate_root.html
@@ -41,25 +41,25 @@
 .invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root library">foo</span><span class="semicolon">;</span>
-<span class="keyword">use</span> <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">iter</span><span class="semicolon">;</span>
+<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="crate_root library">foo</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">iter</span><span class="semicolon">;</span>
 
 <span class="keyword">pub</span> <span class="keyword const">const</span> <span class="constant const declaration public">NINETY_TWO</span><span class="colon">:</span> <span class="builtin_type">u8</span> <span class="operator">=</span> <span class="numeric_literal">92</span><span class="semicolon">;</span>
 
-<span class="keyword">use</span> <span class="module crate_root library">foo</span> <span class="keyword">as</span> <span class="module crate_root declaration library">foooo</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="crate_root library">foo</span> <span class="keyword">as</span> <span class="crate_root declaration library">foooo</span><span class="semicolon">;</span>
 
-<span class="keyword">pub</span><span class="parenthesis">(</span><span class="keyword crate_root public">crate</span><span class="parenthesis">)</span> <span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+<span class="keyword">pub</span><span class="parenthesis">(</span><span class="keyword public">crate</span><span class="parenthesis">)</span> <span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
     <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="module default_library library">iter</span><span class="operator">::</span><span class="function default_library library">repeat</span><span class="parenthesis">(</span><span class="numeric_literal">92</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 
 <span class="keyword">mod</span> <span class="module declaration">bar</span> <span class="brace">{</span>
-    <span class="keyword">pub</span><span class="parenthesis">(</span><span class="keyword control">in</span> <span class="keyword crate_root public">super</span><span class="parenthesis">)</span> <span class="keyword const">const</span> <span class="constant const declaration">FORTY_TWO</span><span class="colon">:</span> <span class="builtin_type">u8</span> <span class="operator">=</span> <span class="numeric_literal">42</span><span class="semicolon">;</span>
+    <span class="keyword">pub</span><span class="parenthesis">(</span><span class="keyword control">in</span> <span class="keyword public">super</span><span class="parenthesis">)</span> <span class="keyword const">const</span> <span class="constant const declaration">FORTY_TWO</span><span class="colon">:</span> <span class="builtin_type">u8</span> <span class="operator">=</span> <span class="numeric_literal">42</span><span class="semicolon">;</span>
 
     <span class="keyword">mod</span> <span class="module declaration">baz</span> <span class="brace">{</span>
-        <span class="keyword">use</span> <span class="keyword">super</span><span class="operator">::</span><span class="keyword crate_root public">super</span><span class="operator">::</span><span class="constant const public">NINETY_TWO</span><span class="semicolon">;</span>
-        <span class="keyword">use</span> <span class="keyword crate_root public">crate</span><span class="operator">::</span><span class="module crate_root library">foooo</span><span class="operator">::</span><span class="struct library">Point</span><span class="semicolon">;</span>
+        <span class="keyword">use</span> <span class="keyword">super</span><span class="operator">::</span><span class="keyword public">super</span><span class="operator">::</span><span class="constant const public">NINETY_TWO</span><span class="semicolon">;</span>
+        <span class="keyword">use</span> <span class="keyword public">crate</span><span class="operator">::</span><span class="crate_root library">foooo</span><span class="operator">::</span><span class="struct library">Point</span><span class="semicolon">;</span>
 
-        <span class="keyword">pub</span><span class="parenthesis">(</span><span class="keyword control">in</span> <span class="keyword">super</span><span class="operator">::</span><span class="keyword crate_root public">super</span><span class="parenthesis">)</span> <span class="keyword const">const</span> <span class="constant const declaration">TWENTY_NINE</span><span class="colon">:</span> <span class="builtin_type">u8</span> <span class="operator">=</span> <span class="numeric_literal">29</span><span class="semicolon">;</span>
+        <span class="keyword">pub</span><span class="parenthesis">(</span><span class="keyword control">in</span> <span class="keyword">super</span><span class="operator">::</span><span class="keyword public">super</span><span class="parenthesis">)</span> <span class="keyword const">const</span> <span class="constant const declaration">TWENTY_NINE</span><span class="colon">:</span> <span class="builtin_type">u8</span> <span class="operator">=</span> <span class="numeric_literal">29</span><span class="semicolon">;</span>
     <span class="brace">}</span>
 <span class="brace">}</span>
 </code></pre>
\ No newline at end of file
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_default_library.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_default_library.html
index 2f4a2004f1de6..29f78959a54f1 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_default_library.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_default_library.html
@@ -41,7 +41,7 @@
 .invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">use</span> <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">iter</span><span class="semicolon">;</span>
+<pre><code><span class="keyword">use</span> <span class="crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">iter</span><span class="semicolon">;</span>
 
 <span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
     <span class="keyword">let</span> <span class="variable declaration">foo</span> <span class="operator">=</span> <span class="enum_variant default_library library">Some</span><span class="parenthesis">(</span><span class="numeric_literal">92</span><span class="parenthesis">)</span><span class="semicolon">;</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_deprecated.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_deprecated.html
index 41d3dff8ed9e8..5287affbfc5c1 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_deprecated.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_deprecated.html
@@ -42,8 +42,8 @@
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">!</span><span class="attribute_bracket attribute">[</span><span class="builtin_attr attribute">deprecated</span><span class="attribute_bracket attribute">]</span>
-<span class="keyword">use</span> <span class="keyword crate_root deprecated public">crate</span> <span class="keyword">as</span> <span class="punctuation">_</span><span class="semicolon">;</span>
-<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root deprecated library">bar</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="keyword deprecated public">crate</span> <span class="keyword">as</span> <span class="punctuation">_</span><span class="semicolon">;</span>
+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="crate_root deprecated library">bar</span><span class="semicolon">;</span>
 <span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="builtin_attr attribute">deprecated</span><span class="attribute_bracket attribute">]</span>
 <span class="keyword">macro_rules</span><span class="macro_bang">!</span> <span class="macro declaration deprecated public">macro_</span> <span class="brace">{</span>
     <span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">=</span><span class="operator">&gt;</span> <span class="brace">{</span><span class="brace">}</span><span class="semicolon">;</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index b5c3df6ee447f..ce9ec7431a975 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -48,9 +48,9 @@
 
 <span class="comment documentation">//! Syntactic name ref highlighting testing</span>
 <span class="comment documentation">//! ```rust</span>
-<span class="comment documentation">//! </span><span class="keyword injected">extern</span><span class="none injected"> </span><span class="keyword injected">crate</span><span class="none injected"> </span><span class="self_keyword crate_root injected">self</span><span class="semicolon injected">;</span>
-<span class="comment documentation">//! </span><span class="keyword injected">extern</span><span class="none injected"> </span><span class="keyword injected">crate</span><span class="none injected"> </span><span class="module crate_root injected">other</span><span class="none injected"> </span><span class="keyword injected">as</span><span class="none injected"> </span><span class="module crate_root declaration injected">otter</span><span class="semicolon injected">;</span>
-<span class="comment documentation">//! </span><span class="keyword injected">extern</span><span class="none injected"> </span><span class="keyword injected">crate</span><span class="none injected"> </span><span class="module crate_root injected">core</span><span class="semicolon injected">;</span>
+<span class="comment documentation">//! </span><span class="keyword injected">extern</span><span class="none injected"> </span><span class="keyword injected">crate</span><span class="none injected"> </span><span class="self_keyword injected">self</span><span class="semicolon injected">;</span>
+<span class="comment documentation">//! </span><span class="keyword injected">extern</span><span class="none injected"> </span><span class="keyword injected">crate</span><span class="none injected"> </span><span class="crate_root injected">other</span><span class="none injected"> </span><span class="keyword injected">as</span><span class="none injected"> </span><span class="crate_root declaration injected">otter</span><span class="semicolon injected">;</span>
+<span class="comment documentation">//! </span><span class="keyword injected">extern</span><span class="none injected"> </span><span class="keyword injected">crate</span><span class="none injected"> </span><span class="crate_root injected">core</span><span class="semicolon injected">;</span>
 <span class="comment documentation">//! </span><span class="keyword injected">trait</span><span class="none injected"> </span><span class="trait declaration injected">T</span><span class="none injected"> </span><span class="brace injected">{</span><span class="none injected"> </span><span class="keyword injected">type</span><span class="none injected"> </span><span class="type_alias associated declaration injected static trait">Assoc</span><span class="semicolon injected">;</span><span class="none injected"> </span><span class="brace injected">}</span>
 <span class="comment documentation">//! </span><span class="keyword injected">fn</span><span class="none injected"> </span><span class="function declaration injected">f</span><span class="angle injected">&lt;</span><span class="type_param declaration injected">Arg</span><span class="angle injected">&gt;</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="none injected"> </span><span class="operator injected">-&gt;</span><span class="none injected"> </span><span class="keyword injected">use</span><span class="angle injected">&lt;</span><span class="struct injected">Arg</span><span class="angle injected">&gt;</span><span class="none injected"> </span><span class="keyword injected">where</span><span class="none injected"> </span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="colon injected">:</span><span class="none injected"> </span><span class="trait injected">T</span><span class="comparison injected">&lt;</span><span class="struct injected">Assoc</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="comparison injected">&gt;</span><span class="none injected"> </span><span class="brace injected">{</span><span class="brace injected">}</span>
 <span class="comment documentation">//! ```</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
index 3a45182368834..8f7cbddd7ffba 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
@@ -41,12 +41,12 @@
 .invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword crate_root">self</span> <span class="keyword">as</span> <span class="module crate_root declaration">this</span><span class="semicolon">;</span>
-<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">std</span><span class="semicolon">;</span>
-<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">alloc</span> <span class="keyword">as</span> <span class="module crate_root declaration">abc</span><span class="semicolon">;</span>
-<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="unresolved_reference">unresolved</span> <span class="keyword">as</span> <span class="module crate_root declaration">definitely_unresolved</span><span class="semicolon">;</span>
+<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword">self</span> <span class="keyword">as</span> <span class="crate_root declaration">this</span><span class="semicolon">;</span>
+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="crate_root default_library library">std</span><span class="semicolon">;</span>
+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="crate_root default_library library">alloc</span> <span class="keyword">as</span> <span class="crate_root declaration">abc</span><span class="semicolon">;</span>
+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="unresolved_reference">unresolved</span> <span class="keyword">as</span> <span class="crate_root declaration">definitely_unresolved</span><span class="semicolon">;</span>
 <span class="keyword">extern</span> <span class="keyword">crate</span> <span class="unresolved_reference">unresolved</span> <span class="keyword">as</span> <span class="punctuation">_</span><span class="semicolon">;</span>
-<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">test</span> <span class="keyword">as</span> <span class="module crate_root declaration">opt_in_crate</span><span class="semicolon">;</span>
-<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">test</span> <span class="keyword">as</span> <span class="punctuation">_</span><span class="semicolon">;</span>
-<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">proc_macro</span><span class="semicolon">;</span>
+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="crate_root default_library library">test</span> <span class="keyword">as</span> <span class="crate_root declaration">opt_in_crate</span><span class="semicolon">;</span>
+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="crate_root default_library library">test</span> <span class="keyword">as</span> <span class="punctuation">_</span><span class="semicolon">;</span>
+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="crate_root default_library library">proc_macro</span><span class="semicolon">;</span>
 </code></pre>
\ No newline at end of file
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
index fd652f444ffd5..c6dbc435c0e81 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
@@ -72,7 +72,7 @@
     <span class="brace">}</span>
 <span class="brace">}</span>
 
-<span class="keyword">use</span> <span class="self_keyword crate_root public">self</span><span class="operator">::</span><span class="struct">FooCopy</span><span class="operator">::</span><span class="brace">{</span><span class="self_keyword">self</span> <span class="keyword">as</span> <span class="struct declaration">BarCopy</span><span class="brace">}</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="self_keyword public">self</span><span class="operator">::</span><span class="struct">FooCopy</span><span class="operator">::</span><span class="brace">{</span><span class="self_keyword">self</span> <span class="keyword">as</span> <span class="struct declaration">BarCopy</span><span class="brace">}</span><span class="semicolon">;</span>
 
 <span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="attribute attribute default_library library">derive</span><span class="parenthesis attribute">(</span><span class="derive attribute default_library library macro">Copy</span><span class="parenthesis attribute">)</span><span class="attribute_bracket attribute">]</span>
 <span class="keyword">struct</span> <span class="struct declaration">FooCopy</span> <span class="brace">{</span>
@@ -110,7 +110,7 @@
     <span class="const_param const">FOO</span>
 <span class="brace">}</span>
 
-<span class="keyword">use</span> <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">ops</span><span class="operator">::</span><span class="trait default_library library">Fn</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">ops</span><span class="operator">::</span><span class="trait default_library library">Fn</span><span class="semicolon">;</span>
 <span class="keyword">fn</span> <span class="function declaration">baz</span><span class="angle">&lt;</span><span class="type_param declaration">F</span><span class="colon">:</span> <span class="trait default_library library">Fn</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="parenthesis">(</span><span class="parenthesis">)</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="value_param callable declaration">f</span><span class="colon">:</span> <span class="type_param">F</span><span class="parenthesis">)</span> <span class="brace">{</span>
     <span class="value_param callable">f</span><span class="parenthesis">(</span><span class="parenthesis">)</span>
 <span class="brace">}</span>
@@ -184,15 +184,15 @@
 <span class="brace">}</span>
 
 <span class="keyword">fn</span> <span class="function declaration">use_foo_items</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
-    <span class="keyword">let</span> <span class="variable declaration">bob</span> <span class="operator">=</span> <span class="module crate_root library">foo</span><span class="operator">::</span><span class="struct library">Person</span> <span class="brace">{</span>
+    <span class="keyword">let</span> <span class="variable declaration">bob</span> <span class="operator">=</span> <span class="crate_root library">foo</span><span class="operator">::</span><span class="struct library">Person</span> <span class="brace">{</span>
         <span class="field library">name</span><span class="colon">:</span> <span class="string_literal">"Bob"</span><span class="comma">,</span>
-        <span class="field library">age</span><span class="colon">:</span> <span class="module crate_root library">foo</span><span class="operator">::</span><span class="module library">consts</span><span class="operator">::</span><span class="constant const library">NUMBER</span><span class="comma">,</span>
+        <span class="field library">age</span><span class="colon">:</span> <span class="crate_root library">foo</span><span class="operator">::</span><span class="module library">consts</span><span class="operator">::</span><span class="constant const library">NUMBER</span><span class="comma">,</span>
     <span class="brace">}</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="variable declaration">control_flow</span> <span class="operator">=</span> <span class="module crate_root library">foo</span><span class="operator">::</span><span class="function library">identity</span><span class="parenthesis">(</span><span class="module crate_root library">foo</span><span class="operator">::</span><span class="enum library">ControlFlow</span><span class="operator">::</span><span class="enum_variant library">Continue</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">control_flow</span> <span class="operator">=</span> <span class="crate_root library">foo</span><span class="operator">::</span><span class="function library">identity</span><span class="parenthesis">(</span><span class="crate_root library">foo</span><span class="operator">::</span><span class="enum library">ControlFlow</span><span class="operator">::</span><span class="enum_variant library">Continue</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
     <span class="keyword control">if</span> <span class="variable">control_flow</span><span class="operator">.</span><span class="method consuming library">should_die</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
-        <span class="module crate_root library">foo</span><span class="operator">::</span><span class="unresolved_reference">die</span><span class="macro_bang">!</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+        <span class="crate_root library">foo</span><span class="operator">::</span><span class="unresolved_reference">die</span><span class="macro_bang">!</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
     <span class="brace">}</span>
 <span class="brace">}</span>
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_injection_2.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_injection_2.html
index 5a5d9bd1f909b..391a46f706c80 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_injection_2.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_injection_2.html
@@ -47,7 +47,7 @@
     <span class="function">fixture</span><span class="parenthesis">(</span><span class="string_literal">r#"</span>
 @@- /main.rs crate:main deps:other_crate
 <span class="keyword injected">fn</span><span class="none injected"> </span><span class="function declaration injected">test</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="none injected"> </span><span class="brace injected">{</span><span class="none injected">
-</span>    <span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">x</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="module crate_root injected library">other_crate</span><span class="operator injected">::</span><span class="module injected library">foo</span><span class="operator injected">::</span><span class="struct injected library">S</span><span class="operator injected">::</span><span class="function associated injected library static">thing</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span><span class="none injected">
+</span>    <span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">x</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="crate_root injected library">other_crate</span><span class="operator injected">::</span><span class="module injected library">foo</span><span class="operator injected">::</span><span class="struct injected library">S</span><span class="operator injected">::</span><span class="function associated injected library static">thing</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span><span class="none injected">
 </span>    <span class="variable injected">x</span><span class="semicolon injected">;</span><span class="none injected">
 </span><span class="brace injected">}</span><span class="none injected"> </span><span class="comment injected">//^ i128</span><span class="none injected">
 </span><span class="none injected">
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_issue_18089.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_issue_18089.html
index b28818e679ff7..fccf34083d7f2 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_issue_18089.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_issue_18089.html
@@ -45,5 +45,5 @@
     <span class="macro public">template</span><span class="macro_bang">!</span><span class="parenthesis">(</span>template<span class="parenthesis">)</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 
-<span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="module attribute crate_root library">proc_macros</span><span class="operator attribute">::</span><span class="attribute attribute library">issue_18089</span><span class="attribute_bracket attribute">]</span>
+<span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="crate_root attribute library">proc_macros</span><span class="operator attribute">::</span><span class="attribute attribute library">issue_18089</span><span class="attribute_bracket attribute">]</span>
 <span class="keyword macro proc_macro">fn</span> <span class="macro declaration macro proc_macro public">template</span><span class="parenthesis macro proc_macro">(</span><span class="parenthesis macro proc_macro">)</span> <span class="brace macro proc_macro">{</span><span class="brace macro proc_macro">}</span></code></pre>
\ No newline at end of file
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2015.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2015.html
index d2a53b2ff9e1f..6366cba1bd030 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2015.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2015.html
@@ -41,12 +41,12 @@
 .invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword crate_root">self</span><span class="semicolon">;</span>
+<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword">self</span><span class="semicolon">;</span>
 
-<span class="keyword">use</span> <span class="keyword crate_root public">crate</span><span class="semicolon">;</span>
-<span class="keyword">use</span> <span class="self_keyword crate_root public">self</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="keyword public">crate</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="self_keyword public">self</span><span class="semicolon">;</span>
 <span class="keyword">mod</span> <span class="module declaration">__</span> <span class="brace">{</span>
-    <span class="keyword">use</span> <span class="keyword crate_root public">super</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
+    <span class="keyword">use</span> <span class="keyword public">super</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 
 <span class="keyword">macro_rules</span><span class="macro_bang">!</span> <span class="macro declaration public">void</span> <span class="brace">{</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2018.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2018.html
index d309b4723238b..a89e8190832e8 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2018.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2018.html
@@ -41,12 +41,12 @@
 .invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword crate_root">self</span><span class="semicolon">;</span>
+<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword">self</span><span class="semicolon">;</span>
 
-<span class="keyword">use</span> <span class="keyword crate_root public">crate</span><span class="semicolon">;</span>
-<span class="keyword">use</span> <span class="self_keyword crate_root public">self</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="keyword public">crate</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="self_keyword public">self</span><span class="semicolon">;</span>
 <span class="keyword">mod</span> <span class="module declaration">__</span> <span class="brace">{</span>
-    <span class="keyword">use</span> <span class="keyword crate_root public">super</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
+    <span class="keyword">use</span> <span class="keyword public">super</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 
 <span class="keyword">macro_rules</span><span class="macro_bang">!</span> <span class="macro declaration public">void</span> <span class="brace">{</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2021.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2021.html
index d309b4723238b..a89e8190832e8 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2021.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2021.html
@@ -41,12 +41,12 @@
 .invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword crate_root">self</span><span class="semicolon">;</span>
+<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword">self</span><span class="semicolon">;</span>
 
-<span class="keyword">use</span> <span class="keyword crate_root public">crate</span><span class="semicolon">;</span>
-<span class="keyword">use</span> <span class="self_keyword crate_root public">self</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="keyword public">crate</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="self_keyword public">self</span><span class="semicolon">;</span>
 <span class="keyword">mod</span> <span class="module declaration">__</span> <span class="brace">{</span>
-    <span class="keyword">use</span> <span class="keyword crate_root public">super</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
+    <span class="keyword">use</span> <span class="keyword public">super</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 
 <span class="keyword">macro_rules</span><span class="macro_bang">!</span> <span class="macro declaration public">void</span> <span class="brace">{</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2024.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2024.html
index 575c9a6b0aca8..aa1500b8f85bb 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2024.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_2024.html
@@ -41,12 +41,12 @@
 .invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword crate_root">self</span><span class="semicolon">;</span>
+<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword">self</span><span class="semicolon">;</span>
 
-<span class="keyword">use</span> <span class="keyword crate_root public">crate</span><span class="semicolon">;</span>
-<span class="keyword">use</span> <span class="self_keyword crate_root public">self</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="keyword public">crate</span><span class="semicolon">;</span>
+<span class="keyword">use</span> <span class="self_keyword public">self</span><span class="semicolon">;</span>
 <span class="keyword">mod</span> <span class="module declaration">__</span> <span class="brace">{</span>
-    <span class="keyword">use</span> <span class="keyword crate_root public">super</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
+    <span class="keyword">use</span> <span class="keyword public">super</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 
 <span class="keyword">macro_rules</span><span class="macro_bang">!</span> <span class="macro declaration public">void</span> <span class="brace">{</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_macros.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_macros.html
index caf66ace7a689..484afd81ead2a 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_macros.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords_macros.html
@@ -41,6 +41,6 @@
 .invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="module crate_root library">lib2015</span><span class="operator">::</span><span class="macro library">void_2015</span><span class="macro_bang">!</span><span class="parenthesis">(</span>try async await <span class="none macro">gen</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-<span class="module crate_root library">lib2024</span><span class="operator">::</span><span class="macro library">void_2024</span><span class="macro_bang">!</span><span class="parenthesis">(</span><span class="keyword macro">try</span> <span class="keyword async macro">async</span> <span class="keyword async control macro">await</span> <span class="none macro">gen</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+<pre><code><span class="crate_root library">lib2015</span><span class="operator">::</span><span class="macro library">void_2015</span><span class="macro_bang">!</span><span class="parenthesis">(</span>try async await <span class="none macro">gen</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="crate_root library">lib2024</span><span class="operator">::</span><span class="macro library">void_2024</span><span class="macro_bang">!</span><span class="parenthesis">(</span><span class="keyword macro">try</span> <span class="keyword async macro">async</span> <span class="keyword async control macro">await</span> <span class="none macro">gen</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 </code></pre>
\ No newline at end of file
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_macros.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_macros.html
index b63d5cedc825b..59612634fda38 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_macros.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_macros.html
@@ -41,7 +41,7 @@
 .invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
 .unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">use</span> <span class="module crate_root library">proc_macros</span><span class="operator">::</span><span class="brace">{</span><span class="function library">mirror</span><span class="comma">,</span> <span class="function library">identity</span><span class="comma">,</span> <span class="derive library">DeriveIdentity</span><span class="brace">}</span><span class="semicolon">;</span>
+<pre><code><span class="keyword">use</span> <span class="crate_root library">proc_macros</span><span class="operator">::</span><span class="brace">{</span><span class="function library">mirror</span><span class="comma">,</span> <span class="function library">identity</span><span class="comma">,</span> <span class="derive library">DeriveIdentity</span><span class="brace">}</span><span class="semicolon">;</span>
 
 <span class="proc_macro library">mirror</span><span class="macro_bang">!</span> <span class="brace">{</span>
     <span class="brace macro proc_macro">{</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
index e178782c79c4e..4e3822c3d31f8 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -165,7 +165,7 @@
     <span class="macro public">toho</span><span class="macro_bang">!</span><span class="parenthesis">(</span><span class="string_literal macro">"{}fmt"</span><span class="comma macro">,</span> <span class="numeric_literal macro">0</span><span class="parenthesis">)</span><span class="semicolon">;</span>
     <span class="keyword">let</span> <span class="variable declaration">i</span><span class="colon">:</span> <span class="builtin_type">u64</span> <span class="operator">=</span> <span class="numeric_literal">3</span><span class="semicolon">;</span>
     <span class="keyword">let</span> <span class="variable declaration">o</span><span class="colon">:</span> <span class="builtin_type">u64</span><span class="semicolon">;</span>
-    <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span>
+    <span class="crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span>
         <span class="string_literal macro">"mov {</span><span class="variable">0</span><span class="string_literal macro">}, {</span><span class="variable">1</span><span class="string_literal macro">}"</span><span class="comma macro">,</span>
         <span class="string_literal macro">"add {</span><span class="variable">0</span><span class="string_literal macro">}, 5"</span><span class="comma macro">,</span>
         <span class="keyword macro">out</span><span class="parenthesis macro">(</span><span class="reg library macro">reg</span><span class="parenthesis macro">)</span> <span class="variable macro">o</span><span class="comma macro">,</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings_disabled.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings_disabled.html
new file mode 100644
index 0000000000000..344d0c2ff03b5
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings_disabled.html
@@ -0,0 +1,47 @@
+
+<style>
+body                { margin: 0; }
+pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
+
+.lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
+.comment            { color: #7F9F7F; }
+.documentation      { color: #629755; }
+.intra_doc_link     { font-style: italic; }
+.injected           { opacity: 0.65 ; }
+.struct, .enum      { color: #7CB8BB; }
+.enum_variant       { color: #BDE0F3; }
+.string_literal     { color: #CC9393; }
+.field              { color: #94BFF3; }
+.function           { color: #93E0E3; }
+.parameter          { color: #94BFF3; }
+.text               { color: #DCDCCC; }
+.type               { color: #7CB8BB; }
+.builtin_type       { color: #8CD0D3; }
+.type_param         { color: #DFAF8F; }
+.attribute          { color: #94BFF3; }
+.numeric_literal    { color: #BFEBBF; }
+.bool_literal       { color: #BFE6EB; }
+.macro              { color: #94BFF3; }
+.proc_macro         { color: #94BFF3; text-decoration: underline; }
+.derive             { color: #94BFF3; font-style: italic; }
+.module             { color: #AFD8AF; }
+.value_param        { color: #DCDCCC; }
+.variable           { color: #DCDCCC; }
+.format_specifier   { color: #CC696B; }
+.mutable            { text-decoration: underline; }
+.escape_sequence    { color: #94BFF3; }
+.keyword            { color: #F0DFAF; font-weight: bold; }
+.control            { font-style: italic; }
+.reference          { font-style: italic; font-weight: bold; }
+.const              { font-weight: bolder; }
+.unsafe             { color: #BC8383; }
+.deprecated         { text-decoration: line-through; }
+
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
+</style>
+<pre><code><span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="macro default_library library">format_args</span><span class="macro_bang">!</span><span class="parenthesis">(</span>"foo\nbar"<span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro default_library library">format_args</span><span class="macro_bang">!</span><span class="parenthesis">(</span>"foo\invalid"<span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="brace">}</span></code></pre>
\ No newline at end of file
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index 93513f5b575d4..008987d409adc 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -91,7 +91,7 @@
 
         <span class="comment">// unsafe fn and method calls</span>
         <span class="function unsafe">unsafe_fn</span><span class="parenthesis unsafe">(</span><span class="parenthesis unsafe">)</span><span class="semicolon">;</span>
-        <span class="self_keyword crate_root public">self</span><span class="operator">::</span><span class="function unsafe">unsafe_fn</span><span class="parenthesis unsafe">(</span><span class="parenthesis unsafe">)</span><span class="semicolon">;</span>
+        <span class="self_keyword public">self</span><span class="operator">::</span><span class="function unsafe">unsafe_fn</span><span class="parenthesis unsafe">(</span><span class="parenthesis unsafe">)</span><span class="semicolon">;</span>
         <span class="parenthesis">(</span><span class="function">unsafe_fn</span> <span class="keyword">as</span> <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="parenthesis">)</span><span class="parenthesis unsafe">(</span><span class="parenthesis unsafe">)</span><span class="semicolon">;</span>
         <span class="struct">Struct</span> <span class="brace">{</span> <span class="field">field</span><span class="colon">:</span> <span class="numeric_literal">0</span> <span class="brace">}</span><span class="operator">.</span><span class="method reference unsafe">unsafe_method</span><span class="parenthesis unsafe">(</span><span class="parenthesis unsafe">)</span><span class="semicolon">;</span>
 
@@ -120,7 +120,7 @@
         <span class="operator">&</span><span class="static unsafe">EXTERN_STATIC</span><span class="semicolon">;</span>
         <span class="operator">&</span><span class="keyword">raw</span> <span class="keyword const">const</span> <span class="static">EXTERN_STATIC</span><span class="semicolon">;</span>
 
-        <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span>
+        <span class="crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">arch</span><span class="operator">::</span><span class="macro default_library library unsafe">asm</span><span class="macro_bang unsafe">!</span><span class="parenthesis unsafe">(</span>
             <span class="string_literal macro">"push {</span><span class="variable">base</span><span class="string_literal macro">}"</span><span class="comma macro">,</span>
             <span class="variable declaration macro">base</span> <span class="operator macro">=</span> <span class="keyword const macro">const</span> <span class="numeric_literal macro">0</span>
         <span class="parenthesis unsafe">)</span><span class="semicolon">;</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
index 89a5e434f90cc..8b529cf10f7f9 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
@@ -1498,6 +1498,23 @@ fn main() {
     );
 }
 
+#[test]
+fn test_strings_highlighting_disabled() {
+    // Test that comments are not highlighted when disabled
+    check_highlighting_with_config(
+        r#"
+//- minicore: fmt
+fn main() {
+    format_args!("foo\nbar");
+    format_args!("foo\invalid");
+}
+"#,
+        HighlightConfig { strings: false, ..HL_CONFIG },
+        expect_file!["./test_data/highlight_strings_disabled.html"],
+        false,
+    );
+}
+
 #[test]
 fn regression_20952() {
     check_highlighting(
diff --git a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
index 6181413a46dbc..781e58a1204e0 100644
--- a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
+++ b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
@@ -531,4 +531,5 @@ define_symbols! {
     CoerceUnsized,
     DispatchFromDyn,
     define_opaque,
+    marker,
 }
diff --git a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
index e8d98b1ce661d..8342492a33a4c 100644
--- a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
@@ -553,15 +553,14 @@ impl ProcMacroExpander for Expander {
 
                 Ok(SubResponse::LocalFilePathResult { name })
             }
+            // Not incremental: requires full file text.
             SubRequest::SourceText { file_id, ast_id, start, end } => {
-                let ast_id = span::ErasedFileAstId::from_raw(ast_id);
-                let editioned_file_id = span::EditionedFileId::from_raw(file_id);
-                let span = Span {
-                    range: TextRange::new(TextSize::from(start), TextSize::from(end)),
-                    anchor: SpanAnchor { file_id: editioned_file_id, ast_id },
-                    ctx: SyntaxContext::root(editioned_file_id.edition()),
-                };
-                let range = db.resolve_span(span);
+                let range = resolve_sub_span(
+                    db,
+                    file_id,
+                    ast_id,
+                    TextRange::new(TextSize::from(start), TextSize::from(end)),
+                );
                 let source = db.file_text(range.file_id.file_id(db)).text(db);
                 let text = source
                     .get(usize::from(range.range.start())..usize::from(range.range.end()))
@@ -569,6 +568,19 @@ impl ProcMacroExpander for Expander {
 
                 Ok(SubResponse::SourceTextResult { text })
             }
+            // Not incremental: requires building line index.
+            SubRequest::LineColumn { file_id, ast_id, offset } => {
+                let range =
+                    resolve_sub_span(db, file_id, ast_id, TextRange::empty(TextSize::from(offset)));
+                let source = db.file_text(range.file_id.file_id(db)).text(db);
+                let line_index = ide_db::line_index::LineIndex::new(source);
+                let (line, column) = line_index
+                    .try_line_col(range.range.start())
+                    .map(|lc| (lc.line + 1, lc.col + 1))
+                    .unwrap_or((1, 1));
+                // proc_macro::Span line/column are 1-based
+                Ok(SubResponse::LineColumnResult { line, column })
+            }
             SubRequest::FilePath { file_id } => {
                 let file_id = FileId::from_raw(file_id);
                 let source_root_id = db.file_source_root(file_id).source_root_id(db);
@@ -581,6 +593,17 @@ impl ProcMacroExpander for Expander {
 
                 Ok(SubResponse::FilePathResult { name })
             }
+            // Not incremental: requires global span resolution.
+            SubRequest::ByteRange { file_id, ast_id, start, end } => {
+                let range = resolve_sub_span(
+                    db,
+                    file_id,
+                    ast_id,
+                    TextRange::new(TextSize::from(start), TextSize::from(end)),
+                );
+
+                Ok(SubResponse::ByteRangeResult { range: range.range.into() })
+            }
         };
         match self.0.expand(
             subtree.view(),
@@ -603,6 +626,22 @@ impl ProcMacroExpander for Expander {
     }
 }
 
+fn resolve_sub_span(
+    db: &dyn ExpandDatabase,
+    file_id: u32,
+    ast_id: u32,
+    range: TextRange,
+) -> hir_expand::FileRange {
+    let ast_id = span::ErasedFileAstId::from_raw(ast_id);
+    let editioned_file_id = span::EditionedFileId::from_raw(file_id);
+    let span = Span {
+        range,
+        anchor: SpanAnchor { file_id: editioned_file_id, ast_id },
+        ctx: SyntaxContext::root(editioned_file_id.edition()),
+    };
+    db.resolve_span(span)
+}
+
 #[cfg(test)]
 mod tests {
     use ide_db::base_db::RootQueryDb;
diff --git a/src/tools/rust-analyzer/crates/mbe/src/expander/matcher.rs b/src/tools/rust-analyzer/crates/mbe/src/expander/matcher.rs
index 8f6627a60fe63..fe01fb1f10637 100644
--- a/src/tools/rust-analyzer/crates/mbe/src/expander/matcher.rs
+++ b/src/tools/rust-analyzer/crates/mbe/src/expander/matcher.rs
@@ -414,8 +414,9 @@ fn match_loop_inner<'t>(
                     }
 
                     // Check if we need a separator.
-                    if item.sep.is_some() && !item.sep_matched {
-                        let sep = item.sep.as_ref().unwrap();
+                    if let Some(sep) = &item.sep
+                        && !item.sep_matched
+                    {
                         let mut fork = src.clone();
                         if expect_separator(&mut fork, sep) {
                             // HACK: here we use `meta_result` to pass `TtIter` back to caller because
diff --git a/src/tools/rust-analyzer/crates/parser/src/grammar.rs b/src/tools/rust-analyzer/crates/parser/src/grammar.rs
index bf8430294110c..e481bbe9bc4a0 100644
--- a/src/tools/rust-analyzer/crates/parser/src/grammar.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/grammar.rs
@@ -6,7 +6,7 @@
 //! each submodule starts with `use super::*` import and exports
 //! "public" productions via `pub(super)`.
 //!
-//! See docs for [`Parser`](super::parser::Parser) to learn about API,
+//! See docs for [`Parser`] to learn about API,
 //! available to the grammar, and see docs for [`Event`](super::event::Event)
 //! to learn how this actually manages to produce parse trees.
 //!
diff --git a/src/tools/rust-analyzer/crates/proc-macro-api/src/bidirectional_protocol/msg.rs b/src/tools/rust-analyzer/crates/proc-macro-api/src/bidirectional_protocol/msg.rs
index e41f8a5d7da76..57e7b1ee8f684 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-api/src/bidirectional_protocol/msg.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-api/src/bidirectional_protocol/msg.rs
@@ -1,5 +1,7 @@
 //! Bidirectional protocol messages
 
+use std::ops::Range;
+
 use paths::Utf8PathBuf;
 use serde::{Deserialize, Serialize};
 
@@ -13,13 +15,29 @@ pub enum SubRequest {
     FilePath { file_id: u32 },
     SourceText { file_id: u32, ast_id: u32, start: u32, end: u32 },
     LocalFilePath { file_id: u32 },
+    LineColumn { file_id: u32, ast_id: u32, offset: u32 },
+    ByteRange { file_id: u32, ast_id: u32, start: u32, end: u32 },
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum SubResponse {
-    FilePathResult { name: String },
-    SourceTextResult { text: Option<String> },
-    LocalFilePathResult { name: Option<String> },
+    FilePathResult {
+        name: String,
+    },
+    SourceTextResult {
+        text: Option<String>,
+    },
+    LocalFilePathResult {
+        name: Option<String>,
+    },
+    /// Line and column are 1-based.
+    LineColumnResult {
+        line: u32,
+        column: u32,
+    },
+    ByteRangeResult {
+        range: Range<usize>,
+    },
 }
 
 #[derive(Debug, Serialize, Deserialize)]
diff --git a/src/tools/rust-analyzer/crates/proc-macro-api/src/legacy_protocol.rs b/src/tools/rust-analyzer/crates/proc-macro-api/src/legacy_protocol.rs
index 22a7d9868e215..4524d1b66bfe2 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-api/src/legacy_protocol.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-api/src/legacy_protocol.rs
@@ -162,11 +162,11 @@ fn send_request<P: Codec>(
     req: Request,
     buf: &mut P::Buf,
 ) -> Result<Option<Response>, ServerError> {
-    req.write::<_, P>(&mut writer).map_err(|err| ServerError {
+    req.write::<P>(&mut writer).map_err(|err| ServerError {
         message: "failed to write request".into(),
         io: Some(Arc::new(err)),
     })?;
-    let res = Response::read::<_, P>(&mut reader, buf).map_err(|err| ServerError {
+    let res = Response::read::<P>(&mut reader, buf).map_err(|err| ServerError {
         message: "failed to read response".into(),
         io: Some(Arc::new(err)),
     })?;
diff --git a/src/tools/rust-analyzer/crates/proc-macro-api/src/legacy_protocol/msg.rs b/src/tools/rust-analyzer/crates/proc-macro-api/src/legacy_protocol/msg.rs
index 4146b619ec0c4..1b6590693354b 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-api/src/legacy_protocol/msg.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-api/src/legacy_protocol/msg.rs
@@ -155,13 +155,13 @@ impl ExpnGlobals {
 }
 
 pub trait Message: serde::Serialize + DeserializeOwned {
-    fn read<R: BufRead, C: Codec>(inp: &mut R, buf: &mut C::Buf) -> io::Result<Option<Self>> {
+    fn read<C: Codec>(inp: &mut dyn BufRead, buf: &mut C::Buf) -> io::Result<Option<Self>> {
         Ok(match C::read(inp, buf)? {
             None => None,
             Some(buf) => Some(C::decode(buf)?),
         })
     }
-    fn write<W: Write, C: Codec>(self, out: &mut W) -> io::Result<()> {
+    fn write<C: Codec>(self, out: &mut dyn Write) -> io::Result<()> {
         let value = C::encode(&self)?;
         C::write(out, &value)
     }
diff --git a/src/tools/rust-analyzer/crates/proc-macro-api/src/lib.rs b/src/tools/rust-analyzer/crates/proc-macro-api/src/lib.rs
index f5fcc99f14a3c..822809943a364 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-api/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-api/src/lib.rs
@@ -18,7 +18,7 @@ extern crate rustc_driver as _;
 
 pub mod bidirectional_protocol;
 pub mod legacy_protocol;
-mod process;
+pub mod process;
 pub mod transport;
 
 use paths::{AbsPath, AbsPathBuf};
@@ -44,6 +44,29 @@ pub mod version {
     pub const CURRENT_API_VERSION: u32 = HASHED_AST_ID;
 }
 
+/// Protocol format for communication between client and server.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ProtocolFormat {
+    /// JSON-based legacy protocol (newline-delimited JSON).
+    JsonLegacy,
+    /// Postcard-based legacy protocol (COBS-encoded postcard).
+    PostcardLegacy,
+    /// Bidirectional postcard protocol with sub-request support.
+    BidirectionalPostcardPrototype,
+}
+
+impl fmt::Display for ProtocolFormat {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ProtocolFormat::JsonLegacy => write!(f, "json-legacy"),
+            ProtocolFormat::PostcardLegacy => write!(f, "postcard-legacy"),
+            ProtocolFormat::BidirectionalPostcardPrototype => {
+                write!(f, "bidirectional-postcard-prototype")
+            }
+        }
+    }
+}
+
 /// Represents different kinds of procedural macros that can be expanded by the external server.
 #[derive(Copy, Clone, Eq, PartialEq, Debug, serde_derive::Serialize, serde_derive::Deserialize)]
 pub enum ProcMacroKind {
@@ -132,7 +155,25 @@ impl ProcMacroClient {
         > + Clone,
         version: Option<&Version>,
     ) -> io::Result<ProcMacroClient> {
-        let process = ProcMacroServerProcess::run(process_path, env, version)?;
+        let process = ProcMacroServerProcess::spawn(process_path, env, version)?;
+        Ok(ProcMacroClient { process: Arc::new(process), path: process_path.to_owned() })
+    }
+
+    /// Invokes `spawn` and returns a client connected to the resulting read and write handles.
+    ///
+    /// The `process_path` is used for `Self::server_path`. This function is mainly used for testing.
+    pub fn with_io_channels(
+        process_path: &AbsPath,
+        spawn: impl Fn(
+            Option<ProtocolFormat>,
+        ) -> io::Result<(
+            Box<dyn process::ProcessExit>,
+            Box<dyn io::Write + Send + Sync>,
+            Box<dyn io::BufRead + Send + Sync>,
+        )>,
+        version: Option<&Version>,
+    ) -> io::Result<ProcMacroClient> {
+        let process = ProcMacroServerProcess::run(spawn, version, || "<unknown>".to_owned())?;
         Ok(ProcMacroClient { process: Arc::new(process), path: process_path.to_owned() })
     }
 
diff --git a/src/tools/rust-analyzer/crates/proc-macro-api/src/process.rs b/src/tools/rust-analyzer/crates/proc-macro-api/src/process.rs
index f6a656e3ce3a4..4f87621587908 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-api/src/process.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-api/src/process.rs
@@ -13,14 +13,13 @@ use span::Span;
 use stdx::JodChild;
 
 use crate::{
-    Codec, ProcMacro, ProcMacroKind, ServerError,
+    Codec, ProcMacro, ProcMacroKind, ProtocolFormat, ServerError,
     bidirectional_protocol::{self, SubCallback, msg::BidirectionalMessage, reject_subrequests},
     legacy_protocol::{self, SpanMode},
     version,
 };
 
 /// Represents a process handling proc-macro communication.
-#[derive(Debug)]
 pub(crate) struct ProcMacroServerProcess {
     /// The state of the proc-macro server process, the protocol is currently strictly sequential
     /// hence the lock on the state.
@@ -31,6 +30,16 @@ pub(crate) struct ProcMacroServerProcess {
     exited: OnceLock<AssertUnwindSafe<ServerError>>,
 }
 
+impl std::fmt::Debug for ProcMacroServerProcess {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ProcMacroServerProcess")
+            .field("version", &self.version)
+            .field("protocol", &self.protocol)
+            .field("exited", &self.exited)
+            .finish()
+    }
+}
+
 #[derive(Debug, Clone)]
 pub(crate) enum Protocol {
     LegacyJson { mode: SpanMode },
@@ -38,22 +47,83 @@ pub(crate) enum Protocol {
     BidirectionalPostcardPrototype { mode: SpanMode },
 }
 
+pub trait ProcessExit: Send + Sync {
+    fn exit_err(&mut self) -> Option<ServerError>;
+}
+
+impl ProcessExit for Process {
+    fn exit_err(&mut self) -> Option<ServerError> {
+        match self.child.try_wait() {
+            Ok(None) | Err(_) => None,
+            Ok(Some(status)) => {
+                let mut msg = String::new();
+                if !status.success()
+                    && let Some(stderr) = self.child.stderr.as_mut()
+                {
+                    _ = stderr.read_to_string(&mut msg);
+                }
+                Some(ServerError {
+                    message: format!(
+                        "proc-macro server exited with {status}{}{msg}",
+                        if msg.is_empty() { "" } else { ": " }
+                    ),
+                    io: None,
+                })
+            }
+        }
+    }
+}
+
 /// Maintains the state of the proc-macro server process.
-#[derive(Debug)]
 struct ProcessSrvState {
-    process: Process,
-    stdin: ChildStdin,
-    stdout: BufReader<ChildStdout>,
+    process: Box<dyn ProcessExit>,
+    stdin: Box<dyn Write + Send + Sync>,
+    stdout: Box<dyn BufRead + Send + Sync>,
 }
 
 impl ProcMacroServerProcess {
     /// Starts the proc-macro server and performs a version check
-    pub(crate) fn run<'a>(
+    pub(crate) fn spawn<'a>(
         process_path: &AbsPath,
         env: impl IntoIterator<
             Item = (impl AsRef<std::ffi::OsStr>, &'a Option<impl 'a + AsRef<std::ffi::OsStr>>),
         > + Clone,
         version: Option<&Version>,
+    ) -> io::Result<ProcMacroServerProcess> {
+        Self::run(
+            |format| {
+                let mut process = Process::run(
+                    process_path,
+                    env.clone(),
+                    format.map(|format| format.to_string()).as_deref(),
+                )?;
+                let (stdin, stdout) = process.stdio().expect("couldn't access child stdio");
+
+                Ok((Box::new(process), Box::new(stdin), Box::new(stdout)))
+            },
+            version,
+            || {
+                #[expect(clippy::disallowed_methods)]
+                Command::new(process_path)
+                    .arg("--version")
+                    .output()
+                    .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_owned())
+                    .unwrap_or_else(|_| "unknown version".to_owned())
+            },
+        )
+    }
+
+    /// Invokes `spawn` and performs a version check.
+    pub(crate) fn run(
+        spawn: impl Fn(
+            Option<ProtocolFormat>,
+        ) -> io::Result<(
+            Box<dyn ProcessExit>,
+            Box<dyn Write + Send + Sync>,
+            Box<dyn BufRead + Send + Sync>,
+        )>,
+        version: Option<&Version>,
+        binary_server_version: impl Fn() -> String,
     ) -> io::Result<ProcMacroServerProcess> {
         const VERSION: Version = Version::new(1, 93, 0);
         // we do `>` for nightly as this started working in the middle of the 1.93 nightly release, so we dont want to break on half of the nightlies
@@ -65,27 +135,33 @@ impl ProcMacroServerProcess {
             && has_working_format_flag
         {
             &[
-                (
-                    Some("bidirectional-postcard-prototype"),
-                    Protocol::BidirectionalPostcardPrototype { mode: SpanMode::Id },
-                ),
-                (Some("postcard-legacy"), Protocol::LegacyPostcard { mode: SpanMode::Id }),
-                (Some("json-legacy"), Protocol::LegacyJson { mode: SpanMode::Id }),
+                Some(ProtocolFormat::BidirectionalPostcardPrototype),
+                Some(ProtocolFormat::PostcardLegacy),
+                Some(ProtocolFormat::JsonLegacy),
             ]
         } else {
-            &[(None, Protocol::LegacyJson { mode: SpanMode::Id })]
+            &[None]
         };
 
         let mut err = None;
-        for &(format, ref protocol) in formats {
+        for &format in formats {
             let create_srv = || {
-                let mut process = Process::run(process_path, env.clone(), format)?;
-                let (stdin, stdout) = process.stdio().expect("couldn't access child stdio");
+                let (process, stdin, stdout) = spawn(format)?;
 
                 io::Result::Ok(ProcMacroServerProcess {
                     state: Mutex::new(ProcessSrvState { process, stdin, stdout }),
                     version: 0,
-                    protocol: protocol.clone(),
+                    protocol: match format {
+                        Some(ProtocolFormat::BidirectionalPostcardPrototype) => {
+                            Protocol::BidirectionalPostcardPrototype { mode: SpanMode::Id }
+                        }
+                        Some(ProtocolFormat::PostcardLegacy) => {
+                            Protocol::LegacyPostcard { mode: SpanMode::Id }
+                        }
+                        Some(ProtocolFormat::JsonLegacy) | None => {
+                            Protocol::LegacyJson { mode: SpanMode::Id }
+                        }
+                    },
                     exited: OnceLock::new(),
                 })
             };
@@ -93,12 +169,7 @@ impl ProcMacroServerProcess {
             tracing::info!("sending proc-macro server version check");
             match srv.version_check(Some(&mut reject_subrequests)) {
                 Ok(v) if v > version::CURRENT_API_VERSION => {
-                    #[allow(clippy::disallowed_methods)]
-                    let process_version = Command::new(process_path)
-                        .arg("--version")
-                        .output()
-                        .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_owned())
-                        .unwrap_or_else(|_| "unknown version".to_owned());
+                    let process_version = binary_server_version();
                     err = Some(io::Error::other(format!(
                         "Your installed proc-macro server is too new for your rust-analyzer. API version: {}, server version: {process_version}. \
                         This will prevent proc-macro expansion from working. Please consider updating your rust-analyzer to ensure compatibility with your current toolchain.",
@@ -275,22 +346,9 @@ impl ProcMacroServerProcess {
 
         f(&mut state.stdin, &mut state.stdout, &mut buf).map_err(|e| {
             if e.io.as_ref().map(|it| it.kind()) == Some(io::ErrorKind::BrokenPipe) {
-                match state.process.child.try_wait() {
-                    Ok(None) | Err(_) => e,
-                    Ok(Some(status)) => {
-                        let mut msg = String::new();
-                        if !status.success()
-                            && let Some(stderr) = state.process.child.stderr.as_mut()
-                        {
-                            _ = stderr.read_to_string(&mut msg);
-                        }
-                        let server_error = ServerError {
-                            message: format!(
-                                "proc-macro server exited with {status}{}{msg}",
-                                if msg.is_empty() { "" } else { ": " }
-                            ),
-                            io: None,
-                        };
+                match state.process.exit_err() {
+                    None => e,
+                    Some(server_error) => {
                         self.exited.get_or_init(|| AssertUnwindSafe(server_error)).0.clone()
                     }
                 }
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/Cargo.toml b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/Cargo.toml
index 6b2db0b269d57..a25e3b64ad42b 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/Cargo.toml
@@ -10,12 +10,26 @@ license.workspace = true
 rust-version.workspace = true
 publish = false
 
+[lib]
+doctest = false
+
 [dependencies]
 proc-macro-srv.workspace = true
 proc-macro-api.workspace = true
 postcard.workspace = true
 clap = {version = "4.5.42", default-features = false, features = ["std"]}
 
+[dev-dependencies]
+expect-test.workspace = true
+paths.workspace = true
+# span = {workspace = true, default-features = false} does not work
+span = { path = "../span", default-features = false}
+tt.workspace = true
+intern.workspace = true
+
+# used as proc macro test target
+proc-macro-test.path = "../proc-macro-srv/proc-macro-test"
+
 [features]
 default = []
 # default = ["sysroot-abi"]
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/lib.rs b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/lib.rs
new file mode 100644
index 0000000000000..9e6f03bf46046
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/lib.rs
@@ -0,0 +1,6 @@
+//! Library interface for `proc-macro-srv-cli`.
+//!
+//! This module exposes the server main loop and protocol format for integration testing.
+
+#[cfg(feature = "sysroot-abi")]
+pub mod main_loop;
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main.rs b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main.rs
index bdfdb50002e12..a246d4d3f28f9 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main.rs
@@ -9,11 +9,11 @@ extern crate rustc_driver as _;
 
 mod version;
 
-#[cfg(feature = "sysroot-abi")]
-mod main_loop;
 use clap::{Command, ValueEnum};
+use proc_macro_api::ProtocolFormat;
+
 #[cfg(feature = "sysroot-abi")]
-use main_loop::run;
+use proc_macro_srv_cli::main_loop::run;
 
 fn main() -> std::io::Result<()> {
     let v = std::env::var("RUST_ANALYZER_INTERNALS_DO_NOT_USE");
@@ -32,7 +32,7 @@ fn main() -> std::io::Result<()> {
                 .long("format")
                 .action(clap::ArgAction::Set)
                 .default_value("json-legacy")
-                .value_parser(clap::builder::EnumValueParser::<ProtocolFormat>::new()),
+                .value_parser(clap::builder::EnumValueParser::<ProtocolFormatArg>::new()),
             clap::Arg::new("version")
                 .long("version")
                 .action(clap::ArgAction::SetTrue)
@@ -43,29 +43,37 @@ fn main() -> std::io::Result<()> {
         println!("rust-analyzer-proc-macro-srv {}", version::version());
         return Ok(());
     }
-    let &format =
-        matches.get_one::<ProtocolFormat>("format").expect("format value should always be present");
-    run(format)
+    let &format = matches
+        .get_one::<ProtocolFormatArg>("format")
+        .expect("format value should always be present");
+
+    let mut stdin = std::io::BufReader::new(std::io::stdin());
+    let mut stdout = std::io::stdout();
+
+    run(&mut stdin, &mut stdout, format.into())
 }
 
+/// Wrapper for CLI argument parsing that implements `ValueEnum`.
 #[derive(Copy, Clone)]
-enum ProtocolFormat {
-    JsonLegacy,
-    PostcardLegacy,
-    BidirectionalPostcardPrototype,
+struct ProtocolFormatArg(ProtocolFormat);
+
+impl From<ProtocolFormatArg> for ProtocolFormat {
+    fn from(arg: ProtocolFormatArg) -> Self {
+        arg.0
+    }
 }
 
-impl ValueEnum for ProtocolFormat {
+impl ValueEnum for ProtocolFormatArg {
     fn value_variants<'a>() -> &'a [Self] {
         &[
-            ProtocolFormat::JsonLegacy,
-            ProtocolFormat::PostcardLegacy,
-            ProtocolFormat::BidirectionalPostcardPrototype,
+            ProtocolFormatArg(ProtocolFormat::JsonLegacy),
+            ProtocolFormatArg(ProtocolFormat::PostcardLegacy),
+            ProtocolFormatArg(ProtocolFormat::BidirectionalPostcardPrototype),
         ]
     }
 
     fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
-        match self {
+        match self.0 {
             ProtocolFormat::JsonLegacy => Some(clap::builder::PossibleValue::new("json-legacy")),
             ProtocolFormat::PostcardLegacy => {
                 Some(clap::builder::PossibleValue::new("postcard-legacy"))
@@ -75,12 +83,13 @@ impl ValueEnum for ProtocolFormat {
             }
         }
     }
+
     fn from_str(input: &str, _ignore_case: bool) -> Result<Self, String> {
         match input {
-            "json-legacy" => Ok(ProtocolFormat::JsonLegacy),
-            "postcard-legacy" => Ok(ProtocolFormat::PostcardLegacy),
+            "json-legacy" => Ok(ProtocolFormatArg(ProtocolFormat::JsonLegacy)),
+            "postcard-legacy" => Ok(ProtocolFormatArg(ProtocolFormat::PostcardLegacy)),
             "bidirectional-postcard-prototype" => {
-                Ok(ProtocolFormat::BidirectionalPostcardPrototype)
+                Ok(ProtocolFormatArg(ProtocolFormat::BidirectionalPostcardPrototype))
             }
             _ => Err(format!("unknown protocol format: {input}")),
         }
@@ -88,7 +97,11 @@ impl ValueEnum for ProtocolFormat {
 }
 
 #[cfg(not(feature = "sysroot-abi"))]
-fn run(_: ProtocolFormat) -> std::io::Result<()> {
+fn run(
+    _: &mut std::io::BufReader<std::io::Stdin>,
+    _: &mut std::io::Stdout,
+    _: ProtocolFormat,
+) -> std::io::Result<()> {
     Err(std::io::Error::new(
         std::io::ErrorKind::Unsupported,
         "proc-macro-srv-cli needs to be compiled with the `sysroot-abi` feature to function"
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main_loop.rs b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main_loop.rs
index b2f4b96bd2551..5180ede9fb900 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/src/main_loop.rs
@@ -1,18 +1,20 @@
 //! The main loop of the proc-macro server.
 use proc_macro_api::{
-    Codec,
+    Codec, ProtocolFormat,
     bidirectional_protocol::msg as bidirectional,
     legacy_protocol::msg as legacy,
     transport::codec::{json::JsonProtocol, postcard::PostcardProtocol},
     version::CURRENT_API_VERSION,
 };
-use std::io;
+use std::{
+    io::{self, BufRead, Write},
+    ops::Range,
+};
 
 use legacy::Message;
 
 use proc_macro_srv::{EnvSnapshot, SpanId};
 
-use crate::ProtocolFormat;
 struct SpanTrans;
 
 impl legacy::SpanTransformer for SpanTrans {
@@ -32,15 +34,24 @@ impl legacy::SpanTransformer for SpanTrans {
     }
 }
 
-pub(crate) fn run(format: ProtocolFormat) -> io::Result<()> {
+pub fn run(
+    stdin: &mut (dyn BufRead + Send + Sync),
+    stdout: &mut (dyn Write + Send + Sync),
+    format: ProtocolFormat,
+) -> io::Result<()> {
     match format {
-        ProtocolFormat::JsonLegacy => run_::<JsonProtocol>(),
-        ProtocolFormat::PostcardLegacy => run_::<PostcardProtocol>(),
-        ProtocolFormat::BidirectionalPostcardPrototype => run_new::<PostcardProtocol>(),
+        ProtocolFormat::JsonLegacy => run_old::<JsonProtocol>(stdin, stdout),
+        ProtocolFormat::PostcardLegacy => run_old::<PostcardProtocol>(stdin, stdout),
+        ProtocolFormat::BidirectionalPostcardPrototype => {
+            run_new::<PostcardProtocol>(stdin, stdout)
+        }
     }
 }
 
-fn run_new<C: Codec>() -> io::Result<()> {
+fn run_new<C: Codec>(
+    stdin: &mut (dyn BufRead + Send + Sync),
+    stdout: &mut (dyn Write + Send + Sync),
+) -> io::Result<()> {
     fn macro_kind_to_api(kind: proc_macro_srv::ProcMacroKind) -> proc_macro_api::ProcMacroKind {
         match kind {
             proc_macro_srv::ProcMacroKind::CustomDerive => {
@@ -52,8 +63,6 @@ fn run_new<C: Codec>() -> io::Result<()> {
     }
 
     let mut buf = C::Buf::default();
-    let mut stdin = io::stdin();
-    let mut stdout = io::stdout();
 
     let env_snapshot = EnvSnapshot::default();
     let srv = proc_macro_srv::ProcMacroSrv::new(&env_snapshot);
@@ -61,8 +70,7 @@ fn run_new<C: Codec>() -> io::Result<()> {
     let mut span_mode = legacy::SpanMode::Id;
 
     'outer: loop {
-        let req_opt =
-            bidirectional::BidirectionalMessage::read::<_, C>(&mut stdin.lock(), &mut buf)?;
+        let req_opt = bidirectional::BidirectionalMessage::read::<C>(stdin, &mut buf)?;
         let Some(req) = req_opt else {
             break 'outer;
         };
@@ -77,22 +85,22 @@ fn run_new<C: Codec>() -> io::Result<()> {
                             .collect()
                     });
 
-                    send_response::<C>(&stdout, bidirectional::Response::ListMacros(res))?;
+                    send_response::<C>(stdout, bidirectional::Response::ListMacros(res))?;
                 }
 
                 bidirectional::Request::ApiVersionCheck {} => {
                     send_response::<C>(
-                        &stdout,
+                        stdout,
                         bidirectional::Response::ApiVersionCheck(CURRENT_API_VERSION),
                     )?;
                 }
 
                 bidirectional::Request::SetConfig(config) => {
                     span_mode = config.span_mode;
-                    send_response::<C>(&stdout, bidirectional::Response::SetConfig(config))?;
+                    send_response::<C>(stdout, bidirectional::Response::SetConfig(config))?;
                 }
                 bidirectional::Request::ExpandMacro(task) => {
-                    handle_expand::<C>(&srv, &mut stdin, &mut stdout, &mut buf, span_mode, *task)?;
+                    handle_expand::<C>(&srv, stdin, stdout, &mut buf, span_mode, *task)?;
                 }
             },
             _ => continue,
@@ -104,8 +112,8 @@ fn run_new<C: Codec>() -> io::Result<()> {
 
 fn handle_expand<C: Codec>(
     srv: &proc_macro_srv::ProcMacroSrv<'_>,
-    stdin: &io::Stdin,
-    stdout: &io::Stdout,
+    stdin: &mut (dyn BufRead + Send + Sync),
+    stdout: &mut (dyn Write + Send + Sync),
     buf: &mut C::Buf,
     span_mode: legacy::SpanMode,
     task: bidirectional::ExpandMacro,
@@ -118,7 +126,7 @@ fn handle_expand<C: Codec>(
 
 fn handle_expand_id<C: Codec>(
     srv: &proc_macro_srv::ProcMacroSrv<'_>,
-    stdout: &io::Stdout,
+    stdout: &mut dyn Write,
     task: bidirectional::ExpandMacro,
 ) -> io::Result<()> {
     let bidirectional::ExpandMacro { lib, env, current_dir, data } = task;
@@ -157,12 +165,12 @@ fn handle_expand_id<C: Codec>(
         })
         .map_err(|e| legacy::PanicMessage(e.into_string().unwrap_or_default()));
 
-    send_response::<C>(&stdout, bidirectional::Response::ExpandMacro(res))
+    send_response::<C>(stdout, bidirectional::Response::ExpandMacro(res))
 }
 
 struct ProcMacroClientHandle<'a, C: Codec> {
-    stdin: &'a io::Stdin,
-    stdout: &'a io::Stdout,
+    stdin: &'a mut (dyn BufRead + Send + Sync),
+    stdout: &'a mut (dyn Write + Send + Sync),
     buf: &'a mut C::Buf,
 }
 
@@ -173,11 +181,11 @@ impl<'a, C: Codec> ProcMacroClientHandle<'a, C> {
     ) -> Option<bidirectional::BidirectionalMessage> {
         let msg = bidirectional::BidirectionalMessage::SubRequest(req);
 
-        if msg.write::<_, C>(&mut self.stdout.lock()).is_err() {
+        if msg.write::<C>(&mut *self.stdout).is_err() {
             return None;
         }
 
-        match bidirectional::BidirectionalMessage::read::<_, C>(&mut self.stdin.lock(), self.buf) {
+        match bidirectional::BidirectionalMessage::read::<C>(&mut *self.stdin, self.buf) {
             Ok(Some(msg)) => Some(msg),
             _ => None,
         }
@@ -220,12 +228,43 @@ impl<C: Codec> proc_macro_srv::ProcMacroClientInterface for ProcMacroClientHandl
             _ => None,
         }
     }
+
+    fn line_column(&mut self, span: proc_macro_srv::span::Span) -> Option<(u32, u32)> {
+        let proc_macro_srv::span::Span { range, anchor, ctx: _ } = span;
+        match self.roundtrip(bidirectional::SubRequest::LineColumn {
+            file_id: anchor.file_id.as_u32(),
+            ast_id: anchor.ast_id.into_raw(),
+            offset: range.start().into(),
+        }) {
+            Some(bidirectional::BidirectionalMessage::SubResponse(
+                bidirectional::SubResponse::LineColumnResult { line, column },
+            )) => Some((line, column)),
+            _ => None,
+        }
+    }
+
+    fn byte_range(
+        &mut self,
+        proc_macro_srv::span::Span { range, anchor, ctx: _ }: proc_macro_srv::span::Span,
+    ) -> Range<usize> {
+        match self.roundtrip(bidirectional::SubRequest::ByteRange {
+            file_id: anchor.file_id.as_u32(),
+            ast_id: anchor.ast_id.into_raw(),
+            start: range.start().into(),
+            end: range.end().into(),
+        }) {
+            Some(bidirectional::BidirectionalMessage::SubResponse(
+                bidirectional::SubResponse::ByteRangeResult { range },
+            )) => range,
+            _ => Range { start: range.start().into(), end: range.end().into() },
+        }
+    }
 }
 
 fn handle_expand_ra<C: Codec>(
     srv: &proc_macro_srv::ProcMacroSrv<'_>,
-    stdin: &io::Stdin,
-    stdout: &io::Stdout,
+    stdin: &mut (dyn BufRead + Send + Sync),
+    stdout: &mut (dyn Write + Send + Sync),
     buf: &mut C::Buf,
     task: bidirectional::ExpandMacro,
 ) -> io::Result<()> {
@@ -287,10 +326,13 @@ fn handle_expand_ra<C: Codec>(
         .map(|(tree, span_data_table)| bidirectional::ExpandMacroExtended { tree, span_data_table })
         .map_err(|e| legacy::PanicMessage(e.into_string().unwrap_or_default()));
 
-    send_response::<C>(&stdout, bidirectional::Response::ExpandMacroExtended(res))
+    send_response::<C>(stdout, bidirectional::Response::ExpandMacroExtended(res))
 }
 
-fn run_<C: Codec>() -> io::Result<()> {
+fn run_old<C: Codec>(
+    stdin: &mut (dyn BufRead + Send + Sync),
+    stdout: &mut (dyn Write + Send + Sync),
+) -> io::Result<()> {
     fn macro_kind_to_api(kind: proc_macro_srv::ProcMacroKind) -> proc_macro_api::ProcMacroKind {
         match kind {
             proc_macro_srv::ProcMacroKind::CustomDerive => {
@@ -302,8 +344,8 @@ fn run_<C: Codec>() -> io::Result<()> {
     }
 
     let mut buf = C::Buf::default();
-    let mut read_request = || legacy::Request::read::<_, C>(&mut io::stdin().lock(), &mut buf);
-    let write_response = |msg: legacy::Response| msg.write::<_, C>(&mut io::stdout().lock());
+    let mut read_request = || legacy::Request::read::<C>(stdin, &mut buf);
+    let mut write_response = |msg: legacy::Response| msg.write::<C>(stdout);
 
     let env = EnvSnapshot::default();
     let srv = proc_macro_srv::ProcMacroSrv::new(&env);
@@ -432,7 +474,10 @@ fn run_<C: Codec>() -> io::Result<()> {
     Ok(())
 }
 
-fn send_response<C: Codec>(stdout: &io::Stdout, resp: bidirectional::Response) -> io::Result<()> {
+fn send_response<C: Codec>(
+    stdout: &mut dyn Write,
+    resp: bidirectional::Response,
+) -> io::Result<()> {
     let resp = bidirectional::BidirectionalMessage::Response(resp);
-    resp.write::<_, C>(&mut stdout.lock())
+    resp.write::<C>(stdout)
 }
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/tests/common/utils.rs b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/tests/common/utils.rs
new file mode 100644
index 0000000000000..722e92eec7e52
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/tests/common/utils.rs
@@ -0,0 +1,213 @@
+use std::{
+    collections::VecDeque,
+    io::{self, BufRead, Read, Write},
+    sync::{Arc, Condvar, Mutex},
+    thread,
+};
+
+use paths::Utf8PathBuf;
+use proc_macro_api::{
+    legacy_protocol::msg::{FlatTree, Message, Request, Response, SpanDataIndexMap},
+    transport::codec::json::JsonProtocol,
+};
+use span::{Edition, EditionedFileId, FileId, Span, SpanAnchor, SyntaxContext, TextRange};
+use tt::{Delimiter, DelimiterKind, TopSubtreeBuilder};
+
+/// Shared state for an in-memory byte channel.
+#[derive(Default)]
+struct ChannelState {
+    buffer: VecDeque<u8>,
+    closed: bool,
+}
+
+type InMemoryChannel = Arc<(Mutex<ChannelState>, Condvar)>;
+
+/// Writer end of an in-memory channel.
+pub(crate) struct ChannelWriter {
+    state: InMemoryChannel,
+}
+
+impl Write for ChannelWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let (lock, cvar) = &*self.state;
+        let mut state = lock.lock().unwrap();
+        if state.closed {
+            return Err(io::Error::new(io::ErrorKind::BrokenPipe, "channel closed"));
+        }
+        state.buffer.extend(buf);
+        cvar.notify_all();
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Drop for ChannelWriter {
+    fn drop(&mut self) {
+        let (lock, cvar) = &*self.state;
+        let mut state = lock.lock().unwrap();
+        state.closed = true;
+        cvar.notify_all();
+    }
+}
+
+/// Reader end of an in-memory channel.
+pub(crate) struct ChannelReader {
+    state: InMemoryChannel,
+    internal_buf: Vec<u8>,
+}
+
+impl Read for ChannelReader {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let (lock, cvar) = &*self.state;
+        let mut state = lock.lock().unwrap();
+
+        while state.buffer.is_empty() && !state.closed {
+            state = cvar.wait(state).unwrap();
+        }
+
+        if state.buffer.is_empty() && state.closed {
+            return Ok(0);
+        }
+
+        let to_read = buf.len().min(state.buffer.len());
+        for (dst, src) in buf.iter_mut().zip(state.buffer.drain(..to_read)) {
+            *dst = src;
+        }
+        Ok(to_read)
+    }
+}
+
+impl BufRead for ChannelReader {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        let (lock, cvar) = &*self.state;
+        let mut state = lock.lock().unwrap();
+
+        while state.buffer.is_empty() && !state.closed {
+            state = cvar.wait(state).unwrap();
+        }
+
+        self.internal_buf.clear();
+        self.internal_buf.extend(&state.buffer);
+        Ok(&self.internal_buf)
+    }
+
+    fn consume(&mut self, amt: usize) {
+        let (lock, _) = &*self.state;
+        let mut state = lock.lock().unwrap();
+        let to_drain = amt.min(state.buffer.len());
+        drop(state.buffer.drain(..to_drain));
+    }
+}
+
+/// Creates a connected pair of channels for bidirectional communication.
+fn create_channel_pair() -> (ChannelWriter, ChannelReader, ChannelWriter, ChannelReader) {
+    // Channel for client -> server communication
+    let client_to_server = Arc::new((
+        Mutex::new(ChannelState { buffer: VecDeque::new(), closed: false }),
+        Condvar::new(),
+    ));
+    let client_writer = ChannelWriter { state: client_to_server.clone() };
+    let server_reader = ChannelReader { state: client_to_server, internal_buf: Vec::new() };
+
+    // Channel for server -> client communication
+    let server_to_client = Arc::new((
+        Mutex::new(ChannelState { buffer: VecDeque::new(), closed: false }),
+        Condvar::new(),
+    ));
+
+    let server_writer = ChannelWriter { state: server_to_client.clone() };
+    let client_reader = ChannelReader { state: server_to_client, internal_buf: Vec::new() };
+
+    (client_writer, client_reader, server_writer, server_reader)
+}
+
+pub(crate) fn proc_macro_test_dylib_path() -> Utf8PathBuf {
+    let path = proc_macro_test::PROC_MACRO_TEST_LOCATION;
+    if path.is_empty() {
+        panic!("proc-macro-test dylib not available (requires nightly toolchain)");
+    }
+    path.into()
+}
+
+/// Runs a test with the server in a background thread.
+pub(crate) fn with_server<F, R>(test_fn: F) -> R
+where
+    F: FnOnce(&mut dyn Write, &mut dyn BufRead) -> R,
+{
+    let (mut client_writer, mut client_reader, mut server_writer, mut server_reader) =
+        create_channel_pair();
+
+    let server_handle = thread::spawn(move || {
+        proc_macro_srv_cli::main_loop::run(
+            &mut server_reader,
+            &mut server_writer,
+            proc_macro_api::ProtocolFormat::JsonLegacy,
+        )
+    });
+
+    let result = test_fn(&mut client_writer, &mut client_reader);
+
+    // Close the client writer to signal the server to stop
+    drop(client_writer);
+
+    // Wait for server to finish
+    match server_handle.join() {
+        Ok(Ok(())) => {}
+        Ok(Err(e)) => {
+            // IO error from server is expected when client disconnects
+            if matches!(
+                e.kind(),
+                io::ErrorKind::BrokenPipe
+                    | io::ErrorKind::UnexpectedEof
+                    | io::ErrorKind::InvalidData
+            ) {
+                panic!("Server error: {e}");
+            }
+        }
+        Err(e) => std::panic::resume_unwind(e),
+    }
+
+    result
+}
+
+/// Sends a request and reads the response using JSON protocol.
+pub(crate) fn request(
+    writer: &mut dyn Write,
+    reader: &mut dyn BufRead,
+    request: Request,
+) -> Response {
+    request.write::<JsonProtocol>(writer).expect("failed to write request");
+
+    let mut buf = String::new();
+    Response::read::<JsonProtocol>(reader, &mut buf)
+        .expect("failed to read response")
+        .expect("no response received")
+}
+
+/// Creates a simple empty token tree suitable for testing.
+pub(crate) fn create_empty_token_tree(
+    version: u32,
+    span_data_table: &mut SpanDataIndexMap,
+) -> FlatTree {
+    let anchor = SpanAnchor {
+        file_id: EditionedFileId::new(FileId::from_raw(0), Edition::CURRENT),
+        ast_id: span::ROOT_ERASED_FILE_AST_ID,
+    };
+    let span = Span {
+        range: TextRange::empty(0.into()),
+        anchor,
+        ctx: SyntaxContext::root(Edition::CURRENT),
+    };
+
+    let builder = TopSubtreeBuilder::new(Delimiter {
+        open: span,
+        close: span,
+        kind: DelimiterKind::Invisible,
+    });
+    let tt = builder.build();
+
+    FlatTree::from_subtree(tt.view(), version, span_data_table)
+}
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv-cli/tests/legacy_json.rs b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/tests/legacy_json.rs
new file mode 100644
index 0000000000000..1fa886219a8a4
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv-cli/tests/legacy_json.rs
@@ -0,0 +1,224 @@
+//! Integration tests for the proc-macro-srv-cli main loop.
+//!
+//! These tests exercise the full client-server RPC procedure using in-memory
+//! channels without needing to spawn the actual server and client processes.
+
+#![cfg(feature = "sysroot-abi")]
+
+mod common {
+    pub(crate) mod utils;
+}
+
+use common::utils::{create_empty_token_tree, proc_macro_test_dylib_path, request, with_server};
+use expect_test::expect;
+use proc_macro_api::{
+    legacy_protocol::msg::{
+        ExpandMacro, ExpandMacroData, ExpnGlobals, PanicMessage, Request, Response, ServerConfig,
+        SpanDataIndexMap, SpanMode,
+    },
+    version::CURRENT_API_VERSION,
+};
+
+#[test]
+fn test_version_check() {
+    with_server(|writer, reader| {
+        let response = request(writer, reader, Request::ApiVersionCheck {});
+
+        match response {
+            Response::ApiVersionCheck(version) => {
+                assert_eq!(version, CURRENT_API_VERSION);
+            }
+            other => panic!("unexpected response: {other:?}"),
+        }
+    });
+}
+
+#[test]
+fn test_list_macros() {
+    with_server(|writer, reader| {
+        let dylib_path = proc_macro_test_dylib_path();
+        let response = request(writer, reader, Request::ListMacros { dylib_path });
+
+        let Response::ListMacros(Ok(macros)) = response else {
+            panic!("expected successful ListMacros response");
+        };
+
+        let mut macro_list: Vec<_> =
+            macros.iter().map(|(name, kind)| format!("{name} [{kind:?}]")).collect();
+        macro_list.sort();
+        let macro_list_str = macro_list.join("\n");
+
+        expect![[r#"
+            DeriveEmpty [CustomDerive]
+            DeriveError [CustomDerive]
+            DerivePanic [CustomDerive]
+            DeriveReemit [CustomDerive]
+            attr_error [Attr]
+            attr_noop [Attr]
+            attr_panic [Attr]
+            fn_like_clone_tokens [Bang]
+            fn_like_error [Bang]
+            fn_like_mk_idents [Bang]
+            fn_like_mk_literals [Bang]
+            fn_like_noop [Bang]
+            fn_like_panic [Bang]
+            fn_like_span_join [Bang]
+            fn_like_span_line_column [Bang]
+            fn_like_span_ops [Bang]"#]]
+        .assert_eq(&macro_list_str);
+    });
+}
+
+#[test]
+fn test_list_macros_invalid_path() {
+    with_server(|writer, reader| {
+        let response = request(
+            writer,
+            reader,
+            Request::ListMacros { dylib_path: "/nonexistent/path/to/dylib.so".into() },
+        );
+
+        match response {
+            Response::ListMacros(Err(e)) => assert!(
+                e.starts_with("Cannot create expander for /nonexistent/path/to/dylib.so"),
+                "{e}"
+            ),
+            other => panic!("expected error response, got: {other:?}"),
+        }
+    });
+}
+
+#[test]
+fn test_set_config() {
+    with_server(|writer, reader| {
+        let config = ServerConfig { span_mode: SpanMode::Id };
+        let response = request(writer, reader, Request::SetConfig(config));
+
+        match response {
+            Response::SetConfig(returned_config) => {
+                assert_eq!(returned_config.span_mode, SpanMode::Id);
+            }
+            other => panic!("unexpected response: {other:?}"),
+        }
+    });
+}
+
+#[test]
+fn test_set_config_rust_analyzer_mode() {
+    with_server(|writer, reader| {
+        let config = ServerConfig { span_mode: SpanMode::RustAnalyzer };
+        let response = request(writer, reader, Request::SetConfig(config));
+
+        match response {
+            Response::SetConfig(returned_config) => {
+                assert_eq!(returned_config.span_mode, SpanMode::RustAnalyzer);
+            }
+            other => panic!("unexpected response: {other:?}"),
+        }
+    });
+}
+
+#[test]
+fn test_expand_macro_panic() {
+    with_server(|writer, reader| {
+        let dylib_path = proc_macro_test_dylib_path();
+
+        let version_response = request(writer, reader, Request::ApiVersionCheck {});
+        let Response::ApiVersionCheck(version) = version_response else {
+            panic!("expected version check response");
+        };
+
+        let mut span_data_table = SpanDataIndexMap::default();
+        let macro_body = create_empty_token_tree(version, &mut span_data_table);
+
+        let expand_request = Request::ExpandMacro(Box::new(ExpandMacro {
+            lib: dylib_path,
+            env: vec![],
+            current_dir: None,
+            data: ExpandMacroData {
+                macro_body,
+                macro_name: "fn_like_panic".to_owned(),
+                attributes: None,
+                has_global_spans: ExpnGlobals {
+                    serialize: version >= 3,
+                    def_site: 0,
+                    call_site: 0,
+                    mixed_site: 0,
+                },
+                span_data_table: vec![],
+            },
+        }));
+
+        let response = request(writer, reader, expand_request);
+
+        match response {
+            Response::ExpandMacro(Err(PanicMessage(msg))) => {
+                assert!(msg.contains("fn_like_panic"), "panic message should mention the macro");
+            }
+            Response::ExpandMacro(Ok(_)) => {
+                panic!("expected panic, but macro succeeded");
+            }
+            other => panic!("unexpected response: {other:?}"),
+        }
+    });
+}
+
+#[test]
+fn test_basic_call_flow() {
+    with_server(|writer, reader| {
+        let dylib_path = proc_macro_test_dylib_path();
+
+        let response1 = request(writer, reader, Request::ApiVersionCheck {});
+        assert!(matches!(response1, Response::ApiVersionCheck(_)));
+
+        let response2 =
+            request(writer, reader, Request::SetConfig(ServerConfig { span_mode: SpanMode::Id }));
+        assert!(matches!(response2, Response::SetConfig(_)));
+
+        let response3 =
+            request(writer, reader, Request::ListMacros { dylib_path: dylib_path.clone() });
+        assert!(matches!(response3, Response::ListMacros(Ok(_))));
+    });
+}
+
+#[test]
+fn test_expand_nonexistent_macro() {
+    with_server(|writer, reader| {
+        let dylib_path = proc_macro_test_dylib_path();
+
+        let version_response = request(writer, reader, Request::ApiVersionCheck {});
+        let Response::ApiVersionCheck(version) = version_response else {
+            panic!("expected version check response");
+        };
+
+        let mut span_data_table = SpanDataIndexMap::default();
+        let macro_body = create_empty_token_tree(version, &mut span_data_table);
+
+        let expand_request = Request::ExpandMacro(Box::new(ExpandMacro {
+            lib: dylib_path,
+            env: vec![],
+            current_dir: None,
+            data: ExpandMacroData {
+                macro_body,
+                macro_name: "NonexistentMacro".to_owned(),
+                attributes: None,
+                has_global_spans: ExpnGlobals {
+                    serialize: version >= 3,
+                    def_site: 0,
+                    call_site: 0,
+                    mixed_site: 0,
+                },
+                span_data_table: vec![],
+            },
+        }));
+
+        let response = request(writer, reader, expand_request);
+
+        match response {
+            Response::ExpandMacro(Err(PanicMessage(msg))) => {
+                expect!["proc-macro `NonexistentMacro` is missing"].assert_eq(&msg)
+            }
+            other => panic!("expected error for nonexistent macro, got: {other:?}"),
+        }
+    });
+}
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/Cargo.toml b/src/tools/rust-analyzer/crates/proc-macro-srv/Cargo.toml
index 361017178409b..8e5617f8a20eb 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/Cargo.toml
@@ -31,6 +31,7 @@ libc.workspace = true
 
 [dev-dependencies]
 expect-test.workspace = true
+line-index.workspace = true
 
 # used as proc macro test targets
 proc-macro-test.path = "./proc-macro-test"
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/proc-macro-test/imp/src/lib.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/proc-macro-test/imp/src/lib.rs
index b4fac26d6e72c..06c76b6d03815 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/proc-macro-test/imp/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/proc-macro-test/imp/src/lib.rs
@@ -79,6 +79,16 @@ pub fn fn_like_span_ops(args: TokenStream) -> TokenStream {
     TokenStream::from_iter(vec![first, second, third])
 }
 
+/// Returns the line and column of the first token's span as two integer literals.
+#[proc_macro]
+pub fn fn_like_span_line_column(args: TokenStream) -> TokenStream {
+    let first = args.into_iter().next().unwrap();
+    let span = first.span();
+    let line = Literal::usize_unsuffixed(span.line());
+    let column = Literal::usize_unsuffixed(span.column());
+    TokenStream::from_iter(vec![TokenTree::Literal(line), TokenTree::Literal(column)])
+}
+
 #[proc_macro_attribute]
 pub fn attr_noop(_args: TokenStream, item: TokenStream) -> TokenStream {
     item
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
index f2d1dfbba4ccb..ac9f89352c2bf 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
@@ -41,6 +41,7 @@ use std::{
     env,
     ffi::OsString,
     fs,
+    ops::Range,
     path::{Path, PathBuf},
     sync::{Arc, Mutex, PoisonError},
     thread,
@@ -98,6 +99,10 @@ pub trait ProcMacroClientInterface {
     fn file(&mut self, file_id: span::FileId) -> String;
     fn source_text(&mut self, span: Span) -> Option<String>;
     fn local_file(&mut self, file_id: span::FileId) -> Option<String>;
+    /// Line and column are 1-based.
+    fn line_column(&mut self, span: Span) -> Option<(u32, u32)>;
+
+    fn byte_range(&mut self, span: Span) -> Range<usize>;
 }
 
 const EXPANDER_STACK_SIZE: usize = 8 * 1024 * 1024;
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
index 32725afc55272..9946608247c3e 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
@@ -162,7 +162,10 @@ impl server::Span for RaSpanServer<'_> {
         span
     }
     fn byte_range(&mut self, span: Self::Span) -> Range<usize> {
-        // FIXME requires db to resolve the ast id, THIS IS NOT INCREMENTAL
+        if let Some(cb) = self.callback.as_mut() {
+            return cb.byte_range(span);
+        }
+
         Range { start: span.range.start().into(), end: span.range.end().into() }
     }
     fn join(&mut self, first: Self::Span, second: Self::Span) -> Option<Self::Span> {
@@ -257,14 +260,12 @@ impl server::Span for RaSpanServer<'_> {
         Span { range: TextRange::empty(span.range.start()), ..span }
     }
 
-    fn line(&mut self, _span: Self::Span) -> usize {
-        // FIXME requires db to resolve line index, THIS IS NOT INCREMENTAL
-        1
+    fn line(&mut self, span: Self::Span) -> usize {
+        self.callback.as_mut().and_then(|cb| cb.line_column(span)).map_or(1, |(l, _)| l as usize)
     }
 
-    fn column(&mut self, _span: Self::Span) -> usize {
-        // FIXME requires db to resolve line index, THIS IS NOT INCREMENTAL
-        1
+    fn column(&mut self, span: Self::Span) -> usize {
+        self.callback.as_mut().and_then(|cb| cb.line_column(span)).map_or(1, |(_, c)| c as usize)
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/tests/mod.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/tests/mod.rs
index 20507a6def54d..ebef9a9a519a7 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/tests/mod.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/tests/mod.rs
@@ -703,6 +703,7 @@ fn list_test_macros() {
         fn_like_mk_idents [Bang]
         fn_like_span_join [Bang]
         fn_like_span_ops [Bang]
+        fn_like_span_line_column [Bang]
         attr_noop [Attr]
         attr_panic [Attr]
         attr_error [Attr]
@@ -712,3 +713,17 @@ fn list_test_macros() {
         DeriveError [CustomDerive]"#]]
     .assert_eq(&res);
 }
+
+#[test]
+fn test_fn_like_span_line_column() {
+    assert_expand_with_callback(
+        "fn_like_span_line_column",
+        // Input text with known position: "hello" starts at offset 1 (line 2, column 1 in 1-based)
+        "
+hello",
+        expect![[r#"
+            LITER 42:Root[0000, 0]@0..100#ROOT2024 Integer 2
+            LITER 42:Root[0000, 0]@0..100#ROOT2024 Integer 1
+        "#]],
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/tests/utils.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/tests/utils.rs
index 61fcd810b1d9d..b7c5c4fdd21f0 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/tests/utils.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/tests/utils.rs
@@ -4,9 +4,11 @@ use expect_test::Expect;
 use span::{
     EditionedFileId, FileId, ROOT_ERASED_FILE_AST_ID, Span, SpanAnchor, SyntaxContext, TextRange,
 };
+use std::ops::Range;
 
 use crate::{
-    EnvSnapshot, ProcMacroSrv, SpanId, dylib, proc_macro_test_dylib_path, token_stream::TokenStream,
+    EnvSnapshot, ProcMacroClientInterface, ProcMacroSrv, SpanId, dylib, proc_macro_test_dylib_path,
+    token_stream::TokenStream,
 };
 
 fn parse_string(call_site: SpanId, src: &str) -> TokenStream<SpanId> {
@@ -109,3 +111,70 @@ pub(crate) fn list() -> Vec<String> {
     let res = srv.list_macros(&dylib_path).unwrap();
     res.into_iter().map(|(name, kind)| format!("{name} [{kind:?}]")).collect()
 }
+
+/// A mock callback for testing that computes line/column from the input text.
+struct MockCallback<'a> {
+    text: &'a str,
+}
+
+impl ProcMacroClientInterface for MockCallback<'_> {
+    fn source_text(&mut self, span: Span) -> Option<String> {
+        self.text
+            .get(usize::from(span.range.start())..usize::from(span.range.end()))
+            .map(ToOwned::to_owned)
+    }
+
+    fn file(&mut self, _file_id: FileId) -> String {
+        String::new()
+    }
+
+    fn local_file(&mut self, _file_id: FileId) -> Option<String> {
+        None
+    }
+
+    fn line_column(&mut self, span: Span) -> Option<(u32, u32)> {
+        let line_index = line_index::LineIndex::new(self.text);
+        let line_col = line_index.try_line_col(span.range.start())?;
+        // proc_macro uses 1-based line/column
+        Some((line_col.line as u32 + 1, line_col.col as u32 + 1))
+    }
+
+    fn byte_range(&mut self, span: Span) -> Range<usize> {
+        Range { start: span.range.start().into(), end: span.range.end().into() }
+    }
+}
+
+pub fn assert_expand_with_callback(
+    macro_name: &str,
+    #[rust_analyzer::rust_fixture] ra_fixture: &str,
+    expect_spanned: Expect,
+) {
+    let path = proc_macro_test_dylib_path();
+    let expander = dylib::Expander::new(&temp_dir::TempDir::new().unwrap(), &path).unwrap();
+
+    let def_site = Span {
+        range: TextRange::new(0.into(), 150.into()),
+        anchor: SpanAnchor {
+            file_id: EditionedFileId::current_edition(FileId::from_raw(41)),
+            ast_id: ROOT_ERASED_FILE_AST_ID,
+        },
+        ctx: SyntaxContext::root(span::Edition::CURRENT),
+    };
+    let call_site = Span {
+        range: TextRange::new(0.into(), 100.into()),
+        anchor: SpanAnchor {
+            file_id: EditionedFileId::current_edition(FileId::from_raw(42)),
+            ast_id: ROOT_ERASED_FILE_AST_ID,
+        },
+        ctx: SyntaxContext::root(span::Edition::CURRENT),
+    };
+    let mixed_site = call_site;
+
+    let fixture = parse_string_spanned(call_site.anchor, call_site.ctx, ra_fixture);
+
+    let mut callback = MockCallback { text: ra_fixture };
+    let res = expander
+        .expand(macro_name, fixture, None, def_site, call_site, mixed_site, Some(&mut callback))
+        .unwrap();
+    expect_spanned.assert_eq(&format!("{res:?}"));
+}
diff --git a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
index 6e1a3f37ff1c1..483ab28450455 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
@@ -640,7 +640,7 @@ impl FetchMetadata {
     /// Builds a command to fetch metadata for the given `cargo_toml` manifest.
     ///
     /// Performs a lightweight pre-fetch using the `--no-deps` option,
-    /// available via [`FetchMetadata::no_deps_metadata`], to gather basic
+    /// available via `FetchMetadata::no_deps_metadata`, to gather basic
     /// information such as the `target-dir`.
     ///
     /// The provided sysroot is used to set the `RUSTUP_TOOLCHAIN`
diff --git a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
index b3478d2cfe033..6938010cbd708 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
@@ -78,6 +78,13 @@ pub struct ProjectJson {
     runnables: Vec<Runnable>,
 }
 
+impl std::ops::Index<CrateArrayIdx> for ProjectJson {
+    type Output = Crate;
+    fn index(&self, index: CrateArrayIdx) -> &Self::Output {
+        &self.crates[index.0]
+    }
+}
+
 impl ProjectJson {
     /// Create a new ProjectJson instance.
     ///
@@ -195,12 +202,11 @@ impl ProjectJson {
         &self.project_root
     }
 
-    pub fn crate_by_root(&self, root: &AbsPath) -> Option<Crate> {
+    pub fn crate_by_root(&self, root: &AbsPath) -> Option<&Crate> {
         self.crates
             .iter()
             .filter(|krate| krate.is_workspace_member)
             .find(|krate| krate.root_module == root)
-            .cloned()
     }
 
     /// Returns the path to the project's manifest, if it exists.
@@ -214,8 +220,17 @@ impl ProjectJson {
         self.crates
             .iter()
             .filter(|krate| krate.is_workspace_member)
-            .filter_map(|krate| krate.build.clone())
+            .filter_map(|krate| krate.build.as_ref())
             .find(|build| build.build_file.as_std_path() == path)
+            .cloned()
+    }
+
+    pub fn crate_by_label(&self, label: &str) -> Option<&Crate> {
+        // this is fast enough for now, but it's unfortunate that this is O(crates).
+        self.crates
+            .iter()
+            .filter(|krate| krate.is_workspace_member)
+            .find(|krate| krate.build.as_ref().is_some_and(|build| build.label == label))
     }
 
     /// Returns the path to the project's manifest or root folder, if no manifest exists.
@@ -231,6 +246,10 @@ impl ProjectJson {
     pub fn runnables(&self) -> &[Runnable] {
         &self.runnables
     }
+
+    pub fn runnable_template(&self, kind: RunnableKind) -> Option<&Runnable> {
+        self.runnables().iter().find(|r| r.kind == kind)
+    }
 }
 
 /// A crate points to the root module of a crate and lists the dependencies of the crate. This is
@@ -258,6 +277,12 @@ pub struct Crate {
     pub build: Option<Build>,
 }
 
+impl Crate {
+    pub fn iter_deps(&self) -> impl ExactSizeIterator<Item = CrateArrayIdx> {
+        self.deps.iter().map(|dep| dep.krate)
+    }
+}
+
 /// Additional, build-specific data about a crate.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Build {
@@ -328,13 +353,21 @@ pub struct Runnable {
 /// The kind of runnable.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RunnableKind {
+    /// `cargo check`, basically, with human-readable output.
     Check,
 
     /// Can run a binary.
+    /// May include {label} which will get the label from the `build` section of a crate.
     Run,
 
     /// Run a single test.
+    /// May include {label} which will get the label from the `build` section of a crate.
+    /// May include {test_id} which will get the test clicked on by the user.
     TestOne,
+
+    /// Template for checking a target, emitting rustc JSON diagnostics.
+    /// May include {label} which will get the label from the `build` section of a crate.
+    Flycheck,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
@@ -441,6 +474,7 @@ pub struct RunnableData {
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub enum RunnableKindData {
+    Flycheck,
     Check,
     Run,
     TestOne,
@@ -511,6 +545,7 @@ impl From<RunnableKindData> for RunnableKind {
             RunnableKindData::Check => RunnableKind::Check,
             RunnableKindData::Run => RunnableKind::Run,
             RunnableKindData::TestOne => RunnableKind::TestOne,
+            RunnableKindData::Flycheck => RunnableKind::Flycheck,
         }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index e39569e108de4..28ac94e4deb61 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -480,8 +480,8 @@ config_data! {
 
         /// Enables automatic discovery of projects using [`DiscoverWorkspaceConfig::command`].
         ///
-        /// [`DiscoverWorkspaceConfig`] also requires setting `progress_label` and `files_to_watch`.
-        /// `progress_label` is used for the title in progress indicators, whereas `files_to_watch`
+        /// [`DiscoverWorkspaceConfig`] also requires setting `progressLabel` and `filesToWatch`.
+        /// `progressLabel` is used for the title in progress indicators, whereas `filesToWatch`
         /// is used to determine which build system-specific files should be watched in order to
         /// reload rust-analyzer.
         ///
@@ -490,16 +490,17 @@ config_data! {
         /// "rust-analyzer.workspace.discoverConfig": {
         ///     "command": [
         ///         "rust-project",
-        ///         "develop-json"
+        ///         "develop-json",
+        ///         "{arg}"
         ///     ],
-        ///     "progressLabel": "rust-analyzer",
+        ///     "progressLabel": "buck2/rust-project",
         ///     "filesToWatch": [
         ///         "BUCK"
         ///     ]
         /// }
         /// ```
         ///
-        /// ## On `DiscoverWorkspaceConfig::command`
+        /// ## Workspace Discovery Protocol
         ///
         /// **Warning**: This format is provisional and subject to change.
         ///
@@ -870,10 +871,18 @@ config_data! {
         /// (i.e., the folder containing the `Cargo.toml`). This can be overwritten
         /// by changing `#rust-analyzer.check.invocationStrategy#`.
         ///
-        /// If `$saved_file` is part of the command, rust-analyzer will pass
-        /// the absolute path of the saved file to the provided command. This is
-        /// intended to be used with non-Cargo build systems.
-        /// Note that `$saved_file` is experimental and may be removed in the future.
+        /// It supports two interpolation syntaxes, both mainly intended to be used with
+        /// [non-Cargo build systems](./non_cargo_based_projects.md):
+        ///
+        /// - If `{saved_file}` is part of the command, rust-analyzer will pass
+        ///   the absolute path of the saved file to the provided command.
+        ///   (A previous version, `$saved_file`, also works.)
+        /// - If `{label}` is part of the command, rust-analyzer will pass the
+        ///   Cargo package ID, which can be used with `cargo check -p`, or a build label from
+        ///   `rust-project.json`. If `{label}` is included, rust-analyzer behaves much like
+        ///   [`"rust-analyzer.check.workspace": false`](#check.workspace).
+        ///
+        ///
         ///
         /// An example command would be:
         ///
@@ -2431,6 +2440,8 @@ impl Config {
 
     pub(crate) fn cargo_test_options(&self, source_root: Option<SourceRootId>) -> CargoOptions {
         CargoOptions {
+            // Might be nice to allow users to specify test_command = "nextest"
+            subcommand: "test".into(),
             target_tuples: self.cargo_target(source_root).clone().into_iter().collect(),
             all_targets: false,
             no_default_features: *self.cargo_noDefaultFeatures(source_root),
@@ -2464,9 +2475,9 @@ impl Config {
                     },
                 }
             }
-            Some(_) | None => FlycheckConfig::CargoCommand {
-                command: self.check_command(source_root).clone(),
-                options: CargoOptions {
+            Some(_) | None => FlycheckConfig::Automatic {
+                cargo_options: CargoOptions {
+                    subcommand: self.check_command(source_root).clone(),
                     target_tuples: self
                         .check_targets(source_root)
                         .clone()
@@ -4171,8 +4182,8 @@ mod tests {
         assert_eq!(config.cargo_targetDir(None), &None);
         assert!(matches!(
             config.flycheck(None),
-            FlycheckConfig::CargoCommand {
-                options: CargoOptions { target_dir_config: TargetDirectoryConfig::None, .. },
+            FlycheckConfig::Automatic {
+                cargo_options: CargoOptions { target_dir_config: TargetDirectoryConfig::None, .. },
                 ..
             }
         ));
@@ -4195,8 +4206,8 @@ mod tests {
             Utf8PathBuf::from(std::env::var("CARGO_TARGET_DIR").unwrap_or("target".to_owned()));
         assert!(matches!(
             config.flycheck(None),
-            FlycheckConfig::CargoCommand {
-                options: CargoOptions { target_dir_config, .. },
+            FlycheckConfig::Automatic {
+                cargo_options: CargoOptions { target_dir_config, .. },
                 ..
             } if target_dir_config.target_dir(Some(&ws_target_dir)).map(Cow::into_owned)
                 == Some(ws_target_dir.join("rust-analyzer"))
@@ -4221,8 +4232,8 @@ mod tests {
         );
         assert!(matches!(
             config.flycheck(None),
-            FlycheckConfig::CargoCommand {
-                options: CargoOptions { target_dir_config, .. },
+            FlycheckConfig::Automatic {
+                cargo_options: CargoOptions { target_dir_config, .. },
                 ..
             } if target_dir_config.target_dir(None).map(Cow::into_owned)
                 == Some(Utf8PathBuf::from("other_folder"))
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config/patch_old_style.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config/patch_old_style.rs
index 389bb7848c01c..5dc463eccce46 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config/patch_old_style.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config/patch_old_style.rs
@@ -3,7 +3,7 @@ use serde_json::{Value, json};
 
 /// This function patches the json config to the new expected keys.
 /// That is we try to load old known config keys here and convert them to the new ones.
-/// See https://github.com/rust-lang/rust-analyzer/pull/12010
+/// See <https://github.com/rust-lang/rust-analyzer/pull/12010>
 ///
 /// We already have an alias system for simple cases, but if we make structural changes
 /// the alias infra fails down.
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
index 4a247800af9d5..712960f13d7e9 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
@@ -3,7 +3,6 @@ pub(crate) mod flycheck_to_proto;
 
 use std::mem;
 
-use cargo_metadata::PackageId;
 use ide::FileId;
 use ide_db::{FxHashMap, base_db::DbPanicContext};
 use itertools::Itertools;
@@ -12,10 +11,13 @@ use smallvec::SmallVec;
 use stdx::iter_eq_by;
 use triomphe::Arc;
 
-use crate::{global_state::GlobalStateSnapshot, lsp, lsp_ext, main_loop::DiagnosticsTaskKind};
+use crate::{
+    flycheck::PackageSpecifier, global_state::GlobalStateSnapshot, lsp, lsp_ext,
+    main_loop::DiagnosticsTaskKind,
+};
 
 pub(crate) type CheckFixes =
-    Arc<Vec<FxHashMap<Option<Arc<PackageId>>, FxHashMap<FileId, Vec<Fix>>>>>;
+    Arc<Vec<FxHashMap<Option<PackageSpecifier>, FxHashMap<FileId, Vec<Fix>>>>>;
 
 #[derive(Debug, Default, Clone)]
 pub struct DiagnosticsMapConfig {
@@ -29,7 +31,7 @@ pub(crate) type DiagnosticsGeneration = usize;
 
 #[derive(Debug, Clone, Default)]
 pub(crate) struct WorkspaceFlycheckDiagnostic {
-    pub(crate) per_package: FxHashMap<Option<Arc<PackageId>>, PackageFlycheckDiagnostic>,
+    pub(crate) per_package: FxHashMap<Option<PackageSpecifier>, PackageFlycheckDiagnostic>,
 }
 
 #[derive(Debug, Clone)]
@@ -85,7 +87,7 @@ impl DiagnosticCollection {
     pub(crate) fn clear_check_for_package(
         &mut self,
         flycheck_id: usize,
-        package_id: Arc<PackageId>,
+        package_id: PackageSpecifier,
     ) {
         let Some(check) = self.check.get_mut(flycheck_id) else {
             return;
@@ -124,7 +126,7 @@ impl DiagnosticCollection {
     pub(crate) fn clear_check_older_than_for_package(
         &mut self,
         flycheck_id: usize,
-        package_id: Arc<PackageId>,
+        package_id: PackageSpecifier,
         generation: DiagnosticsGeneration,
     ) {
         let Some(check) = self.check.get_mut(flycheck_id) else {
@@ -154,7 +156,7 @@ impl DiagnosticCollection {
         &mut self,
         flycheck_id: usize,
         generation: DiagnosticsGeneration,
-        package_id: &Option<Arc<PackageId>>,
+        package_id: &Option<PackageSpecifier>,
         file_id: FileId,
         diagnostic: lsp_types::Diagnostic,
         fix: Option<Box<Fix>>,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/discover.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/discover.rs
index 4aef5b0b7f3d5..f129f156a030a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/discover.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/discover.rs
@@ -42,7 +42,7 @@ impl DiscoverCommand {
         Self { sender, command }
     }
 
-    /// Spawn the command inside [Discover] and report progress, if any.
+    /// Spawn the command inside `DiscoverCommand` and report progress, if any.
     pub(crate) fn spawn(
         &self,
         discover_arg: DiscoverArgument,
@@ -73,7 +73,7 @@ impl DiscoverCommand {
     }
 }
 
-/// A handle to a spawned [Discover].
+/// A handle to a spawned `DiscoverCommand`.
 #[derive(Debug)]
 pub(crate) struct DiscoverHandle {
     pub(crate) handle: CommandHandle<DiscoverProjectMessage>,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
index b062641691885..512c231990cb6 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
@@ -14,6 +14,7 @@ use ide_db::FxHashSet;
 use itertools::Itertools;
 use paths::{AbsPath, AbsPathBuf, Utf8Path, Utf8PathBuf};
 use project_model::TargetDirectoryConfig;
+use project_model::project_json;
 use rustc_hash::FxHashMap;
 use serde::Deserialize as _;
 use serde_derive::Deserialize;
@@ -21,6 +22,7 @@ use serde_derive::Deserialize;
 pub(crate) use cargo_metadata::diagnostic::{
     Applicability, Diagnostic, DiagnosticCode, DiagnosticLevel, DiagnosticSpan,
 };
+use toolchain::DISPLAY_COMMAND_IGNORE_ENVS;
 use toolchain::Tool;
 use triomphe::Arc;
 
@@ -36,8 +38,11 @@ pub(crate) enum InvocationStrategy {
     PerWorkspace,
 }
 
+/// Data needed to construct a `cargo` command invocation, e.g. for flycheck or running a test.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct CargoOptions {
+    /// The cargo subcommand to run, e.g. "check" or "clippy"
+    pub(crate) subcommand: String,
     pub(crate) target_tuples: Vec<String>,
     pub(crate) all_targets: bool,
     pub(crate) set_test: bool,
@@ -89,13 +94,36 @@ impl CargoOptions {
     }
 }
 
+/// The flycheck config from a rust-project.json file or discoverConfig JSON output.
+#[derive(Debug, Default)]
+pub(crate) struct FlycheckConfigJson {
+    /// The template with [project_json::RunnableKind::Flycheck]
+    pub single_template: Option<project_json::Runnable>,
+}
+
+impl FlycheckConfigJson {
+    pub(crate) fn any_configured(&self) -> bool {
+        // self.workspace_template.is_some() ||
+        self.single_template.is_some()
+    }
+}
+
+/// The flycheck config from rust-analyzer's own configuration.
+///
+/// We rely on this when rust-project.json does not specify a flycheck runnable
+///
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum FlycheckConfig {
-    CargoCommand {
-        command: String,
-        options: CargoOptions,
+    /// Automatically use rust-project.json's flycheck runnable or just use cargo (the common case)
+    ///
+    /// We can't have a variant for ProjectJson because that is configured on the fly during
+    /// discoverConfig. We only know what we can read at config time.
+    Automatic {
+        /// If we do use cargo, how to build the check command
+        cargo_options: CargoOptions,
         ansi_color_output: bool,
     },
+    /// check_overrideCommand. This overrides both cargo and rust-project.json's flycheck runnable.
     CustomCommand {
         command: String,
         args: Vec<String>,
@@ -107,7 +135,7 @@ pub(crate) enum FlycheckConfig {
 impl FlycheckConfig {
     pub(crate) fn invocation_strategy(&self) -> InvocationStrategy {
         match self {
-            FlycheckConfig::CargoCommand { .. } => InvocationStrategy::PerWorkspace,
+            FlycheckConfig::Automatic { .. } => InvocationStrategy::PerWorkspace,
             FlycheckConfig::CustomCommand { invocation_strategy, .. } => {
                 invocation_strategy.clone()
             }
@@ -118,7 +146,9 @@ impl FlycheckConfig {
 impl fmt::Display for FlycheckConfig {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            FlycheckConfig::CargoCommand { command, .. } => write!(f, "cargo {command}"),
+            FlycheckConfig::Automatic { cargo_options, .. } => {
+                write!(f, "cargo {}", cargo_options.subcommand)
+            }
             FlycheckConfig::CustomCommand { command, args, .. } => {
                 // Don't show `my_custom_check --foo $saved_file` literally to the user, as it
                 // looks like we've forgotten to substitute $saved_file.
@@ -128,7 +158,7 @@ impl fmt::Display for FlycheckConfig {
                 // in the IDE (e.g. in the VS Code status bar).
                 let display_args = args
                     .iter()
-                    .map(|arg| if arg == SAVED_FILE_PLACEHOLDER { "..." } else { arg })
+                    .map(|arg| if arg == SAVED_FILE_PLACEHOLDER_DOLLAR { "..." } else { arg })
                     .collect::<Vec<_>>();
 
                 write!(f, "{command} {}", display_args.join(" "))
@@ -156,6 +186,7 @@ impl FlycheckHandle {
         generation: Arc<AtomicUsize>,
         sender: Sender<FlycheckMessage>,
         config: FlycheckConfig,
+        config_json: FlycheckConfigJson,
         sysroot_root: Option<AbsPathBuf>,
         workspace_root: AbsPathBuf,
         manifest_path: Option<AbsPathBuf>,
@@ -166,6 +197,7 @@ impl FlycheckHandle {
             generation.load(Ordering::Relaxed),
             sender,
             config,
+            config_json,
             sysroot_root,
             workspace_root,
             manifest_path,
@@ -195,16 +227,17 @@ impl FlycheckHandle {
     /// Schedule a re-start of the cargo check worker to do a package wide check.
     pub(crate) fn restart_for_package(
         &self,
-        package: Arc<PackageId>,
+        package: PackageSpecifier,
         target: Option<Target>,
-        workspace_deps: Option<FxHashSet<Arc<PackageId>>>,
+        workspace_deps: Option<FxHashSet<PackageSpecifier>>,
+        saved_file: Option<AbsPathBuf>,
     ) {
         let generation = self.generation.fetch_add(1, Ordering::Relaxed) + 1;
         self.sender
             .send(StateChange::Restart {
                 generation,
                 scope: FlycheckScope::Package { package, workspace_deps },
-                saved_file: None,
+                saved_file,
                 target,
             })
             .unwrap();
@@ -233,7 +266,7 @@ pub(crate) enum ClearDiagnosticsKind {
 #[derive(Debug)]
 pub(crate) enum ClearScope {
     Workspace,
-    Package(Arc<PackageId>),
+    Package(PackageSpecifier),
 }
 
 pub(crate) enum FlycheckMessage {
@@ -243,7 +276,7 @@ pub(crate) enum FlycheckMessage {
         generation: DiagnosticsGeneration,
         workspace_root: Arc<AbsPathBuf>,
         diagnostic: Diagnostic,
-        package_id: Option<Arc<PackageId>>,
+        package_id: Option<PackageSpecifier>,
     },
 
     /// Request clearing all outdated diagnostics.
@@ -286,16 +319,56 @@ impl fmt::Debug for FlycheckMessage {
 
 #[derive(Debug)]
 pub(crate) enum Progress {
-    DidStart,
+    DidStart {
+        /// The user sees this in VSCode, etc. May be a shortened version of the command we actually
+        /// executed, otherwise it is way too long.
+        user_facing_command: String,
+    },
     DidCheckCrate(String),
     DidFinish(io::Result<()>),
     DidCancel,
     DidFailToRestart(String),
 }
 
+#[derive(Debug, Clone)]
 enum FlycheckScope {
     Workspace,
-    Package { package: Arc<PackageId>, workspace_deps: Option<FxHashSet<Arc<PackageId>>> },
+    Package {
+        // Either a cargo package or a $label in rust-project.check.overrideCommand
+        package: PackageSpecifier,
+        workspace_deps: Option<FxHashSet<PackageSpecifier>>,
+    },
+}
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone)]
+pub(crate) enum PackageSpecifier {
+    Cargo {
+        /// The one in Cargo.toml, assumed to work with `cargo check -p {}` etc
+        package_id: Arc<PackageId>,
+    },
+    BuildInfo {
+        /// If a `build` field is present in rust-project.json, its label field
+        label: String,
+    },
+}
+
+impl PackageSpecifier {
+    pub(crate) fn as_str(&self) -> &str {
+        match self {
+            Self::Cargo { package_id } => &package_id.repr,
+            Self::BuildInfo { label } => label,
+        }
+    }
+}
+
+#[derive(Debug)]
+enum FlycheckCommandOrigin {
+    /// Regular cargo invocation
+    Cargo,
+    /// Configured via check_overrideCommand
+    CheckOverrideCommand,
+    /// From a runnable with [project_json::RunnableKind::Flycheck]
+    ProjectJsonRunnable,
 }
 
 enum StateChange {
@@ -316,6 +389,8 @@ struct FlycheckActor {
     generation: DiagnosticsGeneration,
     sender: Sender<FlycheckMessage>,
     config: FlycheckConfig,
+    config_json: FlycheckConfigJson,
+
     manifest_path: Option<AbsPathBuf>,
     ws_target_dir: Option<Utf8PathBuf>,
     /// Either the workspace root of the workspace we are flychecking,
@@ -331,7 +406,7 @@ struct FlycheckActor {
     command_handle: Option<CommandHandle<CargoCheckMessage>>,
     /// The receiver side of the channel mentioned above.
     command_receiver: Option<Receiver<CargoCheckMessage>>,
-    diagnostics_cleared_for: FxHashSet<Arc<PackageId>>,
+    diagnostics_cleared_for: FxHashSet<PackageSpecifier>,
     diagnostics_received: DiagnosticsReceived,
 }
 
@@ -348,7 +423,66 @@ enum Event {
     CheckEvent(Option<CargoCheckMessage>),
 }
 
-pub(crate) const SAVED_FILE_PLACEHOLDER: &str = "$saved_file";
+/// This is stable behaviour. Don't change.
+const SAVED_FILE_PLACEHOLDER_DOLLAR: &str = "$saved_file";
+const LABEL_INLINE: &str = "{label}";
+const SAVED_FILE_INLINE: &str = "{saved_file}";
+
+struct Substitutions<'a> {
+    label: Option<&'a str>,
+    saved_file: Option<&'a str>,
+}
+
+impl<'a> Substitutions<'a> {
+    /// If you have a runnable, and it has {label} in it somewhere, treat it as a template that
+    /// may be unsatisfied if you do not provide a label to substitute into it. Returns None in
+    /// that situation. Otherwise performs the requested substitutions.
+    ///
+    /// Same for {saved_file}.
+    ///
+    #[allow(clippy::disallowed_types)] /* generic parameter allows for FxHashMap */
+    fn substitute<H>(
+        self,
+        template: &project_json::Runnable,
+        extra_env: &std::collections::HashMap<String, Option<String>, H>,
+    ) -> Option<Command> {
+        let mut cmd = toolchain::command(&template.program, &template.cwd, extra_env);
+        for arg in &template.args {
+            if let Some(ix) = arg.find(LABEL_INLINE) {
+                if let Some(label) = self.label {
+                    let mut arg = arg.to_string();
+                    arg.replace_range(ix..ix + LABEL_INLINE.len(), label);
+                    cmd.arg(arg);
+                    continue;
+                } else {
+                    return None;
+                }
+            }
+            if let Some(ix) = arg.find(SAVED_FILE_INLINE) {
+                if let Some(saved_file) = self.saved_file {
+                    let mut arg = arg.to_string();
+                    arg.replace_range(ix..ix + SAVED_FILE_INLINE.len(), saved_file);
+                    cmd.arg(arg);
+                    continue;
+                } else {
+                    return None;
+                }
+            }
+            // Legacy syntax: full argument match
+            if arg == SAVED_FILE_PLACEHOLDER_DOLLAR {
+                if let Some(saved_file) = self.saved_file {
+                    cmd.arg(saved_file);
+                    continue;
+                } else {
+                    return None;
+                }
+            }
+            cmd.arg(arg);
+        }
+        cmd.current_dir(&template.cwd);
+        Some(cmd)
+    }
+}
 
 impl FlycheckActor {
     fn new(
@@ -356,6 +490,7 @@ impl FlycheckActor {
         generation: DiagnosticsGeneration,
         sender: Sender<FlycheckMessage>,
         config: FlycheckConfig,
+        config_json: FlycheckConfigJson,
         sysroot_root: Option<AbsPathBuf>,
         workspace_root: AbsPathBuf,
         manifest_path: Option<AbsPathBuf>,
@@ -367,6 +502,7 @@ impl FlycheckActor {
             generation,
             sender,
             config,
+            config_json,
             sysroot_root,
             root: Arc::new(workspace_root),
             scope: FlycheckScope::Workspace,
@@ -418,27 +554,39 @@ impl FlycheckActor {
                     }
 
                     let command = self.check_command(&scope, saved_file.as_deref(), target);
-                    self.scope = scope;
+                    self.scope = scope.clone();
                     self.generation = generation;
 
-                    let Some(command) = command else {
+                    let Some((command, origin)) = command else {
+                        tracing::debug!(?scope, "failed to build flycheck command");
                         continue;
                     };
 
-                    let formatted_command = format!("{command:?}");
+                    let debug_command = format!("{command:?}");
+                    let user_facing_command = match origin {
+                        // Don't show all the --format=json-with-blah-blah args, just the simple
+                        // version
+                        FlycheckCommandOrigin::Cargo => self.config.to_string(),
+                        // show them the full command but pretty printed. advanced user
+                        FlycheckCommandOrigin::ProjectJsonRunnable
+                        | FlycheckCommandOrigin::CheckOverrideCommand => display_command(
+                            &command,
+                            Some(std::path::Path::new(self.root.as_path())),
+                        ),
+                    };
 
-                    tracing::debug!(?command, "will restart flycheck");
+                    tracing::debug!(?origin, ?command, "will restart flycheck");
                     let (sender, receiver) = unbounded();
                     match CommandHandle::spawn(
                         command,
                         CargoCheckParser,
                         sender,
                         match &self.config {
-                            FlycheckConfig::CargoCommand { options, .. } => {
+                            FlycheckConfig::Automatic { cargo_options, .. } => {
                                 let ws_target_dir =
                                     self.ws_target_dir.as_ref().map(Utf8PathBuf::as_path);
                                 let target_dir =
-                                    options.target_dir_config.target_dir(ws_target_dir);
+                                    cargo_options.target_dir_config.target_dir(ws_target_dir);
 
                                 // If `"rust-analyzer.cargo.targetDir": null`, we should use
                                 // workspace's target dir instead of hard-coded fallback.
@@ -464,14 +612,14 @@ impl FlycheckActor {
                         },
                     ) {
                         Ok(command_handle) => {
-                            tracing::debug!(command = formatted_command, "did restart flycheck");
+                            tracing::debug!(?origin, command = %debug_command, "did restart flycheck");
                             self.command_handle = Some(command_handle);
                             self.command_receiver = Some(receiver);
-                            self.report_progress(Progress::DidStart);
+                            self.report_progress(Progress::DidStart { user_facing_command });
                         }
                         Err(error) => {
                             self.report_progress(Progress::DidFailToRestart(format!(
-                                "Failed to run the following command: {formatted_command} error={error}"
+                                "Failed to run the following command: {debug_command} origin={origin:?} error={error}"
                             )));
                         }
                     }
@@ -564,7 +712,10 @@ impl FlycheckActor {
                             msg.target.kind.iter().format_with(", ", |kind, f| f(&kind)),
                         )));
                         let package_id = Arc::new(msg.package_id);
-                        if self.diagnostics_cleared_for.insert(package_id.clone()) {
+                        if self
+                            .diagnostics_cleared_for
+                            .insert(PackageSpecifier::Cargo { package_id: package_id.clone() })
+                        {
                             tracing::trace!(
                                 flycheck_id = self.id,
                                 package_id = package_id.repr,
@@ -572,7 +723,9 @@ impl FlycheckActor {
                             );
                             self.send(FlycheckMessage::ClearDiagnostics {
                                 id: self.id,
-                                kind: ClearDiagnosticsKind::All(ClearScope::Package(package_id)),
+                                kind: ClearDiagnosticsKind::All(ClearScope::Package(
+                                    PackageSpecifier::Cargo { package_id },
+                                )),
                             });
                         }
                     }
@@ -580,7 +733,7 @@ impl FlycheckActor {
                         tracing::trace!(
                             flycheck_id = self.id,
                             message = diagnostic.message,
-                            package_id = package_id.as_ref().map(|it| &it.repr),
+                            package_id = package_id.as_ref().map(|it| it.as_str()),
                             "diagnostic received"
                         );
                         if self.diagnostics_received == DiagnosticsReceived::No {
@@ -590,7 +743,7 @@ impl FlycheckActor {
                             if self.diagnostics_cleared_for.insert(package_id.clone()) {
                                 tracing::trace!(
                                     flycheck_id = self.id,
-                                    package_id = package_id.repr,
+                                    package_id = package_id.as_str(),
                                     "clearing diagnostics"
                                 );
                                 self.send(FlycheckMessage::ClearDiagnostics {
@@ -642,6 +795,29 @@ impl FlycheckActor {
         self.diagnostics_received = DiagnosticsReceived::No;
     }
 
+    fn explicit_check_command(
+        &self,
+        scope: &FlycheckScope,
+        saved_file: Option<&AbsPath>,
+    ) -> Option<Command> {
+        let label = match scope {
+            // We could add a runnable like "RunnableKind::FlycheckWorkspace". But generally
+            // if you're not running cargo, it's because your workspace is too big to check
+            // all at once. You can always use `check_overrideCommand` with no {label}.
+            FlycheckScope::Workspace => return None,
+            FlycheckScope::Package { package: PackageSpecifier::BuildInfo { label }, .. } => {
+                label.as_str()
+            }
+            FlycheckScope::Package {
+                package: PackageSpecifier::Cargo { package_id: label },
+                ..
+            } => &label.repr,
+        };
+        let template = self.config_json.single_template.as_ref()?;
+        let subs = Substitutions { label: Some(label), saved_file: saved_file.map(|x| x.as_str()) };
+        subs.substitute(template, &FxHashMap::default())
+    }
+
     /// Construct a `Command` object for checking the user's code. If the user
     /// has specified a custom command with placeholders that we cannot fill,
     /// return None.
@@ -650,23 +826,49 @@ impl FlycheckActor {
         scope: &FlycheckScope,
         saved_file: Option<&AbsPath>,
         target: Option<Target>,
-    ) -> Option<Command> {
+    ) -> Option<(Command, FlycheckCommandOrigin)> {
         match &self.config {
-            FlycheckConfig::CargoCommand { command, options, ansi_color_output } => {
+            FlycheckConfig::Automatic { cargo_options, ansi_color_output } => {
+                // Only use the rust-project.json's flycheck config when no check_overrideCommand
+                // is configured. In the FlycheckConcig::CustomCommand branch we will still do
+                // label substitution, but on the overrideCommand instead.
+                //
+                // There needs to be SOME way to override what your discoverConfig tool says,
+                // because to change the flycheck runnable there you may have to literally
+                // recompile the tool.
+                if self.config_json.any_configured() {
+                    // Completely handle according to rust-project.json.
+                    // We don't consider this to be "using cargo" so we will not apply any of the
+                    // CargoOptions to the command.
+                    let cmd = self.explicit_check_command(scope, saved_file)?;
+                    return Some((cmd, FlycheckCommandOrigin::ProjectJsonRunnable));
+                }
+
                 let mut cmd =
-                    toolchain::command(Tool::Cargo.path(), &*self.root, &options.extra_env);
+                    toolchain::command(Tool::Cargo.path(), &*self.root, &cargo_options.extra_env);
                 if let Some(sysroot_root) = &self.sysroot_root
-                    && !options.extra_env.contains_key("RUSTUP_TOOLCHAIN")
+                    && !cargo_options.extra_env.contains_key("RUSTUP_TOOLCHAIN")
                     && std::env::var_os("RUSTUP_TOOLCHAIN").is_none()
                 {
                     cmd.env("RUSTUP_TOOLCHAIN", AsRef::<std::path::Path>::as_ref(sysroot_root));
                 }
                 cmd.env("CARGO_LOG", "cargo::core::compiler::fingerprint=info");
-                cmd.arg(command);
+                cmd.arg(&cargo_options.subcommand);
 
                 match scope {
                     FlycheckScope::Workspace => cmd.arg("--workspace"),
-                    FlycheckScope::Package { package, .. } => cmd.arg("-p").arg(&package.repr),
+                    FlycheckScope::Package {
+                        package: PackageSpecifier::Cargo { package_id },
+                        ..
+                    } => cmd.arg("-p").arg(&package_id.repr),
+                    FlycheckScope::Package {
+                        package: PackageSpecifier::BuildInfo { .. }, ..
+                    } => {
+                        // No way to flycheck this single package. All we have is a build label.
+                        // There's no way to really say whether this build label happens to be
+                        // a cargo canonical name, so we won't try.
+                        return None;
+                    }
                 };
 
                 if let Some(tgt) = target {
@@ -695,12 +897,12 @@ impl FlycheckActor {
 
                 cmd.arg("--keep-going");
 
-                options.apply_on_command(
+                cargo_options.apply_on_command(
                     &mut cmd,
                     self.ws_target_dir.as_ref().map(Utf8PathBuf::as_path),
                 );
-                cmd.args(&options.extra_args);
-                Some(cmd)
+                cmd.args(&cargo_options.extra_args);
+                Some((cmd, FlycheckCommandOrigin::Cargo))
             }
             FlycheckConfig::CustomCommand { command, args, extra_env, invocation_strategy } => {
                 let root = match invocation_strategy {
@@ -710,31 +912,25 @@ impl FlycheckActor {
                         &*self.root
                     }
                 };
-                let mut cmd = toolchain::command(command, root, extra_env);
-
-                // If the custom command has a $saved_file placeholder, and
-                // we're saving a file, replace the placeholder in the arguments.
-                if let Some(saved_file) = saved_file {
-                    for arg in args {
-                        if arg == SAVED_FILE_PLACEHOLDER {
-                            cmd.arg(saved_file);
-                        } else {
-                            cmd.arg(arg);
-                        }
-                    }
-                } else {
-                    for arg in args {
-                        if arg == SAVED_FILE_PLACEHOLDER {
-                            // The custom command has a $saved_file placeholder,
-                            // but we had an IDE event that wasn't a file save. Do nothing.
-                            return None;
-                        }
+                let runnable = project_json::Runnable {
+                    program: command.clone(),
+                    cwd: Utf8Path::to_owned(root.as_ref()),
+                    args: args.clone(),
+                    kind: project_json::RunnableKind::Flycheck,
+                };
 
-                        cmd.arg(arg);
-                    }
-                }
+                let label = match scope {
+                    FlycheckScope::Workspace => None,
+                    // We support substituting both build labels (e.g. buck, bazel) and cargo package ids.
+                    // With cargo package ids, you get `cargo check -p path+file:///path/to/rust-analyzer/crates/hir#0.0.0`.
+                    // That does work!
+                    FlycheckScope::Package { package, .. } => Some(package.as_str()),
+                };
 
-                Some(cmd)
+                let subs = Substitutions { label, saved_file: saved_file.map(|x| x.as_str()) };
+                let cmd = subs.substitute(&runnable, extra_env)?;
+
+                Some((cmd, FlycheckCommandOrigin::CheckOverrideCommand))
             }
         }
     }
@@ -748,7 +944,7 @@ impl FlycheckActor {
 #[allow(clippy::large_enum_variant)]
 enum CargoCheckMessage {
     CompilerArtifact(cargo_metadata::Artifact),
-    Diagnostic { diagnostic: Diagnostic, package_id: Option<Arc<PackageId>> },
+    Diagnostic { diagnostic: Diagnostic, package_id: Option<PackageSpecifier> },
 }
 
 struct CargoCheckParser;
@@ -767,7 +963,9 @@ impl JsonLinesParser<CargoCheckMessage> for CargoCheckParser {
                     cargo_metadata::Message::CompilerMessage(msg) => {
                         Some(CargoCheckMessage::Diagnostic {
                             diagnostic: msg.message,
-                            package_id: Some(Arc::new(msg.package_id)),
+                            package_id: Some(PackageSpecifier::Cargo {
+                                package_id: Arc::new(msg.package_id),
+                            }),
                         })
                     }
                     _ => None,
@@ -794,3 +992,181 @@ enum JsonMessage {
     Cargo(cargo_metadata::Message),
     Rustc(Diagnostic),
 }
+
+/// Not good enough to execute in a shell, but good enough to show the user without all the noisy
+/// quotes
+///
+/// Pass implicit_cwd if there is one regarded as the obvious by the user, so we can skip showing it.
+/// Compactness is the aim of the game, the output typically gets truncated quite a lot.
+fn display_command(c: &Command, implicit_cwd: Option<&std::path::Path>) -> String {
+    let mut o = String::new();
+    use std::fmt::Write;
+    let lossy = std::ffi::OsStr::to_string_lossy;
+    if let Some(dir) = c.get_current_dir() {
+        if Some(dir) == implicit_cwd.map(std::path::Path::new) {
+            // pass
+        } else if dir.to_string_lossy().contains(" ") {
+            write!(o, "cd {:?} && ", dir).unwrap();
+        } else {
+            write!(o, "cd {} && ", dir.display()).unwrap();
+        }
+    }
+    for (env, val) in c.get_envs() {
+        let (env, val) = (lossy(env), val.map(lossy).unwrap_or(std::borrow::Cow::Borrowed("")));
+        if DISPLAY_COMMAND_IGNORE_ENVS.contains(&env.as_ref()) {
+            continue;
+        }
+        if env.contains(" ") {
+            write!(o, "\"{}={}\" ", env, val).unwrap();
+        } else if val.contains(" ") {
+            write!(o, "{}=\"{}\" ", env, val).unwrap();
+        } else {
+            write!(o, "{}={} ", env, val).unwrap();
+        }
+    }
+    let prog = lossy(c.get_program());
+    if prog.contains(" ") {
+        write!(o, "{:?}", prog).unwrap();
+    } else {
+        write!(o, "{}", prog).unwrap();
+    }
+    for arg in c.get_args() {
+        let arg = lossy(arg);
+        if arg.contains(" ") {
+            write!(o, " \"{}\"", arg).unwrap();
+        } else {
+            write!(o, " {}", arg).unwrap();
+        }
+    }
+    o
+}
+
+#[cfg(test)]
+mod tests {
+    use ide_db::FxHashMap;
+    use itertools::Itertools;
+    use paths::Utf8Path;
+    use project_model::project_json;
+
+    use crate::flycheck::Substitutions;
+    use crate::flycheck::display_command;
+
+    #[test]
+    fn test_substitutions() {
+        let label = ":label";
+        let saved_file = "file.rs";
+
+        // Runnable says it needs both; you need both.
+        assert_eq!(test_substitute(None, None, "{label} {saved_file}").as_deref(), None);
+        assert_eq!(test_substitute(Some(label), None, "{label} {saved_file}").as_deref(), None);
+        assert_eq!(
+            test_substitute(None, Some(saved_file), "{label} {saved_file}").as_deref(),
+            None
+        );
+        assert_eq!(
+            test_substitute(Some(label), Some(saved_file), "{label} {saved_file}").as_deref(),
+            Some("build :label file.rs")
+        );
+
+        // Only need label? only need label.
+        assert_eq!(test_substitute(None, None, "{label}").as_deref(), None);
+        assert_eq!(test_substitute(Some(label), None, "{label}").as_deref(), Some("build :label"),);
+        assert_eq!(test_substitute(None, Some(saved_file), "{label}").as_deref(), None,);
+        assert_eq!(
+            test_substitute(Some(label), Some(saved_file), "{label}").as_deref(),
+            Some("build :label"),
+        );
+
+        // Only need saved_file
+        assert_eq!(test_substitute(None, None, "{saved_file}").as_deref(), None);
+        assert_eq!(test_substitute(Some(label), None, "{saved_file}").as_deref(), None);
+        assert_eq!(
+            test_substitute(None, Some(saved_file), "{saved_file}").as_deref(),
+            Some("build file.rs")
+        );
+        assert_eq!(
+            test_substitute(Some(label), Some(saved_file), "{saved_file}").as_deref(),
+            Some("build file.rs")
+        );
+
+        // Need neither
+        assert_eq!(test_substitute(None, None, "xxx").as_deref(), Some("build xxx"));
+        assert_eq!(test_substitute(Some(label), None, "xxx").as_deref(), Some("build xxx"));
+        assert_eq!(test_substitute(None, Some(saved_file), "xxx").as_deref(), Some("build xxx"));
+        assert_eq!(
+            test_substitute(Some(label), Some(saved_file), "xxx").as_deref(),
+            Some("build xxx")
+        );
+
+        // {label} mid-argument substitution
+        assert_eq!(
+            test_substitute(Some(label), None, "--label={label}").as_deref(),
+            Some("build --label=:label")
+        );
+
+        // {saved_file} mid-argument substitution
+        assert_eq!(
+            test_substitute(None, Some(saved_file), "--saved={saved_file}").as_deref(),
+            Some("build --saved=file.rs")
+        );
+
+        // $saved_file legacy support (no mid-argument substitution, we never supported that)
+        assert_eq!(
+            test_substitute(None, Some(saved_file), "$saved_file").as_deref(),
+            Some("build file.rs")
+        );
+
+        fn test_substitute(
+            label: Option<&str>,
+            saved_file: Option<&str>,
+            args: &str,
+        ) -> Option<String> {
+            Substitutions { label, saved_file }
+                .substitute(
+                    &project_json::Runnable {
+                        program: "build".to_owned(),
+                        args: Vec::from_iter(args.split_whitespace().map(ToOwned::to_owned)),
+                        cwd: Utf8Path::new("/path").to_owned(),
+                        kind: project_json::RunnableKind::Flycheck,
+                    },
+                    &FxHashMap::default(),
+                )
+                .map(|command| {
+                    command.get_args().map(|x| x.to_string_lossy()).collect_vec().join(" ")
+                })
+                .map(|args| format!("build {}", args))
+        }
+    }
+
+    #[test]
+    fn test_display_command() {
+        use std::path::Path;
+        let workdir = Path::new("workdir");
+        let mut cmd = toolchain::command("command", workdir, &FxHashMap::default());
+        assert_eq!(display_command(cmd.arg("--arg"), Some(workdir)), "command --arg");
+        assert_eq!(
+            display_command(cmd.arg("spaced arg"), Some(workdir)),
+            "command --arg \"spaced arg\""
+        );
+        assert_eq!(
+            display_command(cmd.env("ENVIRON", "yeah"), Some(workdir)),
+            "ENVIRON=yeah command --arg \"spaced arg\""
+        );
+        assert_eq!(
+            display_command(cmd.env("OTHER", "spaced env"), Some(workdir)),
+            "ENVIRON=yeah OTHER=\"spaced env\" command --arg \"spaced arg\""
+        );
+        assert_eq!(
+            display_command(cmd.current_dir("/tmp"), Some(workdir)),
+            "cd /tmp && ENVIRON=yeah OTHER=\"spaced env\" command --arg \"spaced arg\""
+        );
+        assert_eq!(
+            display_command(cmd.current_dir("/tmp and/thing"), Some(workdir)),
+            "cd \"/tmp and/thing\" && ENVIRON=yeah OTHER=\"spaced env\" command --arg \"spaced arg\""
+        );
+        assert_eq!(
+            display_command(cmd.current_dir("/tmp and/thing"), Some(Path::new("/tmp and/thing"))),
+            "ENVIRON=yeah OTHER=\"spaced env\" command --arg \"spaced arg\""
+        );
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
index 9beab3c0e45c1..afd4162de6227 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
@@ -9,7 +9,6 @@ use std::{
     time::{Duration, Instant},
 };
 
-use cargo_metadata::PackageId;
 use crossbeam_channel::{Receiver, Sender, unbounded};
 use hir::ChangeWithProcMacros;
 use ide::{Analysis, AnalysisHost, Cancellable, FileId, SourceRootId};
@@ -36,7 +35,7 @@ use crate::{
     config::{Config, ConfigChange, ConfigErrors, RatomlFileKind},
     diagnostics::{CheckFixes, DiagnosticCollection},
     discover,
-    flycheck::{FlycheckHandle, FlycheckMessage},
+    flycheck::{FlycheckHandle, FlycheckMessage, PackageSpecifier},
     line_index::{LineEndings, LineIndex},
     lsp::{from_proto, to_proto::url_from_abs_path},
     lsp_ext,
@@ -113,6 +112,7 @@ pub(crate) struct GlobalState {
     pub(crate) flycheck_sender: Sender<FlycheckMessage>,
     pub(crate) flycheck_receiver: Receiver<FlycheckMessage>,
     pub(crate) last_flycheck_error: Option<String>,
+    pub(crate) flycheck_formatted_commands: Vec<String>,
 
     // Test explorer
     pub(crate) test_run_session: Option<Vec<CargoTestHandle>>,
@@ -188,7 +188,7 @@ pub(crate) struct GlobalState {
     /// been called.
     pub(crate) deferred_task_queue: DeferredTaskQueue,
 
-    /// HACK: Workaround for https://github.com/rust-lang/rust-analyzer/issues/19709
+    /// HACK: Workaround for <https://github.com/rust-lang/rust-analyzer/issues/19709>
     /// This is marked true if we failed to load a crate root file at crate graph creation,
     /// which will usually end up causing a bunch of incorrect diagnostics on startup.
     pub(crate) incomplete_crate_graph: bool,
@@ -289,6 +289,7 @@ impl GlobalState {
             flycheck_sender,
             flycheck_receiver,
             last_flycheck_error: None,
+            flycheck_formatted_commands: vec![],
 
             test_run_session: None,
             test_run_sender,
@@ -825,7 +826,7 @@ impl GlobalStateSnapshot {
                     let Some(krate) = project.crate_by_root(path) else {
                         continue;
                     };
-                    let Some(build) = krate.build else {
+                    let Some(build) = krate.build.clone() else {
                         continue;
                     };
 
@@ -833,6 +834,7 @@ impl GlobalStateSnapshot {
                         label: build.label,
                         target_kind: build.target_kind,
                         shell_runnables: project.runnables().to_owned(),
+                        project_root: project.project_root().to_owned(),
                     }));
                 }
                 ProjectWorkspaceKind::DetachedFile { .. } => {}
@@ -844,23 +846,43 @@ impl GlobalStateSnapshot {
 
     pub(crate) fn all_workspace_dependencies_for_package(
         &self,
-        package: &Arc<PackageId>,
-    ) -> Option<FxHashSet<Arc<PackageId>>> {
-        for workspace in self.workspaces.iter() {
-            match &workspace.kind {
-                ProjectWorkspaceKind::Cargo { cargo, .. }
-                | ProjectWorkspaceKind::DetachedFile { cargo: Some((cargo, _, _)), .. } => {
-                    let package = cargo.packages().find(|p| cargo[*p].id == *package)?;
-
-                    return cargo[package]
-                        .all_member_deps
-                        .as_ref()
-                        .map(|deps| deps.iter().map(|dep| cargo[*dep].id.clone()).collect());
-                }
-                _ => {}
+        package: &PackageSpecifier,
+    ) -> Option<FxHashSet<PackageSpecifier>> {
+        match package {
+            PackageSpecifier::Cargo { package_id } => {
+                self.workspaces.iter().find_map(|workspace| match &workspace.kind {
+                    ProjectWorkspaceKind::Cargo { cargo, .. }
+                    | ProjectWorkspaceKind::DetachedFile { cargo: Some((cargo, _, _)), .. } => {
+                        let package = cargo.packages().find(|p| cargo[*p].id == *package_id)?;
+
+                        cargo[package].all_member_deps.as_ref().map(|deps| {
+                            deps.iter()
+                                .map(|dep| cargo[*dep].id.clone())
+                                .map(|p| PackageSpecifier::Cargo { package_id: p })
+                                .collect()
+                        })
+                    }
+                    _ => None,
+                })
+            }
+            PackageSpecifier::BuildInfo { label } => {
+                self.workspaces.iter().find_map(|workspace| match &workspace.kind {
+                    ProjectWorkspaceKind::Json(p) => {
+                        let krate = p.crate_by_label(label)?;
+                        Some(
+                            krate
+                                .iter_deps()
+                                .filter_map(|dep| p[dep].build.as_ref())
+                                .map(|build| PackageSpecifier::BuildInfo {
+                                    label: build.label.clone(),
+                                })
+                                .collect(),
+                        )
+                    }
+                    _ => None,
+                })
             }
         }
-        None
     }
 
     pub(crate) fn file_exists(&self, file_id: FileId) -> bool {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/dispatch.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/dispatch.rs
index 10bbb0bb31d99..90deae2d902e5 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/dispatch.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/dispatch.rs
@@ -101,7 +101,7 @@ impl RequestDispatcher<'_> {
     }
 
     /// Dispatches a non-latency-sensitive request onto the thread pool. When the VFS is marked not
-    /// ready this will return a default constructed [`R::Result`].
+    /// ready this will return a default constructed `R::Result`.
     pub(crate) fn on<const ALLOW_RETRYING: bool, R>(
         &mut self,
         f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,
@@ -128,7 +128,7 @@ impl RequestDispatcher<'_> {
     }
 
     /// Dispatches a non-latency-sensitive request onto the thread pool. When the VFS is marked not
-    /// ready this will return a `default` constructed [`R::Result`].
+    /// ready this will return a `default` constructed `R::Result`.
     pub(crate) fn on_with_vfs_default<R>(
         &mut self,
         f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,
@@ -176,7 +176,7 @@ impl RequestDispatcher<'_> {
     }
 
     /// Dispatches a latency-sensitive request onto the thread pool. When the VFS is marked not
-    /// ready this will return a default constructed [`R::Result`].
+    /// ready this will return a default constructed `R::Result`.
     pub(crate) fn on_latency_sensitive<const ALLOW_RETRYING: bool, R>(
         &mut self,
         f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
index 4a6544508ff4e..d956010433301 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
@@ -18,7 +18,7 @@ use vfs::{AbsPathBuf, ChangeKind, VfsPath};
 
 use crate::{
     config::{Config, ConfigChange},
-    flycheck::{InvocationStrategy, Target},
+    flycheck::{InvocationStrategy, PackageSpecifier, Target},
     global_state::{FetchWorkspaceRequest, GlobalState},
     lsp::{from_proto, utils::apply_document_changes},
     lsp_ext::{self, RunFlycheckParams},
@@ -328,22 +328,33 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
                 }
                 InvocationStrategy::PerWorkspace => {
                     Box::new(move || {
-                        let target = TargetSpec::for_file(&world, file_id)?.and_then(|it| {
+                        let saved_file = vfs_path.as_path().map(ToOwned::to_owned);
+                        let target = TargetSpec::for_file(&world, file_id)?.map(|it| {
                             let tgt_kind = it.target_kind();
                             let (tgt_name, root, package) = match it {
-                                TargetSpec::Cargo(c) => (c.target, c.workspace_root, c.package_id),
-                                _ => return None,
+                                TargetSpec::Cargo(c) => (
+                                    Some(c.target),
+                                    c.workspace_root,
+                                    PackageSpecifier::Cargo { package_id: c.package_id },
+                                ),
+                                TargetSpec::ProjectJson(p) => (
+                                    None,
+                                    p.project_root,
+                                    PackageSpecifier::BuildInfo { label: p.label.clone() },
+                                ),
                             };
 
-                            let tgt = match tgt_kind {
-                                project_model::TargetKind::Bin => Target::Bin(tgt_name),
-                                project_model::TargetKind::Example => Target::Example(tgt_name),
-                                project_model::TargetKind::Test => Target::Test(tgt_name),
-                                project_model::TargetKind::Bench => Target::Benchmark(tgt_name),
-                                _ => return Some((None, root, package)),
-                            };
+                            let tgt = tgt_name.and_then(|tgt_name| {
+                                Some(match tgt_kind {
+                                    project_model::TargetKind::Bin => Target::Bin(tgt_name),
+                                    project_model::TargetKind::Example => Target::Example(tgt_name),
+                                    project_model::TargetKind::Test => Target::Test(tgt_name),
+                                    project_model::TargetKind::Bench => Target::Benchmark(tgt_name),
+                                    _ => return None,
+                                })
+                            });
 
-                            Some((Some(tgt), root, package))
+                            (tgt, root, package)
                         });
                         tracing::debug!(?target, "flycheck target");
                         // we have a specific non-library target, attempt to only check that target, nothing
@@ -352,8 +363,10 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
                         if let Some((target, root, package)) = target {
                             // trigger a package check if we have a non-library target as that can't affect
                             // anything else in the workspace OR if we're not allowed to check the workspace as
-                            // the user opted into package checks then
-                            let package_check_allowed = target.is_some() || !may_flycheck_workspace;
+                            // the user opted into package checks then OR if this is not cargo.
+                            let package_check_allowed = target.is_some()
+                                || !may_flycheck_workspace
+                                || matches!(package, PackageSpecifier::BuildInfo { .. });
                             if package_check_allowed {
                                 package_workspace_idx =
                                     world.workspaces.iter().position(|ws| match &ws.kind {
@@ -365,7 +378,13 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
                                             cargo: Some((cargo, _, _)),
                                             ..
                                         } => *cargo.workspace_root() == root,
-                                        _ => false,
+                                        project_model::ProjectWorkspaceKind::Json(p) => {
+                                            *p.project_root() == root
+                                        }
+                                        project_model::ProjectWorkspaceKind::DetachedFile {
+                                            cargo: None,
+                                            ..
+                                        } => false,
                                     });
                                 if let Some(idx) = package_workspace_idx {
                                     let workspace_deps =
@@ -374,6 +393,7 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
                                         package,
                                         target,
                                         workspace_deps,
+                                        saved_file.clone(),
                                     );
                                 }
                             }
@@ -444,7 +464,6 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
                                 ws_contains_file && !is_pkg_ws
                             });
 
-                        let saved_file = vfs_path.as_path().map(ToOwned::to_owned);
                         let mut workspace_check_triggered = false;
                         // Find and trigger corresponding flychecks
                         'flychecks: for flycheck in world.flycheck.iter() {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
index 6f0f57725fc7a..e5b983dcbf85c 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
@@ -70,6 +70,7 @@ pub(crate) fn symbol_kind(symbol_kind: SymbolKind) -> lsp_types::SymbolKind {
         | SymbolKind::Attribute
         | SymbolKind::Derive
         | SymbolKind::DeriveHelper => lsp_types::SymbolKind::FUNCTION,
+        SymbolKind::CrateRoot => lsp_types::SymbolKind::PACKAGE,
         SymbolKind::Module | SymbolKind::ToolModule => lsp_types::SymbolKind::MODULE,
         SymbolKind::TypeAlias | SymbolKind::TypeParam | SymbolKind::SelfType => {
             lsp_types::SymbolKind::TYPE_PARAMETER
@@ -141,6 +142,7 @@ pub(crate) fn completion_item_kind(
             SymbolKind::Method => lsp_types::CompletionItemKind::METHOD,
             SymbolKind::Const => lsp_types::CompletionItemKind::CONSTANT,
             SymbolKind::ConstParam => lsp_types::CompletionItemKind::TYPE_PARAMETER,
+            SymbolKind::CrateRoot => lsp_types::CompletionItemKind::MODULE,
             SymbolKind::Derive => lsp_types::CompletionItemKind::FUNCTION,
             SymbolKind::DeriveHelper => lsp_types::CompletionItemKind::FUNCTION,
             SymbolKind::Enum => lsp_types::CompletionItemKind::ENUM,
@@ -803,11 +805,16 @@ fn semantic_token_type_and_modifiers(
 ) -> (lsp_types::SemanticTokenType, semantic_tokens::ModifierSet) {
     use semantic_tokens::{modifiers as mods, types};
 
+    let mut mods = semantic_tokens::ModifierSet::default();
     let ty = match highlight.tag {
         HlTag::Symbol(symbol) => match symbol {
             SymbolKind::Attribute => types::DECORATOR,
             SymbolKind::Derive => types::DERIVE,
             SymbolKind::DeriveHelper => types::DERIVE_HELPER,
+            SymbolKind::CrateRoot => {
+                mods |= mods::CRATE_ROOT;
+                types::NAMESPACE
+            }
             SymbolKind::Module => types::NAMESPACE,
             SymbolKind::Impl => types::TYPE_ALIAS,
             SymbolKind::Field => types::PROPERTY,
@@ -870,7 +877,6 @@ fn semantic_token_type_and_modifiers(
         },
     };
 
-    let mut mods = semantic_tokens::ModifierSet::default();
     for modifier in highlight.mods.iter() {
         let modifier = match modifier {
             HlMod::Associated => mods::ASSOCIATED,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
index dd0813c14454c..62a3b3a17bdfc 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
@@ -1179,8 +1179,24 @@ impl GlobalState {
                 kind: ClearDiagnosticsKind::OlderThan(generation, ClearScope::Package(package_id)),
             } => self.diagnostics.clear_check_older_than_for_package(id, package_id, generation),
             FlycheckMessage::Progress { id, progress } => {
+                let format_with_id = |user_facing_command: String| {
+                    if self.flycheck.len() == 1 {
+                        user_facing_command
+                    } else {
+                        format!("{user_facing_command} (#{})", id + 1)
+                    }
+                };
+
+                self.flycheck_formatted_commands
+                    .resize_with(self.flycheck.len().max(id + 1), || {
+                        format_with_id(self.config.flycheck(None).to_string())
+                    });
+
                 let (state, message) = match progress {
-                    flycheck::Progress::DidStart => (Progress::Begin, None),
+                    flycheck::Progress::DidStart { user_facing_command } => {
+                        self.flycheck_formatted_commands[id] = format_with_id(user_facing_command);
+                        (Progress::Begin, None)
+                    }
                     flycheck::Progress::DidCheckCrate(target) => (Progress::Report, Some(target)),
                     flycheck::Progress::DidCancel => {
                         self.last_flycheck_error = None;
@@ -1200,13 +1216,8 @@ impl GlobalState {
                     }
                 };
 
-                // When we're running multiple flychecks, we have to include a disambiguator in
-                // the title, or the editor complains. Note that this is a user-facing string.
-                let title = if self.flycheck.len() == 1 {
-                    format!("{}", self.config.flycheck(None))
-                } else {
-                    format!("{} (#{})", self.config.flycheck(None), id + 1)
-                };
+                // Clone because we &mut self for report_progress
+                let title = self.flycheck_formatted_commands[id].clone();
                 self.report_progress(
                     &title,
                     state,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
index e3a5ee221973b..ccafbd7b30b9d 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
@@ -25,7 +25,9 @@ use load_cargo::{ProjectFolders, load_proc_macro};
 use lsp_types::FileSystemWatcher;
 use paths::Utf8Path;
 use proc_macro_api::ProcMacroClient;
-use project_model::{ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, WorkspaceBuildScripts};
+use project_model::{
+    ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, WorkspaceBuildScripts, project_json,
+};
 use stdx::{format_to, thread::ThreadIntent};
 use triomphe::Arc;
 use vfs::{AbsPath, AbsPathBuf, ChangeKind};
@@ -875,6 +877,7 @@ impl GlobalState {
                     generation.clone(),
                     sender.clone(),
                     config,
+                    crate::flycheck::FlycheckConfigJson::default(),
                     None,
                     self.config.root_path().clone(),
                     None,
@@ -894,16 +897,25 @@ impl GlobalState {
                                     cargo: Some((cargo, _, _)),
                                     ..
                                 } => (
+                                    crate::flycheck::FlycheckConfigJson::default(),
                                     cargo.workspace_root(),
                                     Some(cargo.manifest_path()),
                                     Some(cargo.target_directory()),
                                 ),
                                 ProjectWorkspaceKind::Json(project) => {
+                                    let config_json = crate::flycheck::FlycheckConfigJson {
+                                        single_template: project
+                                            .runnable_template(project_json::RunnableKind::Flycheck)
+                                            .cloned(),
+                                    };
                                     // Enable flychecks for json projects if a custom flycheck command was supplied
                                     // in the workspace configuration.
                                     match config {
+                                        _ if config_json.any_configured() => {
+                                            (config_json, project.path(), None, None)
+                                        }
                                         FlycheckConfig::CustomCommand { .. } => {
-                                            (project.path(), None, None)
+                                            (config_json, project.path(), None, None)
                                         }
                                         _ => return None,
                                     }
@@ -913,12 +925,13 @@ impl GlobalState {
                             ws.sysroot.root().map(ToOwned::to_owned),
                         ))
                     })
-                    .map(|(id, (root, manifest_path, target_dir), sysroot_root)| {
+                    .map(|(id, (config_json, root, manifest_path, target_dir), sysroot_root)| {
                         FlycheckHandle::spawn(
                             id,
                             generation.clone(),
                             sender.clone(),
                             config.clone(),
+                            config_json,
                             sysroot_root,
                             root.to_path_buf(),
                             manifest_path.map(|it| it.to_path_buf()),
@@ -929,6 +942,7 @@ impl GlobalState {
             }
         }
         .into();
+        self.flycheck_formatted_commands = vec![];
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
index e0f95a7830ea8..b8d9acc02a328 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
@@ -68,6 +68,7 @@ pub(crate) struct ProjectJsonTargetSpec {
     pub(crate) label: String,
     pub(crate) target_kind: TargetKind,
     pub(crate) shell_runnables: Vec<Runnable>,
+    pub(crate) project_root: AbsPathBuf,
 }
 
 impl ProjectJsonTargetSpec {
@@ -76,7 +77,16 @@ impl ProjectJsonTargetSpec {
             RunnableKind::Bin => {
                 for runnable in &self.shell_runnables {
                     if matches!(runnable.kind, project_model::project_json::RunnableKind::Run) {
-                        return Some(runnable.clone());
+                        let mut runnable = runnable.clone();
+
+                        let replaced_args: Vec<_> = runnable
+                            .args
+                            .iter()
+                            .map(|arg| arg.replace("{label}", &self.label))
+                            .collect();
+                        runnable.args = replaced_args;
+
+                        return Some(runnable);
                     }
                 }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/task_pool.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/task_pool.rs
index 8b8876b801cf8..104cd3d2eae9e 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/task_pool.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/task_pool.rs
@@ -52,7 +52,7 @@ impl<T> TaskPool<T> {
 /// `DeferredTaskQueue` holds deferred tasks.
 ///
 /// These are tasks that must be run after
-/// [`GlobalState::process_changes`] has been called.
+/// `GlobalState::process_changes` has been called.
 pub(crate) struct DeferredTaskQueue {
     pub(crate) sender: crossbeam_channel::Sender<DeferredTask>,
     pub(crate) receiver: crossbeam_channel::Receiver<DeferredTask>,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/test_runner.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/test_runner.rs
index 7111a15d02467..f0020f9088e3f 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/test_runner.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/test_runner.rs
@@ -105,7 +105,7 @@ impl CargoTestHandle {
         let mut cmd = toolchain::command(Tool::Cargo.path(), root, &options.extra_env);
         cmd.env("RUSTC_BOOTSTRAP", "1");
         cmd.arg("--color=always");
-        cmd.arg("test");
+        cmd.arg(&options.subcommand); // test, usually
 
         cmd.arg("--package");
         cmd.arg(&test_target.package);
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
index eb1b8c5dd0e6e..b4a7b44d165ac 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
@@ -1447,7 +1447,27 @@ foo = { path = "../foo" }
     .server()
     .wait_until_workspace_is_loaded();
 
-    server.request::<WorkspaceSymbolRequest>(Default::default(), json!([]));
+    server.request::<WorkspaceSymbolRequest>(
+        Default::default(),
+        json!([
+        {
+          "name": "bar",
+          "kind": 4,
+          "location": {
+            "uri": "file:///[..]bar/src/lib.rs",
+            "range": {
+              "start": {
+                "line": 0,
+                "character": 0
+              },
+              "end": {
+                "line": 0,
+                "character": 0
+              }
+            }
+          }
+        }]),
+    );
 
     let server = Project::with_fixture(
         r#"
@@ -1486,7 +1506,27 @@ version = "0.0.0"
     .server()
     .wait_until_workspace_is_loaded();
 
-    server.request::<WorkspaceSymbolRequest>(Default::default(), json!([]));
+    server.request::<WorkspaceSymbolRequest>(
+        Default::default(),
+        json!([
+        {
+          "name": "baz",
+          "kind": 4,
+          "location": {
+            "uri": "file:///[..]baz/src/lib.rs",
+            "range": {
+              "start": {
+                "line": 0,
+                "character": 0
+              },
+              "end": {
+                "line": 0,
+                "character": 0
+              }
+            }
+          }
+        }]),
+    );
 }
 
 #[test]
diff --git a/src/tools/rust-analyzer/crates/span/src/hygiene.rs b/src/tools/rust-analyzer/crates/span/src/hygiene.rs
index fdfa94dfee4eb..fe05ef9465181 100644
--- a/src/tools/rust-analyzer/crates/span/src/hygiene.rs
+++ b/src/tools/rust-analyzer/crates/span/src/hygiene.rs
@@ -8,9 +8,9 @@
 //!
 //! # The Expansion Order Hierarchy
 //!
-//! `ExpnData` in rustc, rust-analyzer's version is [`MacroCallLoc`]. Traversing the hierarchy
-//! upwards can be achieved by walking up [`MacroCallLoc::kind`]'s contained file id, as
-//! [`MacroFile`]s are interned [`MacroCallLoc`]s.
+//! `ExpnData` in rustc, rust-analyzer's version is `MacroCallLoc`. Traversing the hierarchy
+//! upwards can be achieved by walking up `MacroCallLoc::kind`'s contained file id, as
+//! `MacroFile`s are interned `MacroCallLoc`s.
 //!
 //! # The Macro Definition Hierarchy
 //!
@@ -18,7 +18,7 @@
 //!
 //! # The Call-site Hierarchy
 //!
-//! `ExpnData::call_site` in rustc, [`MacroCallLoc::call_site`] in rust-analyzer.
+//! `ExpnData::call_site` in rustc, `MacroCallLoc::call_site` in rust-analyzer.
 use crate::Edition;
 use std::fmt;
 
@@ -241,9 +241,7 @@ const _: () = {
                     edition: zalsa_::interned::Lookup::into_owned(data.2),
                     parent: zalsa_::interned::Lookup::into_owned(data.3),
                     opaque: opaque(zalsa_::FromId::from_id(id)),
-                    opaque_and_semiopaque: opaque_and_semiopaque(
-                        zalsa_::FromId::from_id(id),
-                    ),
+                    opaque_and_semiopaque: opaque_and_semiopaque(zalsa_::FromId::from_id(id)),
                 },
             )
         }
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ptr.rs b/src/tools/rust-analyzer/crates/syntax/src/ptr.rs
index 34c07598d2001..c4979b8e3ae80 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ptr.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ptr.rs
@@ -68,7 +68,7 @@ impl<N: AstNode> AstPtr<N> {
         self.raw
     }
 
-    pub fn text_range(&self) -> TextRange {
+    pub fn text_range(self) -> TextRange {
         self.raw.text_range()
     }
 
diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/mapping.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/mapping.rs
index 1eaef03197c5d..6257bf4e572ec 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/mapping.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/mapping.rs
@@ -1,6 +1,6 @@
 //! Maps syntax elements through disjoint syntax nodes.
 //!
-//! [`SyntaxMappingBuilder`] should be used to create mappings to add to a [`SyntaxEditor`]
+//! [`SyntaxMappingBuilder`] should be used to create mappings to add to a `SyntaxEditor`
 
 use itertools::Itertools;
 use rustc_hash::FxHashMap;
diff --git a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
index d81f27d7c3b1d..ca68edd88c059 100644
--- a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
@@ -37,7 +37,110 @@ use triomphe::Arc;
 
 pub const WORKSPACE: base_db::SourceRootId = base_db::SourceRootId(0);
 
+/// A trait for setting up test databases from fixture strings.
+///
+/// Fixtures are strings containing Rust source code with optional metadata that describe
+/// a project setup. This is the primary way to write tests for rust-analyzer without
+/// having to depend on the entire sysroot.
+///
+/// # Fixture Syntax
+///
+/// ## Basic Structure
+///
+/// A fixture without metadata is parsed into a single source file (`/main.rs`).
+/// Metadata is added after a `//-` comment prefix.
+///
+/// ```text
+/// //- /main.rs
+/// fn main() {
+///     println!("Hello");
+/// }
+/// ```
+///
+/// Note that the fixture syntax is optional and can be omitted if the test only requires
+/// a simple single file.
+///
+/// ## File Metadata
+///
+/// Each file can have the following metadata after `//-`:
+///
+/// - **Path** (required): Must start with `/`, e.g., `/main.rs`, `/lib.rs`, `/foo/bar.rs`
+/// - **`crate:<name>`**: Defines a new crate with this file as its root
+///   - Optional version: `crate:foo@0.1.0,https://example.com/repo.git`
+/// - **`deps:<crate1>,<crate2>`**: Dependencies (requires `crate:`)
+/// - **`extern-prelude:<crate1>,<crate2>`**: Limits extern prelude to specified crates
+/// - **`edition:<year>`**: Rust edition (2015, 2018, 2021, 2024). Defaults to current.
+/// - **`cfg:<key>=<value>,<flag>`**: Configuration options, e.g., `cfg:test,feature="foo"`
+/// - **`env:<KEY>=<value>`**: Environment variables
+/// - **`crate-attr:<attr>`**: Crate-level attributes, e.g., `crate-attr:no_std`
+/// - **`new_source_root:local|library`**: Starts a new source root
+/// - **`library`**: Marks crate as external library (not workspace member)
+///
+/// ## Global Meta (must appear at the top, in order)
+///
+/// - **`//- toolchain: nightly|stable`**: Sets the Rust toolchain (default: stable)
+/// - **`//- target_data_layout: <layout>`**: LLVM data layout string
+/// - **`//- target_arch: <arch>`**: Target architecture (default: x86_64)
+/// - **`//- proc_macros: <name1>,<name2>`**: Enables predefined test proc macros
+/// - **`//- minicore: <flag1>, <flag2>`**: Includes subset of libcore
+///
+/// ## Cursor Markers
+///
+/// Use `$0` to mark cursor position(s) in the fixture:
+/// - Single `$0`: marks a position (use with [`with_position`](Self::with_position))
+/// - Two `$0` markers: marks a range (use with [`with_range`](Self::with_range))
+/// - Escape as `\$0` if you need a literal `$0`
+///
+/// # Examples
+///
+/// ## Single file with cursor position
+/// ```text
+/// r#"
+/// fn main() {
+///     let x$0 = 42;
+/// }
+/// "#
+/// ```
+///
+/// ## Multiple crates with dependencies
+/// ```text
+/// r#"
+/// //- /main.rs crate:main deps:helper
+/// use helper::greet;
+/// fn main() { greet(); }
+///
+/// //- /lib.rs crate:helper
+/// pub fn greet() {}
+/// "#
+/// ```
+///
+/// ## Using minicore for lang items
+/// ```text
+/// r#"
+/// //- minicore: option, result, iterator
+/// //- /main.rs
+/// fn foo() -> Option<i32> { Some(42) }
+/// "#
+/// ```
+///
+/// The available minicore flags are listed at the top of crates\test-utils\src\minicore.rs.
+///
+/// ## Using test proc macros
+/// ```text
+/// r#"
+/// //- proc_macros: identity, mirror
+/// //- /main.rs crate:main deps:proc_macros
+/// use proc_macros::identity;
+///
+/// #[identity]
+/// fn foo() {}
+/// "#
+/// ```
+///
+/// Available proc macros: `identity` (attr), `DeriveIdentity` (derive), `input_replace` (attr),
+/// `mirror` (bang), `shorten` (bang)
 pub trait WithFixture: Default + ExpandDatabase + SourceDatabase + 'static {
+    /// See the trait documentation for more information on fixtures.
     #[track_caller]
     fn with_single_file(
         #[rust_analyzer::rust_fixture] ra_fixture: &str,
@@ -50,6 +153,7 @@ pub trait WithFixture: Default + ExpandDatabase + SourceDatabase + 'static {
         (db, file)
     }
 
+    /// See the trait documentation for more information on fixtures.
     #[track_caller]
     fn with_many_files(
         #[rust_analyzer::rust_fixture] ra_fixture: &str,
@@ -66,6 +170,7 @@ pub trait WithFixture: Default + ExpandDatabase + SourceDatabase + 'static {
         (db, files)
     }
 
+    /// See the trait documentation for more information on fixtures.
     #[track_caller]
     fn with_files(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> Self {
         let mut db = Self::default();
@@ -75,6 +180,7 @@ pub trait WithFixture: Default + ExpandDatabase + SourceDatabase + 'static {
         db
     }
 
+    /// See the trait documentation for more information on fixtures.
     #[track_caller]
     fn with_files_extra_proc_macros(
         #[rust_analyzer::rust_fixture] ra_fixture: &str,
@@ -88,6 +194,7 @@ pub trait WithFixture: Default + ExpandDatabase + SourceDatabase + 'static {
         db
     }
 
+    /// See the trait documentation for more information on fixtures.
     #[track_caller]
     fn with_position(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> (Self, FilePosition) {
         let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
@@ -95,6 +202,7 @@ pub trait WithFixture: Default + ExpandDatabase + SourceDatabase + 'static {
         (db, FilePosition { file_id, offset })
     }
 
+    /// See the trait documentation for more information on fixtures.
     #[track_caller]
     fn with_range(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> (Self, FileRange) {
         let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
@@ -102,6 +210,7 @@ pub trait WithFixture: Default + ExpandDatabase + SourceDatabase + 'static {
         (db, FileRange { file_id, range })
     }
 
+    /// See the trait documentation for more information on fixtures.
     #[track_caller]
     fn with_range_or_offset(
         #[rust_analyzer::rust_fixture] ra_fixture: &str,
diff --git a/src/tools/rust-analyzer/crates/toolchain/src/lib.rs b/src/tools/rust-analyzer/crates/toolchain/src/lib.rs
index 39319886cfe4a..1a17269838708 100644
--- a/src/tools/rust-analyzer/crates/toolchain/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/toolchain/src/lib.rs
@@ -74,6 +74,9 @@ impl Tool {
 // Prevent rustup from automatically installing toolchains, see https://github.com/rust-lang/rust-analyzer/issues/20719.
 pub const NO_RUSTUP_AUTO_INSTALL_ENV: (&str, &str) = ("RUSTUP_AUTO_INSTALL", "0");
 
+// These get ignored when displaying what command is running in LSP status messages.
+pub const DISPLAY_COMMAND_IGNORE_ENVS: &[&str] = &[NO_RUSTUP_AUTO_INSTALL_ENV.0];
+
 #[allow(clippy::disallowed_types)] /* generic parameter allows for FxHashMap */
 pub fn command<H>(
     cmd: impl AsRef<OsStr>,
diff --git a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
index 58b6363345279..c4124aaae0753 100644
--- a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
+++ b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
@@ -323,10 +323,18 @@ each of them, with the working directory being the workspace root
 (i.e., the folder containing the `Cargo.toml`). This can be overwritten
 by changing `#rust-analyzer.check.invocationStrategy#`.
 
-If `$saved_file` is part of the command, rust-analyzer will pass
-the absolute path of the saved file to the provided command. This is
-intended to be used with non-Cargo build systems.
-Note that `$saved_file` is experimental and may be removed in the future.
+It supports two interpolation syntaxes, both mainly intended to be used with
+[non-Cargo build systems](./non_cargo_based_projects.md):
+
+- If `{saved_file}` is part of the command, rust-analyzer will pass
+  the absolute path of the saved file to the provided command.
+  (A previous version, `$saved_file`, also works.)
+- If `{label}` is part of the command, rust-analyzer will pass the
+  Cargo package ID, which can be used with `cargo check -p`, or a build label from
+  `rust-project.json`. If `{label}` is included, rust-analyzer behaves much like
+  [`"rust-analyzer.check.workspace": false`](#check.workspace).
+
+
 
 An example command would be:
 
@@ -1613,8 +1621,8 @@ Default: `null`
 
 Enables automatic discovery of projects using [`DiscoverWorkspaceConfig::command`].
 
-[`DiscoverWorkspaceConfig`] also requires setting `progress_label` and `files_to_watch`.
-`progress_label` is used for the title in progress indicators, whereas `files_to_watch`
+[`DiscoverWorkspaceConfig`] also requires setting `progressLabel` and `filesToWatch`.
+`progressLabel` is used for the title in progress indicators, whereas `filesToWatch`
 is used to determine which build system-specific files should be watched in order to
 reload rust-analyzer.
 
@@ -1623,16 +1631,17 @@ Below is an example of a valid configuration:
 "rust-analyzer.workspace.discoverConfig": {
     "command": [
         "rust-project",
-        "develop-json"
+        "develop-json",
+        "{arg}"
     ],
-    "progressLabel": "rust-analyzer",
+    "progressLabel": "buck2/rust-project",
     "filesToWatch": [
         "BUCK"
     ]
 }
 ```
 
-## On `DiscoverWorkspaceConfig::command`
+## Workspace Discovery Protocol
 
 **Warning**: This format is provisional and subject to change.
 
diff --git a/src/tools/rust-analyzer/docs/book/src/non_cargo_based_projects.md b/src/tools/rust-analyzer/docs/book/src/non_cargo_based_projects.md
index e7df4a5d76685..a48b025c7b3a6 100644
--- a/src/tools/rust-analyzer/docs/book/src/non_cargo_based_projects.md
+++ b/src/tools/rust-analyzer/docs/book/src/non_cargo_based_projects.md
@@ -204,23 +204,40 @@ interface Runnable {
     args: string[];
     /// The current working directory of the runnable.
     cwd: string;
-    /// Used to decide what code lens to offer.
+    /// Maps a runnable to a piece of rust-analyzer functionality.
     ///
-    /// `testOne`: This runnable will be used when the user clicks the 'Run Test'
-    /// CodeLens above a test.
+    /// - `testOne`: This runnable will be used when the user clicks the 'Run Test'
+    ///   CodeLens above a test.
+    /// - `run`: This runnable will be used when the user clicks the 'Run' CodeLens
+    ///    above a main function or triggers a run command.
+    /// - `flycheck`: This is run to provide check-on-save diagnostics when the user
+    ///    saves a file. It must emit rustc JSON diagnostics that rust-analyzer can
+    ///    parse. If this runnable is not specified, we may try to use `cargo check -p`.
+    ///    This is only run for a single crate that the user saved a file in. The
+    ///    {label} syntax is replaced with `BuildInfo::label`.
+    ///    Alternatively, you may use `{saved_file}` and figure out which crate
+    ///    to produce diagnostics for based on that.
     ///
     /// The args for testOne can contain two template strings:
     /// `{label}` and `{test_id}`. `{label}` will be replaced
-    /// with the `Build::label` and `{test_id}` will be replaced
+    /// with the `BuildInfo::label` and `{test_id}` will be replaced
     /// with the test name.
-    kind: 'testOne' | string;
+    kind: 'testOne' | 'run' | 'flycheck' | string;
 }
 ```
 
 This format is provisional and subject to change. Specifically, the
 `roots` setup will be different eventually.
 
-There are three ways to feed `rust-project.json` to rust-analyzer:
+### Providing a JSON project to rust-analyzer
+
+There are four ways to feed `rust-project.json` to rust-analyzer:
+
+-   Use
+    [`"rust-analyzer.workspace.discoverConfig": … }`](./configuration.md#workspace.discoverConfig)
+    to specify a workspace discovery command to generate project descriptions
+    on-the-fly. Please note that the command output is message-oriented and must
+    follow [the discovery protocol](./configuration.md#workspace-discovery-protocol).
 
 -   Place `rust-project.json` file at the root of the project, and
     rust-analyzer will discover it.
@@ -240,19 +257,86 @@ location or (for inline JSON) relative to `rootUri`.
 You can set the `RA_LOG` environment variable to `rust_analyzer=info` to
 inspect how rust-analyzer handles config and project loading.
 
-Note that calls to `cargo check` are disabled when using
-`rust-project.json` by default, so compilation errors and warnings will
-no longer be sent to your LSP client. To enable these compilation errors
-you will need to specify explicitly what command rust-analyzer should
-run to perform the checks using the
-`rust-analyzer.check.overrideCommand` configuration. As an example, the
-following configuration explicitly sets `cargo check` as the `check`
-command.
-
-    { "rust-analyzer.check.overrideCommand": ["cargo", "check", "--message-format=json"] }
-
-`check.overrideCommand` requires the command specified to output json
-error messages for rust-analyzer to consume. The `--message-format=json`
-flag does this for `cargo check` so whichever command you use must also
-output errors in this format. See the [Configuration](#_configuration)
-section for more information.
+### Flycheck support
+
+Rust-analyzer has functionality to run an actual build of a crate when the user saves a file, to
+fill in diagnostics it does not implement natively. This is known as "flycheck".
+
+**Flycheck is disabled when using `rust-project.json` unless explicitly configured**, so compilation
+errors and warnings will no longer be sent to your LSP client by default. To enable these
+compilation errors you will need to specify explicitly what command rust-analyzer should run to
+perform the checks. There are two ways to do this:
+
+- `rust-project.json` may contain a `runnables` field. The `flycheck` runnable may be used to
+  configure a check command. See above for documentation.
+
+- Using the [`rust-analyzer.check.overrideCommand`](./configuration.md#check.overrideCommand)
+  configuration. This will also override anything in `rust-project.json`. As an example, the
+  following configuration explicitly sets `cargo check` as the `check` command.
+
+  ```json
+  { "rust-analyzer.check.overrideCommand": ["cargo", "check", "--message-format=json"] }
+  ```
+
+  Note also that this works with cargo projects.
+
+Either option requires the command specified to output JSON error messages for rust-analyzer to
+consume. The `--message-format=json` flag does this for `cargo check` so whichever command you use
+must also output errors in this format.
+
+Either option also supports two syntaxes within each argument:
+
+- `{label}` will be replaced with the `BuildInfo::label` of the crate
+  containing a saved file, if `BuildInfo` is provided. In the case of `check.overrideCommand` being
+  used in a Cargo project, this will be the cargo package ID, which can be used with `cargo check -p`.
+- `{saved_file}` will be replaced with an absolute path to the saved file. This can be queried against a
+  build system to find targets that include the file.
+
+For example:
+
+```json
+{ "rust-analyzer.check.overrideCommand": ["custom_crate_checker", "{label}"] }
+```
+
+If you do use `{label}` or `{saved_file}`, the command will not be run unless the relevant value can
+be substituted.
+
+
+#### Flycheck considerations
+
+##### Diagnostic output on error
+
+A flycheck command using a complex build orchestrator like `"bazel", "build", "{label}"`, even with
+a tweak to return JSON messages, is often insufficient. Such a command will typically succeed if
+there are warnings, but if there are errors, it might "fail to compile" the diagnostics and not
+produce any output. You must build a package in such a way that the build succeeds even if `rustc`
+exits with an error, and prints the JSON build messages in every case.
+
+##### Diagnostics for upstream crates
+
+`cargo check -p` re-prints any errors and warnings in crates higher up in the dependency graph
+than the one requested. We do clear all diagnostics when flychecking, so if you manage to
+replicate this behaviour, diagnostics for crates other than the one being checked will show up in
+the editor. If you do not, then users may be confused that diagnostics are "stuck" or disappear
+entirely when there is a build error in an upstream crate.
+
+##### Compiler options
+
+`cargo check` invokes rustc differently from `cargo build`. It turns off codegen (with `rustc
+--emit=metadata`), which results in lower latency to get to diagnostics. If your build system can
+configure this, it is recommended.
+
+If your build tool can configure rustc for incremental compiles, this is also recommended.
+
+##### Locking and pre-emption
+
+In any good build system, including Cargo, build commands sometimes block each other. Running a
+flycheck will (by default) frequently block you from running other build commands. Generally this is
+undesirable. Users will have to (unintuitively) press save again in the editor to cancel a
+flycheck, so that some other command may proceed.
+
+If your build system has the ability to isolate any rust-analyzer-driven flychecks and prevent lock
+contention, for example a separate build output directory and/or daemon instance, this is
+recommended. Alternatively, consider using a feature if available that can set the priority of
+various build invocations and automatically cancel lower-priority ones when needed. Flychecks should
+be set to a lower priority than general direct build invocations.
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 2157cbd486535..0d91378706a40 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -1213,7 +1213,7 @@
                 "title": "Check",
                 "properties": {
                     "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(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/workspaces, this command is invoked for\neach of them, with the working directory being the workspace root\n(i.e., the folder containing the `Cargo.toml`). This can be overwritten\nby changing `#rust-analyzer.check.invocationStrategy#`.\n\nIf `$saved_file` is part of the command, rust-analyzer will pass\nthe absolute path of the saved file to the provided command. This is\nintended to be used with non-Cargo build systems.\nNote that `$saved_file` is experimental and may be removed in the future.\n\nAn example command would be:\n\n```bash\ncargo check --workspace --message-format=json --all-targets\n```\n\nNote: The option must be specified as an array of command line arguments, with\nthe first argument being the name of the command to run.",
+                        "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/workspaces, this command is invoked for\neach of them, with the working directory being the workspace root\n(i.e., the folder containing the `Cargo.toml`). This can be overwritten\nby changing `#rust-analyzer.check.invocationStrategy#`.\n\nIt supports two interpolation syntaxes, both mainly intended to be used with\n[non-Cargo build systems](./non_cargo_based_projects.md):\n\n- If `{saved_file}` is part of the command, rust-analyzer will pass\n    the absolute path of the saved file to the provided command.\n    (A previous version, `$saved_file`, also works.)\n- If `{label}` is part of the command, rust-analyzer will pass the\n    Cargo package ID, which can be used with `cargo check -p`, or a build label from\n    `rust-project.json`. If `{label}` is included, rust-analyzer behaves much like\n    [`\"rust-analyzer.check.workspace\": false`](#check.workspace).\n\n\n\nAn example command would be:\n\n```bash\ncargo check --workspace --message-format=json --all-targets\n```\n\nNote: The option must be specified as an array of command line arguments, with\nthe first argument being the name of the command to run.",
                         "default": null,
                         "type": [
                             "null",
@@ -3135,7 +3135,7 @@
                 "title": "Workspace",
                 "properties": {
                     "rust-analyzer.workspace.discoverConfig": {
-                        "markdownDescription": "Enables automatic discovery of projects using [`DiscoverWorkspaceConfig::command`].\n\n[`DiscoverWorkspaceConfig`] also requires setting `progress_label` and `files_to_watch`.\n`progress_label` is used for the title in progress indicators, whereas `files_to_watch`\nis used to determine which build system-specific files should be watched in order to\nreload rust-analyzer.\n\nBelow is an example of a valid configuration:\n```json\n\"rust-analyzer.workspace.discoverConfig\": {\n        \"command\": [\n                \"rust-project\",\n                \"develop-json\"\n        ],\n        \"progressLabel\": \"rust-analyzer\",\n        \"filesToWatch\": [\n                \"BUCK\"\n        ]\n}\n```\n\n## On `DiscoverWorkspaceConfig::command`\n\n**Warning**: This format is provisional and subject to change.\n\n[`DiscoverWorkspaceConfig::command`] *must* return a JSON object corresponding to\n`DiscoverProjectData::Finished`:\n\n```norun\n#[derive(Debug, Clone, Deserialize, Serialize)]\n#[serde(tag = \"kind\")]\n#[serde(rename_all = \"snake_case\")]\nenum DiscoverProjectData {\n        Finished { buildfile: Utf8PathBuf, project: ProjectJsonData },\n        Error { error: String, source: Option<String> },\n        Progress { message: String },\n}\n```\n\nAs JSON, `DiscoverProjectData::Finished` is:\n\n```json\n{\n        // the internally-tagged representation of the enum.\n        \"kind\": \"finished\",\n        // the file used by a non-Cargo build system to define\n        // a package or target.\n        \"buildfile\": \"rust-analyzer/BUILD\",\n        // the contents of a rust-project.json, elided for brevity\n        \"project\": {\n                \"sysroot\": \"foo\",\n                \"crates\": []\n        }\n}\n```\n\nIt is encouraged, but not required, to use the other variants on `DiscoverProjectData`\nto provide a more polished end-user experience.\n\n`DiscoverWorkspaceConfig::command` may *optionally* include an `{arg}`, which will be\nsubstituted with the JSON-serialized form of the following enum:\n\n```norun\n#[derive(PartialEq, Clone, Debug, Serialize)]\n#[serde(rename_all = \"camelCase\")]\npub enum DiscoverArgument {\n     Path(AbsPathBuf),\n     Buildfile(AbsPathBuf),\n}\n```\n\nThe JSON representation of `DiscoverArgument::Path` is:\n\n```json\n{\n        \"path\": \"src/main.rs\"\n}\n```\n\nSimilarly, the JSON representation of `DiscoverArgument::Buildfile` is:\n\n```json\n{\n        \"buildfile\": \"BUILD\"\n}\n```\n\n`DiscoverArgument::Path` is used to find and generate a `rust-project.json`, and\ntherefore, a workspace, whereas `DiscoverArgument::buildfile` is used to to update an\nexisting workspace. As a reference for implementors, buck2's `rust-project` will likely\nbe useful: <https://github.com/facebook/buck2/tree/main/integrations/rust-project>.",
+                        "markdownDescription": "Enables automatic discovery of projects using [`DiscoverWorkspaceConfig::command`].\n\n[`DiscoverWorkspaceConfig`] also requires setting `progressLabel` and `filesToWatch`.\n`progressLabel` is used for the title in progress indicators, whereas `filesToWatch`\nis used to determine which build system-specific files should be watched in order to\nreload rust-analyzer.\n\nBelow is an example of a valid configuration:\n```json\n\"rust-analyzer.workspace.discoverConfig\": {\n        \"command\": [\n                \"rust-project\",\n                \"develop-json\",\n                \"{arg}\"\n        ],\n        \"progressLabel\": \"buck2/rust-project\",\n        \"filesToWatch\": [\n                \"BUCK\"\n        ]\n}\n```\n\n## Workspace Discovery Protocol\n\n**Warning**: This format is provisional and subject to change.\n\n[`DiscoverWorkspaceConfig::command`] *must* return a JSON object corresponding to\n`DiscoverProjectData::Finished`:\n\n```norun\n#[derive(Debug, Clone, Deserialize, Serialize)]\n#[serde(tag = \"kind\")]\n#[serde(rename_all = \"snake_case\")]\nenum DiscoverProjectData {\n        Finished { buildfile: Utf8PathBuf, project: ProjectJsonData },\n        Error { error: String, source: Option<String> },\n        Progress { message: String },\n}\n```\n\nAs JSON, `DiscoverProjectData::Finished` is:\n\n```json\n{\n        // the internally-tagged representation of the enum.\n        \"kind\": \"finished\",\n        // the file used by a non-Cargo build system to define\n        // a package or target.\n        \"buildfile\": \"rust-analyzer/BUILD\",\n        // the contents of a rust-project.json, elided for brevity\n        \"project\": {\n                \"sysroot\": \"foo\",\n                \"crates\": []\n        }\n}\n```\n\nIt is encouraged, but not required, to use the other variants on `DiscoverProjectData`\nto provide a more polished end-user experience.\n\n`DiscoverWorkspaceConfig::command` may *optionally* include an `{arg}`, which will be\nsubstituted with the JSON-serialized form of the following enum:\n\n```norun\n#[derive(PartialEq, Clone, Debug, Serialize)]\n#[serde(rename_all = \"camelCase\")]\npub enum DiscoverArgument {\n     Path(AbsPathBuf),\n     Buildfile(AbsPathBuf),\n}\n```\n\nThe JSON representation of `DiscoverArgument::Path` is:\n\n```json\n{\n        \"path\": \"src/main.rs\"\n}\n```\n\nSimilarly, the JSON representation of `DiscoverArgument::Buildfile` is:\n\n```json\n{\n        \"buildfile\": \"BUILD\"\n}\n```\n\n`DiscoverArgument::Path` is used to find and generate a `rust-project.json`, and\ntherefore, a workspace, whereas `DiscoverArgument::buildfile` is used to to update an\nexisting workspace. As a reference for implementors, buck2's `rust-project` will likely\nbe useful: <https://github.com/facebook/buck2/tree/main/integrations/rust-project>.",
                         "default": null,
                         "anyOf": [
                             {
diff --git a/src/tools/rust-analyzer/lib/line-index/src/lib.rs b/src/tools/rust-analyzer/lib/line-index/src/lib.rs
index 905da330e64b0..d5f0584d988f4 100644
--- a/src/tools/rust-analyzer/lib/line-index/src/lib.rs
+++ b/src/tools/rust-analyzer/lib/line-index/src/lib.rs
@@ -207,7 +207,7 @@ impl LineIndex {
     }
 }
 
-/// This is adapted from the rustc_span crate, https://github.com/rust-lang/rust/blob/de59844c98f7925242a798a72c59dc3610dd0e2c/compiler/rustc_span/src/analyze_source_file.rs
+/// This is adapted from the rustc_span crate, <https://github.com/rust-lang/rust/blob/de59844c98f7925242a798a72c59dc3610dd0e2c/compiler/rustc_span/src/analyze_source_file.rs>
 fn analyze_source_file(src: &str) -> (Vec<TextSize>, IntMap<u32, Box<[WideChar]>>) {
     assert!(src.len() < !0u32 as usize);
     let mut lines = vec![];
diff --git a/src/tools/rust-analyzer/lib/smol_str/Cargo.toml b/src/tools/rust-analyzer/lib/smol_str/Cargo.toml
index 118b25993ffe5..4e7844b49e195 100644
--- a/src/tools/rust-analyzer/lib/smol_str/Cargo.toml
+++ b/src/tools/rust-analyzer/lib/smol_str/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "smol_str"
-version = "0.3.4"
+version = "0.3.5"
 description = "small-string optimized string type with O(1) clone"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-lang/rust-analyzer/tree/master/lib/smol_str"
diff --git a/src/tools/rust-analyzer/rust-version b/src/tools/rust-analyzer/rust-version
index 5ffe95a0b54fa..b53a66c667517 100644
--- a/src/tools/rust-analyzer/rust-version
+++ b/src/tools/rust-analyzer/rust-version
@@ -1 +1 @@
-e7d44143a12a526488e4f0c0d7ea8e62a4fe9354
+44a5b55557c26353f388400d7da95527256fe260