diff --git a/crates/hir-def/src/attrs.rs b/crates/hir-def/src/attrs.rs
index ab36b707f269..607638f32b4e 100644
--- a/crates/hir-def/src/attrs.rs
+++ b/crates/hir-def/src/attrs.rs
@@ -45,8 +45,8 @@ use syntax::{
 use tt::{TextRange, TextSize};
 
 use crate::{
-    AdtId, AstIdLoc, AttrDefId, FieldId, FunctionId, GenericDefId, HasModule, InternedModuleId,
-    LifetimeParamId, LocalFieldId, MacroId, TypeOrConstParamId, VariantId,
+    AdtId, AstIdLoc, AttrDefId, FieldId, FunctionId, GenericDefId, HasModule, LifetimeParamId,
+    LocalFieldId, MacroId, ModuleId, TypeOrConstParamId, VariantId,
     db::DefDatabase,
     hir::generics::{GenericParams, LocalLifetimeParamId, LocalTypeOrConstParamId},
     nameres::ModuleOrigin,
@@ -295,9 +295,8 @@ fn attrs_source(
 ) -> (InFile<ast::AnyHasAttrs>, Option<InFile<ast::Module>>, Crate) {
     let (owner, krate) = match owner {
         AttrDefId::ModuleId(id) => {
-            let id = id.loc(db);
             let def_map = id.def_map(db);
-            let (definition, declaration) = match def_map[id.local_id].origin {
+            let (definition, declaration) = match def_map[id].origin {
                 ModuleOrigin::CrateRoot { definition } => {
                     let file = db.parse(definition).tree();
                     (InFile::new(definition.into(), ast::AnyHasAttrs::from(file)), None)
@@ -318,7 +317,7 @@ fn attrs_source(
                     (block.with_value(definition.into()), None)
                 }
             };
-            return (definition, declaration, id.krate);
+            return (definition, declaration, def_map.krate());
         }
         AttrDefId::AdtId(AdtId::StructId(it)) => attrs_from_ast_id_loc(db, it),
         AttrDefId::AdtId(AdtId::UnionId(it)) => attrs_from_ast_id_loc(db, it),
@@ -1201,14 +1200,14 @@ impl AttrFlags {
     }
 
     #[inline]
-    pub fn doc_keyword(db: &dyn DefDatabase, owner: InternedModuleId) -> Option<Symbol> {
+    pub fn doc_keyword(db: &dyn DefDatabase, owner: ModuleId) -> Option<Symbol> {
         if !AttrFlags::query(db, AttrDefId::ModuleId(owner)).contains(AttrFlags::HAS_DOC_KEYWORD) {
             return None;
         }
         return doc_keyword(db, owner);
 
         #[salsa::tracked]
-        fn doc_keyword(db: &dyn DefDatabase, owner: InternedModuleId) -> Option<Symbol> {
+        fn doc_keyword(db: &dyn DefDatabase, owner: ModuleId) -> Option<Symbol> {
             collect_attrs(db, AttrDefId::ModuleId(owner), |attr| {
                 if let Meta::TokenTree { path, tt } = attr
                     && path.is1("doc")
diff --git a/crates/hir-def/src/db.rs b/crates/hir-def/src/db.rs
index cc311a41dbf8..98df8d0ff445 100644
--- a/crates/hir-def/src/db.rs
+++ b/crates/hir-def/src/db.rs
@@ -8,13 +8,12 @@ use la_arena::ArenaMap;
 use triomphe::Arc;
 
 use crate::{
-    AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc, CrateRootModuleId, DefWithBodyId,
-    EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId,
-    ExternCrateLoc, FunctionId, FunctionLoc, GenericDefId, HasModule, ImplId, ImplLoc,
-    InternedModuleId, LocalFieldId, Macro2Id, Macro2Loc, MacroExpander, MacroId, MacroRulesId,
-    MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId, StaticLoc, StructId,
-    StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc,
-    VariantId,
+    AssocItemId, AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, EnumVariantId,
+    EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc, FunctionId,
+    FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc, MacroExpander,
+    MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId,
+    StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId,
+    UnionLoc, UseId, UseLoc, VariantId,
     attrs::AttrFlags,
     expr_store::{
         Body, BodySourceMap, ExpressionStore, ExpressionStoreSourceMap, scope::ExprScopes,
@@ -83,9 +82,6 @@ pub trait InternDatabase: RootQueryDb {
     #[salsa::interned]
     fn intern_macro_rules(&self, loc: MacroRulesLoc) -> MacroRulesId;
     // endregion: items
-
-    #[salsa::interned]
-    fn intern_block(&self, loc: BlockLoc) -> BlockId;
 }
 
 #[query_group::query_group]
@@ -276,8 +272,8 @@ fn include_macro_invoc(
 }
 
 fn crate_supports_no_std(db: &dyn DefDatabase, crate_id: Crate) -> bool {
-    let root_module = CrateRootModuleId::from(crate_id).module(db);
-    let attrs = AttrFlags::query(db, AttrDefId::ModuleId(InternedModuleId::new(db, root_module)));
+    let root_module = crate_def_map(db, crate_id).root_module_id();
+    let attrs = AttrFlags::query(db, AttrDefId::ModuleId(root_module));
     attrs.contains(AttrFlags::IS_NO_STD)
 }
 
@@ -298,7 +294,7 @@ fn macro_def(db: &dyn DefDatabase, id: MacroId) -> MacroDefId {
             let loc: Macro2Loc = it.lookup(db);
 
             MacroDefId {
-                krate: loc.container.krate,
+                krate: loc.container.krate(db),
                 kind: kind(loc.expander, loc.id.file_id, loc.id.value.upcast()),
                 local_inner: false,
                 allow_internal_unsafe: loc.allow_internal_unsafe,
@@ -309,7 +305,7 @@ fn macro_def(db: &dyn DefDatabase, id: MacroId) -> MacroDefId {
             let loc: MacroRulesLoc = it.lookup(db);
 
             MacroDefId {
-                krate: loc.container.krate,
+                krate: loc.container.krate(db),
                 kind: kind(loc.expander, loc.id.file_id, loc.id.value.upcast()),
                 local_inner: loc.flags.contains(MacroRulesLocFlags::LOCAL_INNER),
                 allow_internal_unsafe: loc
@@ -322,7 +318,7 @@ fn macro_def(db: &dyn DefDatabase, id: MacroId) -> MacroDefId {
             let loc = it.lookup(db);
 
             MacroDefId {
-                krate: loc.container.krate,
+                krate: loc.container.krate(db),
                 kind: MacroDefKind::ProcMacro(loc.id, loc.expander, loc.kind),
                 local_inner: false,
                 allow_internal_unsafe: false,
diff --git a/crates/hir-def/src/expr_store/lower.rs b/crates/hir-def/src/expr_store/lower.rs
index 26a50b53251f..f374dd2cc9ef 100644
--- a/crates/hir-def/src/expr_store/lower.rs
+++ b/crates/hir-def/src/expr_store/lower.rs
@@ -31,7 +31,7 @@ use triomphe::Arc;
 use tt::TextRange;
 
 use crate::{
-    AdtId, BlockId, BlockLoc, DefWithBodyId, FunctionId, GenericDefId, ImplId, MacroId,
+    AdtId, BlockId, BlockIdLt, DefWithBodyId, FunctionId, GenericDefId, ImplId, MacroId,
     ModuleDefId, ModuleId, TraitId, TypeAliasId, UnresolvedMacro,
     attrs::AttrFlags,
     builtin_type::BuiltinUint,
@@ -437,6 +437,7 @@ pub struct ExprCollector<'db> {
     current_binding_owner: Option<ExprId>,
 
     awaitable_context: Option<Awaitable>,
+    krate: base_db::Crate,
 }
 
 #[derive(Clone, Debug)]
@@ -524,9 +525,10 @@ impl<'db> ExprCollector<'db> {
     ) -> ExprCollector<'_> {
         let (def_map, local_def_map) = module.local_def_map(db);
         let expander = Expander::new(db, current_file_id, def_map);
+        let krate = module.krate(db);
         ExprCollector {
             db,
-            cfg_options: module.krate().cfg_options(db),
+            cfg_options: krate.cfg_options(db),
             module,
             def_map,
             local_def_map,
@@ -540,12 +542,13 @@ impl<'db> ExprCollector<'db> {
             awaitable_context: None,
             current_block_legacy_macro_defs_count: FxHashMap::default(),
             outer_impl_trait: false,
+            krate,
         }
     }
 
     #[inline]
     pub(crate) fn lang_items(&self) -> &'db LangItems {
-        self.lang_items.get_or_init(|| crate::lang_item::lang_items(self.db, self.module.krate))
+        self.lang_items.get_or_init(|| crate::lang_item::lang_items(self.db, self.def_map.krate()))
     }
 
     #[inline]
@@ -1915,9 +1918,8 @@ impl<'db> ExprCollector<'db> {
         T: ast::AstNode,
     {
         let macro_call_ptr = self.expander.in_file(syntax_ptr);
-        let module = self.module.local_id;
 
-        let block_call = self.def_map.modules[self.module.local_id].scope.macro_invoc(
+        let block_call = self.def_map.modules[self.module].scope.macro_invoc(
             self.expander.in_file(self.expander.ast_id_map().ast_id_for_ptr(syntax_ptr)),
         );
         let res = match block_call {
@@ -1929,7 +1931,7 @@ impl<'db> ExprCollector<'db> {
                         .resolve_path(
                             self.local_def_map,
                             self.db,
-                            module,
+                            self.module,
                             path,
                             crate::item_scope::BuiltinShadowMode::Other,
                             Some(MacroSubNs::Bang),
@@ -1940,7 +1942,7 @@ impl<'db> ExprCollector<'db> {
                 self.expander.enter_expand(
                     self.db,
                     mcall,
-                    self.module.krate(),
+                    self.krate,
                     resolver,
                     &mut |ptr, call| {
                         _ = self.store.expansions.insert(ptr.map(|(it, _)| it), call);
@@ -2058,7 +2060,8 @@ impl<'db> ExprCollector<'db> {
                     return;
                 };
                 let name = name.as_name();
-                let macro_id = self.def_map.modules[DefMap::ROOT].scope.get(&name).take_macros();
+                let macro_id =
+                    self.def_map.modules[self.def_map.root].scope.get(&name).take_macros();
                 self.collect_macro_def(statements, macro_id);
             }
             ast::Stmt::Item(ast::Item::MacroRules(macro_)) => {
@@ -2072,7 +2075,7 @@ impl<'db> ExprCollector<'db> {
                 let name = name.as_name();
                 let macro_defs_count =
                     self.current_block_legacy_macro_defs_count.entry(name.clone()).or_insert(0);
-                let macro_id = self.def_map.modules[DefMap::ROOT]
+                let macro_id = self.def_map.modules[self.def_map.root]
                     .scope
                     .get_legacy_macro(&name)
                     .and_then(|it| it.get(*macro_defs_count))
@@ -2111,14 +2114,14 @@ impl<'db> ExprCollector<'db> {
     ) -> ExprId {
         let block_id = self.expander.ast_id_map().ast_id_for_block(&block).map(|file_local_id| {
             let ast_id = self.expander.in_file(file_local_id);
-            self.db.intern_block(BlockLoc { ast_id, module: self.module })
+            unsafe { BlockIdLt::new(self.db, ast_id, self.module).to_static() }
         });
 
         let (module, def_map) =
             match block_id.map(|block_id| (block_def_map(self.db, block_id), block_id)) {
                 Some((def_map, block_id)) => {
                     self.store.block_scopes.push(block_id);
-                    (def_map.module_id(DefMap::ROOT), def_map)
+                    (def_map.root_module_id(), def_map)
                 }
                 None => (self.module, self.def_map),
             };
@@ -2201,7 +2204,7 @@ impl<'db> ExprCollector<'db> {
                     let (resolved, _) = self.def_map.resolve_path(
                         self.local_def_map,
                         self.db,
-                        self.module.local_id,
+                        self.module,
                         &name.clone().into(),
                         BuiltinShadowMode::Other,
                         None,
@@ -3131,7 +3134,7 @@ impl<'db> ExprCollector<'db> {
         let precision_expr = self.make_count(precision, argmap);
         let width_expr = self.make_count(width, argmap);
 
-        if self.module.krate().workspace_data(self.db).is_atleast_187() {
+        if self.krate.workspace_data(self.db).is_atleast_187() {
             // These need to match the constants in library/core/src/fmt/rt.rs.
             let align = match alignment {
                 Some(FormatAlignment::Left) => 0,
diff --git a/crates/hir-def/src/expr_store/tests/body.rs b/crates/hir-def/src/expr_store/tests/body.rs
index 4a775568bc22..22ade4387582 100644
--- a/crates/hir-def/src/expr_store/tests/body.rs
+++ b/crates/hir-def/src/expr_store/tests/body.rs
@@ -32,14 +32,14 @@ fn def_map_at(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> String {
     let (db, position) = TestDB::with_position(ra_fixture);
 
     let module = db.module_at_position(position);
-    module.def_map(&db).dump(&db)
+    salsa::plumbing::attach(&db, || module.def_map(&db).dump(&db))
 }
 
 fn check_block_scopes_at(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
     let (db, position) = TestDB::with_position(ra_fixture);
 
     let module = db.module_at_position(position);
-    let actual = module.def_map(&db).dump_block_scopes(&db);
+    let actual = salsa::plumbing::attach(&db, || format!("{module:#?}"));
     expect.assert_eq(&actual);
 }
 
diff --git a/crates/hir-def/src/expr_store/tests/body/block.rs b/crates/hir-def/src/expr_store/tests/body/block.rs
index 4501ff4df5e7..2d60f44092c5 100644
--- a/crates/hir-def/src/expr_store/tests/body/block.rs
+++ b/crates/hir-def/src/expr_store/tests/body/block.rs
@@ -189,10 +189,63 @@ fn f() {
 }
     "#,
         expect![[r#"
-            BlockId(3801) in BlockRelativeModuleId { block: Some(BlockId(3800)), local_id: Idx::<ModuleData>(1) }
-            BlockId(3800) in BlockRelativeModuleId { block: None, local_id: Idx::<ModuleData>(0) }
-            crate scope
-        "#]],
+            ModuleIdLt {
+                [salsa id]: Id(3003),
+                krate: Crate(
+                    Id(1c00),
+                ),
+                block: Some(
+                    BlockIdLt {
+                        [salsa id]: Id(3c01),
+                        ast_id: InFileWrapper {
+                            file_id: FileId(
+                                EditionedFileIdData {
+                                    editioned_file_id: EditionedFileId(
+                                        0,
+                                        Edition2024,
+                                    ),
+                                    krate: Crate(
+                                        Id(1c00),
+                                    ),
+                                },
+                            ),
+                            value: FileAstId::<syntax::ast::generated::nodes::BlockExpr>(ErasedFileAstId { kind: BlockExpr, index: 0, hash: F9BF }),
+                        },
+                        module: ModuleIdLt {
+                            [salsa id]: Id(3002),
+                            krate: Crate(
+                                Id(1c00),
+                            ),
+                            block: Some(
+                                BlockIdLt {
+                                    [salsa id]: Id(3c00),
+                                    ast_id: InFileWrapper {
+                                        file_id: FileId(
+                                            EditionedFileIdData {
+                                                editioned_file_id: EditionedFileId(
+                                                    0,
+                                                    Edition2024,
+                                                ),
+                                                krate: Crate(
+                                                    Id(1c00),
+                                                ),
+                                            },
+                                        ),
+                                        value: FileAstId::<syntax::ast::generated::nodes::BlockExpr>(ErasedFileAstId { kind: BlockExpr, index: 0, hash: C181 }),
+                                    },
+                                    module: ModuleIdLt {
+                                        [salsa id]: Id(3000),
+                                        krate: Crate(
+                                            Id(1c00),
+                                        ),
+                                        block: None,
+                                    },
+                                },
+                            ),
+                        },
+                    },
+                ),
+            }"#]],
     );
 }
 
@@ -460,7 +513,7 @@ fn foo() {
 }
 
 #[test]
-fn is_visible_from_same_def_map() {
+fn is_visible_from_same_def_map_regression_9481() {
     // Regression test for https://github.com/rust-lang/rust-analyzer/issues/9481
     check_at(
         r#"
@@ -478,7 +531,6 @@ fn outer() {
             - tests : type
 
             (block scope)::tests
-            - name : _
             - outer : value (glob)
 
             crate
diff --git a/crates/hir-def/src/find_path.rs b/crates/hir-def/src/find_path.rs
index e8a6ebcffa0a..cc0594f00d61 100644
--- a/crates/hir-def/src/find_path.rs
+++ b/crates/hir-def/src/find_path.rs
@@ -12,7 +12,7 @@ use intern::sym;
 use rustc_hash::FxHashSet;
 
 use crate::{
-    FindPathConfig, ModuleDefId, ModuleId,
+    FindPathConfig, ModuleDefId, ModuleIdLt,
     db::DefDatabase,
     item_scope::ItemInNs,
     nameres::DefMap,
@@ -24,7 +24,7 @@ use crate::{
 pub fn find_path(
     db: &dyn DefDatabase,
     item: ItemInNs,
-    from: ModuleId,
+    from: ModuleIdLt<'_>,
     mut prefix_kind: PrefixKind,
     ignore_local_imports: bool,
     mut cfg: FindPathConfig,
@@ -39,20 +39,23 @@ pub fn find_path(
     // within block modules, forcing a `self` or `crate` prefix will not allow using inner items, so
     // default to plain paths.
     let item_module = item.module(db)?;
-    if item_module.is_within_block() {
+    if item_module.block(db).is_some() {
         prefix_kind = PrefixKind::Plain;
     }
-    cfg.prefer_no_std = cfg.prefer_no_std || db.crate_supports_no_std(from.krate());
+    cfg.prefer_no_std = cfg.prefer_no_std || db.crate_supports_no_std(from.krate(db));
 
+    let from_def_map = from.def_map(db);
     find_path_inner(
         &FindPathCtx {
             db,
             prefix: prefix_kind,
             cfg,
             ignore_local_imports,
-            is_std_item: item_module.krate().data(db).origin.is_lang(),
+            is_std_item: item_module.krate(db).data(db).origin.is_lang(),
             from,
-            from_def_map: from.def_map(db),
+            from_crate: from.krate(db),
+            crate_root: from_def_map.crate_root(db),
+            from_def_map,
             fuel: Cell::new(FIND_PATH_FUEL),
         },
         item,
@@ -99,12 +102,14 @@ struct FindPathCtx<'db> {
     cfg: FindPathConfig,
     ignore_local_imports: bool,
     is_std_item: bool,
-    from: ModuleId,
+    from: ModuleIdLt<'db>,
+    from_crate: Crate,
+    crate_root: ModuleIdLt<'db>,
     from_def_map: &'db DefMap,
     fuel: Cell<usize>,
 }
 
-/// Attempts to find a path to refer to the given `item` visible from the `from` ModuleId
+/// Attempts to find a path to refer to the given `item` visible from the `from` ModuleIdLt<'_>
 fn find_path_inner(ctx: &FindPathCtx<'_>, item: ItemInNs, max_len: usize) -> Option<ModPath> {
     // - if the item is a module, jump straight to module search
     if !ctx.is_std_item
@@ -116,7 +121,7 @@ fn find_path_inner(ctx: &FindPathCtx<'_>, item: ItemInNs, max_len: usize) -> Opt
 
     let may_be_in_scope = match ctx.prefix {
         PrefixKind::Plain | PrefixKind::BySelf => true,
-        PrefixKind::ByCrate => ctx.from.is_crate_root(),
+        PrefixKind::ByCrate => ctx.crate_root == ctx.from,
     };
     if may_be_in_scope {
         // - if the item is already in scope, return the name under which it is
@@ -152,10 +157,10 @@ fn find_path_inner(ctx: &FindPathCtx<'_>, item: ItemInNs, max_len: usize) -> Opt
 }
 
 #[tracing::instrument(skip_all)]
-fn find_path_for_module(
-    ctx: &FindPathCtx<'_>,
-    visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,
-    module_id: ModuleId,
+fn find_path_for_module<'db>(
+    ctx: &'db FindPathCtx<'db>,
+    visited_modules: &mut FxHashSet<(ItemInNs, ModuleIdLt<'db>)>,
+    module_id: ModuleIdLt<'db>,
     maybe_extern: bool,
     max_len: usize,
 ) -> Option<Choice> {
@@ -163,8 +168,9 @@ fn find_path_for_module(
         // recursive base case, we can't find a path of length 0
         return None;
     }
-    if let Some(crate_root) = module_id.as_crate_root() {
-        if !maybe_extern || crate_root == ctx.from.derive_crate_root() {
+    let module_crate_root = module_id.def_map(ctx.db).crate_root(ctx.db);
+    if module_crate_root == module_id {
+        if !maybe_extern || module_crate_root == ctx.crate_root {
             // - if the item is the crate root, return `crate`
             return Some(Choice {
                 path: ModPath::from_segments(PathKind::Crate, None),
@@ -175,19 +181,19 @@ fn find_path_for_module(
         }
         // - otherwise if the item is the crate root of a dependency crate, return the name from the extern prelude
 
-        let root_local_def_map = ctx.from.derive_crate_root().local_def_map(ctx.db).1;
+        let root_local_def_map = ctx.crate_root.local_def_map(ctx.db).1;
         // rev here so we prefer looking at renamed extern decls first
         for (name, (def_id, _extern_crate)) in root_local_def_map.extern_prelude().rev() {
-            if crate_root != def_id {
+            if module_crate_root != def_id {
                 continue;
             }
             let name_already_occupied_in_type_ns = ctx
                 .from_def_map
-                .with_ancestor_maps(ctx.db, ctx.from.local_id, &mut |def_map, local_id| {
+                .with_ancestor_maps(ctx.db, ctx.from, &mut |def_map, local_id| {
                     def_map[local_id]
                         .scope
                         .type_(name)
-                        .filter(|&(id, _)| id != ModuleDefId::ModuleId(def_id.into()))
+                        .filter(|&(id, _)| id != ModuleDefId::ModuleId(def_id))
                 })
                 .is_some();
             let kind = if name_already_occupied_in_type_ns {
@@ -204,14 +210,14 @@ fn find_path_for_module(
 
     let may_be_in_scope = match ctx.prefix {
         PrefixKind::Plain | PrefixKind::BySelf => true,
-        PrefixKind::ByCrate => ctx.from.is_crate_root(),
+        PrefixKind::ByCrate => ctx.crate_root == ctx.from,
     };
     if may_be_in_scope {
         let scope_name = find_in_scope(
             ctx.db,
             ctx.from_def_map,
             ctx.from,
-            ItemInNs::Types(module_id.into()),
+            ItemInNs::Types(unsafe { module_id.to_static() }.into()),
             ctx.ignore_local_imports,
         );
         if let Some(scope_name) = scope_name {
@@ -226,7 +232,7 @@ fn find_path_for_module(
     }
 
     // - if the module can be referenced as self, super or crate, do that
-    if let Some(kind) = is_kw_kind_relative_to_from(ctx.from_def_map, module_id, ctx.from)
+    if let Some(kind) = is_kw_kind_relative_to_from(ctx.db, ctx.from_def_map, module_id, ctx.from)
         && (ctx.prefix != PrefixKind::ByCrate || kind == PathKind::Crate)
     {
         return Some(Choice {
@@ -238,7 +244,7 @@ fn find_path_for_module(
     }
 
     // - if the module is in the prelude, return it by that path
-    let item = ItemInNs::Types(module_id.into());
+    let item = ItemInNs::Types(unsafe { module_id.to_static() }.into());
     if let Some(choice) = find_in_prelude(ctx.db, ctx.from_def_map, item, ctx.from) {
         return Some(choice);
     }
@@ -251,15 +257,15 @@ fn find_path_for_module(
     best_choice
 }
 
-fn find_in_scope(
-    db: &dyn DefDatabase,
+fn find_in_scope<'db>(
+    db: &'db dyn DefDatabase,
     def_map: &DefMap,
-    from: ModuleId,
+    from: ModuleIdLt<'db>,
     item: ItemInNs,
     ignore_local_imports: bool,
 ) -> Option<Name> {
     // FIXME: We could have multiple applicable names here, but we currently only return the first
-    def_map.with_ancestor_maps(db, from.local_id, &mut |def_map, local_id| {
+    def_map.with_ancestor_maps(db, from, &mut |def_map, local_id| {
         def_map[local_id].scope.names_of(item, |name, _, declared| {
             (declared || !ignore_local_imports).then(|| name.clone())
         })
@@ -272,11 +278,11 @@ fn find_in_prelude(
     db: &dyn DefDatabase,
     local_def_map: &DefMap,
     item: ItemInNs,
-    from: ModuleId,
+    from: ModuleIdLt<'_>,
 ) -> Option<Choice> {
     let (prelude_module, _) = local_def_map.prelude()?;
     let prelude_def_map = prelude_module.def_map(db);
-    let prelude_scope = &prelude_def_map[prelude_module.local_id].scope;
+    let prelude_scope = &prelude_def_map[prelude_module].scope;
     let (name, vis, _declared) = prelude_scope.name_of(item)?;
     if !vis.is_visible_from(db, from) {
         return None;
@@ -284,7 +290,7 @@ fn find_in_prelude(
 
     // Check if the name is in current scope and it points to the same def.
     let found_and_same_def =
-        local_def_map.with_ancestor_maps(db, from.local_id, &mut |def_map, local_id| {
+        local_def_map.with_ancestor_maps(db, from, &mut |def_map, local_id| {
             let per_ns = def_map[local_id].scope.get(name);
             let same_def = match item {
                 ItemInNs::Types(it) => per_ns.take_types()? == it,
@@ -302,22 +308,21 @@ fn find_in_prelude(
 }
 
 fn is_kw_kind_relative_to_from(
+    db: &dyn DefDatabase,
     def_map: &DefMap,
-    item: ModuleId,
-    from: ModuleId,
+    item: ModuleIdLt<'_>,
+    from: ModuleIdLt<'_>,
 ) -> Option<PathKind> {
-    if item.krate != from.krate || item.is_within_block() || from.is_within_block() {
+    if item.krate(db) != from.krate(db) || item.block(db).is_some() || from.block(db).is_some() {
         return None;
     }
-    let item = item.local_id;
-    let from = from.local_id;
     if item == from {
         // - if the item is the module we're in, use `self`
         Some(PathKind::SELF)
     } else if let Some(parent_id) = def_map[from].parent {
         if item == parent_id {
             // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
-            Some(if parent_id == DefMap::ROOT { PathKind::Crate } else { PathKind::Super(1) })
+            Some(if parent_id == def_map.root { PathKind::Crate } else { PathKind::Super(1) })
         } else {
             None
         }
@@ -327,9 +332,9 @@ fn is_kw_kind_relative_to_from(
 }
 
 #[tracing::instrument(skip_all)]
-fn calculate_best_path(
-    ctx: &FindPathCtx<'_>,
-    visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,
+fn calculate_best_path<'db>(
+    ctx: &'db FindPathCtx<'db>,
+    visited_modules: &mut FxHashSet<(ItemInNs, ModuleIdLt<'db>)>,
     item: ItemInNs,
     max_len: usize,
     best_choice: &mut Option<Choice>,
@@ -340,13 +345,13 @@ fn calculate_best_path(
         tracing::warn!(
             "ran out of fuel while searching for a path for item {item:?} of krate {:?} from krate {:?}",
             item.krate(ctx.db),
-            ctx.from.krate()
+            ctx.from_crate
         );
         return;
     }
     ctx.fuel.set(fuel - 1);
 
-    if item.krate(ctx.db) == Some(ctx.from.krate) {
+    if item.krate(ctx.db) == Some(ctx.from_crate) {
         // Item was defined in the same crate that wants to import it. It cannot be found in any
         // dependency in this case.
         calculate_best_path_local(ctx, visited_modules, item, max_len, best_choice)
@@ -361,20 +366,20 @@ fn calculate_best_path(
         // too (unless we can't name it at all). It could *also* be (re)exported by the same crate
         // that wants to import it here, but we always prefer to use the external path here.
 
-        ctx.from.krate.data(ctx.db).dependencies.iter().for_each(|dep| {
+        ctx.from_crate.data(ctx.db).dependencies.iter().for_each(|dep| {
             find_in_dep(ctx, visited_modules, item, max_len, best_choice, dep.crate_id)
         });
     }
 }
 
-fn find_in_sysroot(
-    ctx: &FindPathCtx<'_>,
-    visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,
+fn find_in_sysroot<'db>(
+    ctx: &'db FindPathCtx<'db>,
+    visited_modules: &mut FxHashSet<(ItemInNs, ModuleIdLt<'db>)>,
     item: ItemInNs,
     max_len: usize,
     best_choice: &mut Option<Choice>,
 ) {
-    let dependencies = &ctx.from.krate.data(ctx.db).dependencies;
+    let dependencies = &ctx.from_crate.data(ctx.db).dependencies;
     let mut search = |lang, best_choice: &mut _| {
         if let Some(dep) = dependencies.iter().filter(|it| it.is_sysroot()).find(|dep| {
             match dep.crate_id.data(ctx.db).origin {
@@ -413,9 +418,9 @@ fn find_in_sysroot(
         });
 }
 
-fn find_in_dep(
-    ctx: &FindPathCtx<'_>,
-    visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,
+fn find_in_dep<'db>(
+    ctx: &'db FindPathCtx<'db>,
+    visited_modules: &mut FxHashSet<(ItemInNs, ModuleIdLt<'db>)>,
     item: ItemInNs,
     max_len: usize,
     best_choice: &mut Option<Choice>,
@@ -456,34 +461,27 @@ fn find_in_dep(
     }
 }
 
-fn calculate_best_path_local(
-    ctx: &FindPathCtx<'_>,
-    visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,
+fn calculate_best_path_local<'db>(
+    ctx: &'db FindPathCtx<'db>,
+    visited_modules: &mut FxHashSet<(ItemInNs, ModuleIdLt<'db>)>,
     item: ItemInNs,
     max_len: usize,
     best_choice: &mut Option<Choice>,
 ) {
     // FIXME: cache the `find_local_import_locations` output?
-    find_local_import_locations(
-        ctx.db,
-        item,
-        ctx.from,
-        ctx.from_def_map,
-        visited_modules,
-        |visited_modules, name, module_id| {
-            // we are looking for paths of length up to best_path_len, any longer will make it be
-            // less optimal. The -1 is due to us pushing name onto it afterwards.
-            if let Some(choice) = find_path_for_module(
-                ctx,
-                visited_modules,
-                module_id,
-                false,
-                best_choice.as_ref().map_or(max_len, |it| it.path.len()) - 1,
-            ) {
-                Choice::try_select(best_choice, choice, ctx.cfg.prefer_prelude, name.clone());
-            }
-        },
-    );
+    find_local_import_locations(ctx, item, visited_modules, |visited_modules, name, module_id| {
+        // we are looking for paths of length up to best_path_len, any longer will make it be
+        // less optimal. The -1 is due to us pushing name onto it afterwards.
+        if let Some(choice) = find_path_for_module(
+            ctx,
+            visited_modules,
+            module_id,
+            false,
+            best_choice.as_ref().map_or(max_len, |it| it.path.len()) - 1,
+        ) {
+            Choice::try_select(best_choice, choice, ctx.cfg.prefer_prelude, name.clone());
+        }
+    });
 }
 
 #[derive(Debug)]
@@ -560,15 +558,14 @@ fn path_kind_len(kind: PathKind) -> usize {
 }
 
 /// Finds locations in `from.krate` from which `item` can be imported by `from`.
-fn find_local_import_locations(
-    db: &dyn DefDatabase,
+fn find_local_import_locations<'db>(
+    ctx: &'db FindPathCtx<'db>,
     item: ItemInNs,
-    from: ModuleId,
-    def_map: &DefMap,
-    visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,
-    mut cb: impl FnMut(&mut FxHashSet<(ItemInNs, ModuleId)>, &Name, ModuleId),
+    visited_modules: &mut FxHashSet<(ItemInNs, ModuleIdLt<'db>)>,
+    mut cb: impl FnMut(&mut FxHashSet<(ItemInNs, ModuleIdLt<'db>)>, &Name, ModuleIdLt<'db>),
 ) {
     let _p = tracing::info_span!("find_local_import_locations").entered();
+    let db = ctx.db;
 
     // `from` can import anything below `from` with visibility of at least `from`, and anything
     // above `from` with any visibility. That means we do not need to descend into private siblings
@@ -576,15 +573,16 @@ fn find_local_import_locations(
 
     // Compute the initial worklist. We start with all direct child modules of `from` as well as all
     // of its (recursive) parent modules.
-    let mut worklist = def_map[from.local_id]
+    let mut worklist = ctx.from_def_map[ctx.from]
         .children
         .values()
-        .map(|&child| def_map.module_id(child))
-        .chain(iter::successors(from.containing_module(db), |m| m.containing_module(db)))
+        .copied()
+        .chain(iter::successors(ctx.from.containing_module(db), |m| m.containing_module(db)))
         .zip(iter::repeat(false))
         .collect::<Vec<_>>();
 
-    let def_map = def_map.crate_root().def_map(db);
+    let def_map =
+        if ctx.crate_root == ctx.from { ctx.from_def_map } else { ctx.crate_root.def_map(db) };
     let mut block_def_map;
     let mut cursor = 0;
 
@@ -595,17 +593,17 @@ fn find_local_import_locations(
             continue;
         }
         *processed = true;
-        let data = if module.block.is_some() {
+        let data = if module.block(db).is_some() {
             // Re-query the block's DefMap
             block_def_map = module.def_map(db);
-            &block_def_map[module.local_id]
+            &block_def_map[module]
         } else {
             // Reuse the root DefMap
-            &def_map[module.local_id]
+            &def_map[module]
         };
 
         if let Some((name, vis, declared)) = data.scope.name_of(item)
-            && vis.is_visible_from(db, from)
+            && vis.is_visible_from(db, ctx.from)
         {
             let is_pub_or_explicit = match vis {
                 Visibility::Module(_, VisibilityExplicitness::Explicit) => {
@@ -632,7 +630,7 @@ fn find_local_import_locations(
 
         // Descend into all modules visible from `from`.
         for (module, vis) in data.scope.modules_in_scope() {
-            if module.krate != from.krate {
+            if module.krate(db) != ctx.from.krate(db) {
                 // We don't need to look at modules from other crates as our item has to be in the
                 // current crate
                 continue;
@@ -641,7 +639,7 @@ fn find_local_import_locations(
                 continue;
             }
 
-            if vis.is_visible_from(db, from) {
+            if vis.is_visible_from(db, ctx.from) {
                 worklist.push((module, false));
             }
         }
@@ -694,7 +692,7 @@ mod tests {
             .resolve_path(
                 local_def_map,
                 &db,
-                module.local_id,
+                module,
                 &mod_path,
                 crate::item_scope::BuiltinShadowMode::Module,
                 None,
diff --git a/crates/hir-def/src/import_map.rs b/crates/hir-def/src/import_map.rs
index 67cf466276c5..433aead77adb 100644
--- a/crates/hir-def/src/import_map.rs
+++ b/crates/hir-def/src/import_map.rs
@@ -13,11 +13,11 @@ use stdx::format_to;
 use triomphe::Arc;
 
 use crate::{
-    AssocItemId, AttrDefId, Complete, FxIndexMap, InternedModuleId, ModuleDefId, ModuleId, TraitId,
+    AssocItemId, AttrDefId, Complete, FxIndexMap, ModuleDefId, ModuleId, TraitId,
     attrs::AttrFlags,
     db::DefDatabase,
     item_scope::{ImportOrExternCrate, ItemInNs},
-    nameres::{DefMap, assoc::TraitItems, crate_def_map},
+    nameres::{assoc::TraitItems, crate_def_map},
     visibility::Visibility,
 };
 
@@ -134,7 +134,7 @@ impl ImportMap {
         let mut map = FxIndexMap::default();
 
         // We look only into modules that are public(ly reexported), starting with the crate root.
-        let root = def_map.module_id(DefMap::ROOT);
+        let root = def_map.root_module_id();
         let mut worklist = vec![root];
         let mut visited = FxHashSet::default();
 
@@ -142,13 +142,11 @@ impl ImportMap {
             if !visited.insert(module) {
                 continue;
             }
-            let ext_def_map;
-            let mod_data = if module.krate == krate {
-                &def_map[module.local_id]
+            let mod_data = if module.krate(db) == krate {
+                &def_map[module]
             } else {
                 // The crate might reexport a module defined in another crate.
-                ext_def_map = module.def_map(db);
-                &ext_def_map[module.local_id]
+                &module.def_map(db)[module]
             };
 
             let visible_items = mod_data.scope.entries().filter_map(|(name, per_ns)| {
@@ -167,9 +165,7 @@ impl ImportMap {
                     } else {
                         match item {
                             ItemInNs::Types(id) | ItemInNs::Values(id) => match id {
-                                ModuleDefId::ModuleId(it) => {
-                                    Some(AttrDefId::ModuleId(InternedModuleId::new(db, it)))
-                                }
+                                ModuleDefId::ModuleId(it) => Some(AttrDefId::ModuleId(it)),
                                 ModuleDefId::FunctionId(it) => Some(it.into()),
                                 ModuleDefId::AdtId(it) => Some(it.into()),
                                 ModuleDefId::EnumVariantId(it) => Some(it.into()),
@@ -500,7 +496,7 @@ mod tests {
     use expect_test::{Expect, expect};
     use test_fixture::WithFixture;
 
-    use crate::{ItemContainerId, Lookup, nameres::assoc::TraitItems, test_db::TestDB};
+    use crate::{ItemContainerId, Lookup, ModuleIdLt, nameres::assoc::TraitItems, test_db::TestDB};
 
     use super::*;
 
@@ -632,17 +628,16 @@ mod tests {
         expect.assert_eq(&actual)
     }
 
-    fn render_path(db: &dyn DefDatabase, info: &ImportInfo) -> String {
-        let mut module = info.container;
+    fn render_path<'db>(db: &'db dyn DefDatabase, info: &ImportInfo) -> String {
+        let mut module: ModuleIdLt<'db> = info.container;
         let mut segments = vec![&info.name];
 
         let def_map = module.def_map(db);
         assert!(def_map.block_id().is_none(), "block local items should not be in `ImportMap`");
 
         while let Some(parent) = module.containing_module(db) {
-            let parent_data = &def_map[parent.local_id];
-            let (name, _) =
-                parent_data.children.iter().find(|(_, id)| **id == module.local_id).unwrap();
+            let parent_data = &def_map[parent];
+            let (name, _) = parent_data.children.iter().find(|(_, id)| **id == module).unwrap();
             segments.push(name);
             module = parent;
         }
diff --git a/crates/hir-def/src/item_scope.rs b/crates/hir-def/src/item_scope.rs
index 1bfe649ebdf9..3ffeebfaf2c9 100644
--- a/crates/hir-def/src/item_scope.rs
+++ b/crates/hir-def/src/item_scope.rs
@@ -17,7 +17,7 @@ use thin_vec::ThinVec;
 
 use crate::{
     AdtId, BuiltinType, ConstId, ExternBlockId, ExternCrateId, FxIndexMap, HasModule, ImplId,
-    LocalModuleId, Lookup, MacroCallStyles, MacroId, ModuleDefId, ModuleId, TraitId, UseId,
+    Lookup, MacroCallStyles, MacroId, ModuleDefId, ModuleId, TraitId, UseId,
     db::DefDatabase,
     per_ns::{Item, MacrosItem, PerNs, TypesItem, ValuesItem},
     visibility::Visibility,
@@ -25,9 +25,9 @@ use crate::{
 
 #[derive(Debug, Default)]
 pub struct PerNsGlobImports {
-    types: FxHashSet<(LocalModuleId, Name)>,
-    values: FxHashSet<(LocalModuleId, Name)>,
-    macros: FxHashSet<(LocalModuleId, Name)>,
+    types: FxHashSet<(ModuleId, Name)>,
+    values: FxHashSet<(ModuleId, Name)>,
+    macros: FxHashSet<(ModuleId, Name)>,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -133,13 +133,13 @@ pub struct GlobId {
 }
 
 impl PerNsGlobImports {
-    pub(crate) fn contains_type(&self, module_id: LocalModuleId, name: Name) -> bool {
+    pub(crate) fn contains_type(&self, module_id: ModuleId, name: Name) -> bool {
         self.types.contains(&(module_id, name))
     }
-    pub(crate) fn contains_value(&self, module_id: LocalModuleId, name: Name) -> bool {
+    pub(crate) fn contains_value(&self, module_id: ModuleId, name: Name) -> bool {
         self.values.contains(&(module_id, name))
     }
-    pub(crate) fn contains_macro(&self, module_id: LocalModuleId, name: Name) -> bool {
+    pub(crate) fn contains_macro(&self, module_id: ModuleId, name: Name) -> bool {
         self.macros.contains(&(module_id, name))
     }
 }
@@ -261,14 +261,12 @@ impl ItemScope {
     pub fn fully_resolve_import(&self, db: &dyn DefDatabase, mut import: ImportId) -> PerNs {
         let mut res = PerNs::none();
 
-        let mut def_map;
         let mut scope = self;
         while let Some(&m) = scope.use_imports_macros.get(&ImportOrExternCrate::Import(import)) {
             match m {
                 ImportOrDef::Import(i) => {
                     let module_id = i.use_.lookup(db).container;
-                    def_map = module_id.def_map(db);
-                    scope = &def_map[module_id.local_id].scope;
+                    scope = &module_id.def_map(db)[module_id].scope;
                     import = i;
                 }
                 ImportOrDef::Def(ModuleDefId::MacroId(def)) => {
@@ -283,8 +281,7 @@ impl ItemScope {
             match m {
                 ImportOrDef::Import(i) => {
                     let module_id = i.use_.lookup(db).container;
-                    def_map = module_id.def_map(db);
-                    scope = &def_map[module_id.local_id].scope;
+                    scope = &module_id.def_map(db)[module_id].scope;
                     import = i;
                 }
                 ImportOrDef::Def(def) => {
@@ -299,8 +296,7 @@ impl ItemScope {
             match m {
                 ImportOrDef::Import(i) => {
                     let module_id = i.use_.lookup(db).container;
-                    def_map = module_id.def_map(db);
-                    scope = &def_map[module_id.local_id].scope;
+                    scope = &module_id.def_map(db)[module_id].scope;
                     import = i;
                 }
                 ImportOrDef::Def(def) => {
@@ -578,7 +574,7 @@ impl ItemScope {
     pub(crate) fn push_res_with_import(
         &mut self,
         glob_imports: &mut PerNsGlobImports,
-        lookup: (LocalModuleId, Name),
+        lookup: (ModuleId, Name),
         def: PerNs,
         import: Option<ImportOrExternCrate>,
     ) -> bool {
@@ -922,10 +918,7 @@ impl ItemInNs {
 
     /// Returns the crate defining this item (or `None` if `self` is built-in).
     pub fn krate(&self, db: &dyn DefDatabase) -> Option<Crate> {
-        match self {
-            ItemInNs::Types(id) | ItemInNs::Values(id) => id.module(db).map(|m| m.krate),
-            ItemInNs::Macros(id) => Some(id.module(db).krate),
-        }
+        self.module(db).map(|module_id| module_id.krate(db))
     }
 
     pub fn module(&self, db: &dyn DefDatabase) -> Option<ModuleId> {
diff --git a/crates/hir-def/src/item_tree.rs b/crates/hir-def/src/item_tree.rs
index 2a104fff2b92..1228d1999bcb 100644
--- a/crates/hir-def/src/item_tree.rs
+++ b/crates/hir-def/src/item_tree.rs
@@ -58,7 +58,7 @@ use syntax::{SyntaxKind, ast, match_ast};
 use thin_vec::ThinVec;
 use triomphe::Arc;
 
-use crate::{BlockId, Lookup, db::DefDatabase};
+use crate::{BlockId, db::DefDatabase};
 
 pub(crate) use crate::item_tree::{
     attrs::*,
@@ -150,10 +150,10 @@ pub(crate) fn block_item_tree_query(db: &dyn DefDatabase, block: BlockId) -> Arc
     let _p = tracing::info_span!("block_item_tree_query", ?block).entered();
     static EMPTY: OnceLock<Arc<ItemTree>> = OnceLock::new();
 
-    let loc = block.lookup(db);
-    let block = loc.ast_id.to_node(db);
+    let ast_id = block.ast_id(db);
+    let block = ast_id.to_node(db);
 
-    let ctx = lower::Ctx::new(db, loc.ast_id.file_id);
+    let ctx = lower::Ctx::new(db, ast_id.file_id);
     let mut item_tree = ctx.lower_block(&block);
     let ItemTree { top_level, top_attrs, attrs, vis, big_data, small_data } = &item_tree;
     if small_data.is_empty()
diff --git a/crates/hir-def/src/lang_item.rs b/crates/hir-def/src/lang_item.rs
index 04acb8b712db..9fdfb5f5b32e 100644
--- a/crates/hir-def/src/lang_item.rs
+++ b/crates/hir-def/src/lang_item.rs
@@ -111,11 +111,12 @@ pub fn lang_items(db: &dyn DefDatabase, start_crate: Crate) -> LangItems {
     // while nameres.
     //
     // See https://github.com/rust-lang/rust-analyzer/pull/20475 for details.
-    for (_, (krate, _)) in crate_local_def_map(db, start_crate).local(db).extern_prelude() {
+    for (_, (module, _)) in crate_local_def_map(db, start_crate).local(db).extern_prelude() {
         // Some crates declares themselves as extern crate like `extern crate self as core`.
         // Ignore these to prevent cycles.
-        if krate.krate != start_crate {
-            result.merge_prefer_self(lang_items(db, krate.krate));
+        let krate = module.krate(db);
+        if krate != start_crate {
+            result.merge_prefer_self(lang_items(db, krate));
         }
     }
 
diff --git a/crates/hir-def/src/lib.rs b/crates/hir-def/src/lib.rs
index ad247e0d6897..e58cb7bad705 100644
--- a/crates/hir-def/src/lib.rs
+++ b/crates/hir-def/src/lib.rs
@@ -71,7 +71,6 @@ use hir_expand::{
     name::Name,
     proc_macro::{CustomProcMacroExpander, ProcMacroKind},
 };
-use la_arena::Idx;
 use nameres::DefMap;
 use span::{AstIdNode, Edition, FileAstId, SyntaxContext};
 use stdx::impl_from;
@@ -412,181 +411,111 @@ pub enum MacroExpander {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ProcMacroLoc {
-    pub container: CrateRootModuleId,
+    pub container: ModuleId,
     pub id: AstId<ast::Fn>,
     pub expander: CustomProcMacroExpander,
     pub kind: ProcMacroKind,
     pub edition: Edition,
 }
 impl_intern!(ProcMacroId, ProcMacroLoc, intern_proc_macro, lookup_intern_proc_macro);
-impl_loc!(ProcMacroLoc, id: Fn, container: CrateRootModuleId);
+impl_loc!(ProcMacroLoc, id: Fn, container: ModuleId);
 
-#[derive(Debug, Hash, PartialEq, Eq, Clone)]
-pub struct BlockLoc {
+#[salsa_macros::tracked(debug)]
+#[derive(PartialOrd, Ord)]
+pub struct BlockIdLt<'db> {
     pub ast_id: AstId<ast::BlockExpr>,
     /// The containing module.
-    pub module: ModuleId,
-}
-impl_intern!(BlockId, BlockLoc, intern_block, lookup_intern_block);
-
-/// A `ModuleId` that is always a crate's root module.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct CrateRootModuleId {
-    krate: Crate,
-}
-
-impl CrateRootModuleId {
-    pub fn def_map(self, db: &dyn DefDatabase) -> &DefMap {
-        crate_def_map(db, self.krate)
-    }
-
-    pub(crate) fn local_def_map(self, db: &dyn DefDatabase) -> (&DefMap, &LocalDefMap) {
-        let def_map = crate_local_def_map(db, self.krate);
-        (def_map.def_map(db), def_map.local(db))
-    }
-
-    pub fn krate(self) -> Crate {
-        self.krate
-    }
-}
-
-impl HasModule for CrateRootModuleId {
-    #[inline]
-    fn module(&self, _db: &dyn DefDatabase) -> ModuleId {
-        ModuleId { krate: self.krate, block: None, local_id: DefMap::ROOT }
-    }
-
-    #[inline]
-    fn krate(&self, _db: &dyn DefDatabase) -> Crate {
-        self.krate
-    }
-}
-
-impl PartialEq<ModuleId> for CrateRootModuleId {
-    fn eq(&self, other: &ModuleId) -> bool {
-        other.block.is_none() && other.local_id == DefMap::ROOT && self.krate == other.krate
-    }
-}
-impl PartialEq<CrateRootModuleId> for ModuleId {
-    fn eq(&self, other: &CrateRootModuleId) -> bool {
-        other == self
-    }
-}
-
-impl From<CrateRootModuleId> for ModuleId {
-    fn from(CrateRootModuleId { krate }: CrateRootModuleId) -> Self {
-        ModuleId { krate, block: None, local_id: DefMap::ROOT }
-    }
+    pub module: ModuleIdLt<'db>,
 }
+pub type BlockId = BlockIdLt<'static>;
 
-impl From<CrateRootModuleId> for ModuleDefId {
-    fn from(value: CrateRootModuleId) -> Self {
-        ModuleDefId::ModuleId(value.into())
-    }
-}
-
-impl From<Crate> for CrateRootModuleId {
-    fn from(krate: Crate) -> Self {
-        CrateRootModuleId { krate }
+impl BlockIdLt<'_> {
+    /// # Safety
+    ///
+    /// The caller must ensure that the `ModuleId` is not leaked outside of query computations.
+    pub unsafe fn to_static(self) -> BlockId {
+        unsafe { std::mem::transmute(self) }
     }
 }
-
-impl TryFrom<ModuleId> for CrateRootModuleId {
-    type Error = ();
-
-    fn try_from(ModuleId { krate, block, local_id }: ModuleId) -> Result<Self, Self::Error> {
-        if block.is_none() && local_id == DefMap::ROOT {
-            Ok(CrateRootModuleId { krate })
-        } else {
-            Err(())
-        }
+impl BlockId {
+    /// # Safety
+    ///
+    /// The caller must ensure that the `BlockId` comes from the given database.
+    pub unsafe fn to_db<'db>(self, _db: &'db dyn DefDatabase) -> BlockIdLt<'db> {
+        unsafe { std::mem::transmute(self) }
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct ModuleId {
-    krate: Crate,
+#[salsa_macros::tracked(debug)]
+#[derive(PartialOrd, Ord)]
+pub struct ModuleIdLt<'db> {
+    /// The crate this module belongs to.
+    pub krate: Crate,
     /// If this `ModuleId` was derived from a `DefMap` for a block expression, this stores the
     /// `BlockId` of that block expression. If `None`, this module is part of the crate-level
     /// `DefMap` of `krate`.
-    block: Option<BlockId>,
-    /// The module's ID in its originating `DefMap`.
-    pub local_id: LocalModuleId,
+    pub block: Option<BlockIdLt<'db>>,
 }
+pub type ModuleId = ModuleIdLt<'static>;
 
-impl ModuleId {
-    pub fn def_map(self, db: &dyn DefDatabase) -> &DefMap {
-        match self.block {
+impl<'db> ModuleIdLt<'db> {
+    /// # Safety
+    ///
+    /// The caller must ensure that the `ModuleId` is not leaked outside of query computations.
+    pub unsafe fn to_static(self) -> ModuleId {
+        unsafe { std::mem::transmute(self) }
+    }
+
+    pub fn def_map(self, db: &'db dyn DefDatabase) -> &'db DefMap {
+        match self.block(db) {
             Some(block) => block_def_map(db, block),
-            None => crate_def_map(db, self.krate),
+            None => crate_def_map(db, self.krate(db)),
         }
     }
 
-    pub(crate) fn local_def_map(self, db: &dyn DefDatabase) -> (&DefMap, &LocalDefMap) {
-        match self.block {
+    pub(crate) fn local_def_map(self, db: &'db dyn DefDatabase) -> (&'db DefMap, &'db LocalDefMap) {
+        match self.block(db) {
             Some(block) => (block_def_map(db, block), self.only_local_def_map(db)),
             None => {
-                let def_map = crate_local_def_map(db, self.krate);
+                let def_map = crate_local_def_map(db, self.krate(db));
                 (def_map.def_map(db), def_map.local(db))
             }
         }
     }
 
-    pub(crate) fn only_local_def_map(self, db: &dyn DefDatabase) -> &LocalDefMap {
-        crate_local_def_map(db, self.krate).local(db)
-    }
-
-    pub fn crate_def_map(self, db: &dyn DefDatabase) -> &DefMap {
-        crate_def_map(db, self.krate)
+    pub(crate) fn only_local_def_map(self, db: &'db dyn DefDatabase) -> &'db LocalDefMap {
+        crate_local_def_map(db, self.krate(db)).local(db)
     }
 
-    pub fn krate(self) -> Crate {
-        self.krate
+    pub fn crate_def_map(self, db: &'db dyn DefDatabase) -> &'db DefMap {
+        crate_def_map(db, self.krate(db))
     }
 
-    pub fn name(self, db: &dyn DefDatabase) -> Option<Name> {
+    pub fn name(self, db: &'db dyn DefDatabase) -> Option<Name> {
         let def_map = self.def_map(db);
-        let parent = def_map[self.local_id].parent?;
+        let parent = def_map[self].parent?;
         def_map[parent].children.iter().find_map(|(name, module_id)| {
-            if *module_id == self.local_id { Some(name.clone()) } else { None }
+            if *module_id == self { Some(name.clone()) } else { None }
         })
     }
 
     /// Returns the module containing `self`, either the parent `mod`, or the module (or block) containing
     /// the block, if `self` corresponds to a block expression.
-    pub fn containing_module(self, db: &dyn DefDatabase) -> Option<ModuleId> {
-        self.def_map(db).containing_module(self.local_id)
-    }
-
-    pub fn containing_block(self) -> Option<BlockId> {
-        self.block
-    }
-
-    pub fn is_block_module(self) -> bool {
-        self.block.is_some() && self.local_id == DefMap::ROOT
+    pub fn containing_module(self, db: &'db dyn DefDatabase) -> Option<ModuleIdLt<'db>> {
+        self.def_map(db).containing_module(self)
     }
 
-    pub fn is_within_block(self) -> bool {
-        self.block.is_some()
-    }
-
-    /// Returns the [`CrateRootModuleId`] for this module if it is the crate root module.
-    pub fn as_crate_root(&self) -> Option<CrateRootModuleId> {
-        if self.local_id == DefMap::ROOT && self.block.is_none() {
-            Some(CrateRootModuleId { krate: self.krate })
-        } else {
-            None
-        }
-    }
-
-    /// Returns the [`CrateRootModuleId`] for this module.
-    pub fn derive_crate_root(&self) -> CrateRootModuleId {
-        CrateRootModuleId { krate: self.krate }
+    pub fn is_block_module(self, db: &'db dyn DefDatabase) -> bool {
+        self.block(db).is_some() && self.def_map(db).root_module_id() == self
     }
+}
 
-    /// Whether this module represents the crate root module
-    pub fn is_crate_root(&self) -> bool {
-        self.local_id == DefMap::ROOT && self.block.is_none()
+impl ModuleId {
+    /// # Safety
+    ///
+    /// The caller must ensure that the `ModuleId` comes from the given database.
+    pub unsafe fn to_db<'db>(self, _db: &'db dyn DefDatabase) -> ModuleIdLt<'db> {
+        unsafe { std::mem::transmute(self) }
     }
 }
 
@@ -597,9 +526,6 @@ impl HasModule for ModuleId {
     }
 }
 
-/// An ID of a module, **local** to a `DefMap`.
-pub type LocalModuleId = Idx<nameres::ModuleData>;
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, salsa::Update)]
 pub struct FieldId {
     // FIXME: Store this as an erased `salsa::Id` to save space
@@ -682,7 +608,7 @@ pub struct LifetimeParamId {
     pub local_id: LocalLifetimeParamId,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, salsa_macros::Supertype)]
 pub enum ItemContainerId {
     ExternBlockId(ExternBlockId),
     ModuleId(ModuleId),
@@ -956,16 +882,9 @@ impl CallableDefId {
     }
 }
 
-// FIXME: We probably should use this in more places.
-/// This is used to avoid interning the whole `AttrDefId`, so we intern just modules and not everything.
-#[salsa_macros::interned(debug, no_lifetime)]
-pub struct InternedModuleId {
-    pub loc: ModuleId,
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, salsa_macros::Supertype)]
 pub enum AttrDefId {
-    ModuleId(InternedModuleId),
+    ModuleId(ModuleId),
     AdtId(AdtId),
     FunctionId(FunctionId),
     EnumVariantId(EnumVariantId),
@@ -1058,7 +977,7 @@ pub trait HasModule {
     #[inline]
     #[doc(alias = "crate")]
     fn krate(&self, db: &dyn DefDatabase) -> Crate {
-        self.module(db).krate
+        self.module(db).krate(db)
     }
 }
 
@@ -1162,7 +1081,7 @@ impl HasModule for Macro2Id {
 impl HasModule for ProcMacroId {
     #[inline]
     fn module(&self, db: &dyn DefDatabase) -> ModuleId {
-        self.lookup(db).container.into()
+        self.lookup(db).container
     }
 }
 
@@ -1235,7 +1154,7 @@ impl HasModule for GenericDefId {
 impl HasModule for AttrDefId {
     fn module(&self, db: &dyn DefDatabase) -> ModuleId {
         match self {
-            AttrDefId::ModuleId(it) => it.loc(db),
+            AttrDefId::ModuleId(it) => *it,
             AttrDefId::AdtId(it) => it.module(db),
             AttrDefId::FunctionId(it) => it.module(db),
             AttrDefId::EnumVariantId(it) => it.module(db),
diff --git a/crates/hir-def/src/macro_expansion_tests/mbe.rs b/crates/hir-def/src/macro_expansion_tests/mbe.rs
index 947a54f88862..a12674f353c8 100644
--- a/crates/hir-def/src/macro_expansion_tests/mbe.rs
+++ b/crates/hir-def/src/macro_expansion_tests/mbe.rs
@@ -35,9 +35,9 @@ macro_rules! f {
     };
 }
 
-struct#0:MacroRules[BE8F, 0]@58..64#14336# MyTraitMap2#0:MacroCall[BE8F, 0]@31..42#ROOT2024# {#0:MacroRules[BE8F, 0]@72..73#14336#
-    map#0:MacroRules[BE8F, 0]@86..89#14336#:#0:MacroRules[BE8F, 0]@89..90#14336# #0:MacroRules[BE8F, 0]@89..90#14336#::#0:MacroRules[BE8F, 0]@91..93#14336#std#0:MacroRules[BE8F, 0]@93..96#14336#::#0:MacroRules[BE8F, 0]@96..98#14336#collections#0:MacroRules[BE8F, 0]@98..109#14336#::#0:MacroRules[BE8F, 0]@109..111#14336#HashSet#0:MacroRules[BE8F, 0]@111..118#14336#<#0:MacroRules[BE8F, 0]@118..119#14336#(#0:MacroRules[BE8F, 0]@119..120#14336#)#0:MacroRules[BE8F, 0]@120..121#14336#>#0:MacroRules[BE8F, 0]@121..122#14336#,#0:MacroRules[BE8F, 0]@122..123#14336#
-}#0:MacroRules[BE8F, 0]@132..133#14336#
+struct#0:MacroRules[BE8F, 0]@58..64#15360# MyTraitMap2#0:MacroCall[BE8F, 0]@31..42#ROOT2024# {#0:MacroRules[BE8F, 0]@72..73#15360#
+    map#0:MacroRules[BE8F, 0]@86..89#15360#:#0:MacroRules[BE8F, 0]@89..90#15360# #0:MacroRules[BE8F, 0]@89..90#15360#::#0:MacroRules[BE8F, 0]@91..93#15360#std#0:MacroRules[BE8F, 0]@93..96#15360#::#0:MacroRules[BE8F, 0]@96..98#15360#collections#0:MacroRules[BE8F, 0]@98..109#15360#::#0:MacroRules[BE8F, 0]@109..111#15360#HashSet#0:MacroRules[BE8F, 0]@111..118#15360#<#0:MacroRules[BE8F, 0]@118..119#15360#(#0:MacroRules[BE8F, 0]@119..120#15360#)#0:MacroRules[BE8F, 0]@120..121#15360#>#0:MacroRules[BE8F, 0]@121..122#15360#,#0:MacroRules[BE8F, 0]@122..123#15360#
+}#0:MacroRules[BE8F, 0]@132..133#15360#
 "#]],
     );
 }
@@ -197,7 +197,7 @@ macro_rules! mk_struct {
 #[macro_use]
 mod foo;
 
-struct#1:MacroRules[DB0C, 0]@59..65#14336# Foo#0:MacroCall[DB0C, 0]@32..35#ROOT2024#(#1:MacroRules[DB0C, 0]@70..71#14336#u32#0:MacroCall[DB0C, 0]@41..44#ROOT2024#)#1:MacroRules[DB0C, 0]@74..75#14336#;#1:MacroRules[DB0C, 0]@75..76#14336#
+struct#1:MacroRules[DB0C, 0]@59..65#15360# Foo#0:MacroCall[DB0C, 0]@32..35#ROOT2024#(#1:MacroRules[DB0C, 0]@70..71#15360#u32#0:MacroCall[DB0C, 0]@41..44#ROOT2024#)#1:MacroRules[DB0C, 0]@74..75#15360#;#1:MacroRules[DB0C, 0]@75..76#15360#
 "#]],
     );
 }
@@ -423,10 +423,10 @@ m! { foo, bar }
 macro_rules! m {
     ($($i:ident),*) => ( impl Bar { $(fn $i() {})* } );
 }
-impl#\14336# Bar#\14336# {#\14336#
-    fn#\14336# foo#\ROOT2024#(#\14336#)#\14336# {#\14336#}#\14336#
-    fn#\14336# bar#\ROOT2024#(#\14336#)#\14336# {#\14336#}#\14336#
-}#\14336#
+impl#\15360# Bar#\15360# {#\15360#
+    fn#\15360# foo#\ROOT2024#(#\15360#)#\15360# {#\15360#}#\15360#
+    fn#\15360# bar#\ROOT2024#(#\15360#)#\15360# {#\15360#}#\15360#
+}#\15360#
 "#]],
     );
 }
diff --git a/crates/hir-def/src/macro_expansion_tests/mod.rs b/crates/hir-def/src/macro_expansion_tests/mod.rs
index 98b3115814d4..78af976e1b13 100644
--- a/crates/hir-def/src/macro_expansion_tests/mod.rs
+++ b/crates/hir-def/src/macro_expansion_tests/mod.rs
@@ -131,8 +131,7 @@ pub fn identity_when_valid(_attr: TokenStream, item: TokenStream) -> TokenStream
     let db = TestDB::with_files_extra_proc_macros(ra_fixture, extra_proc_macros);
     let krate = db.fetch_test_crate();
     let def_map = crate_def_map(&db, krate);
-    let local_id = DefMap::ROOT;
-    let source = def_map[local_id].definition_source(&db);
+    let source = def_map[def_map.root].definition_source(&db);
     let source_file = match source.value {
         ModuleSource::SourceFile(it) => it,
         ModuleSource::Module(_) | ModuleSource::BlockExpr(_) => panic!(),
@@ -209,7 +208,7 @@ pub fn identity_when_valid(_attr: TokenStream, item: TokenStream) -> TokenStream
         expanded_text.replace_range(range, &text);
     }
 
-    for decl_id in def_map[local_id].scope.declarations() {
+    for decl_id in def_map[def_map.root].scope.declarations() {
         // FIXME: I'm sure there's already better way to do this
         let src = match decl_id {
             ModuleDefId::AdtId(AdtId::StructId(struct_id)) => {
@@ -260,7 +259,7 @@ pub fn identity_when_valid(_attr: TokenStream, item: TokenStream) -> TokenStream
         }
     }
 
-    for impl_id in def_map[local_id].scope.impls() {
+    for impl_id in def_map[def_map.root].scope.impls() {
         let src = impl_id.lookup(&db).source(&db);
         if let Some(macro_file) = src.file_id.macro_file()
             && let MacroKind::DeriveBuiltIn | MacroKind::Derive = macro_file.kind(&db)
diff --git a/crates/hir-def/src/nameres.rs b/crates/hir-def/src/nameres.rs
index aefbf6306e70..a85237662c43 100644
--- a/crates/hir-def/src/nameres.rs
+++ b/crates/hir-def/src/nameres.rs
@@ -58,7 +58,7 @@ pub mod proc_macro;
 #[cfg(test)]
 mod tests;
 
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut, Index, IndexMut};
 
 use base_db::Crate;
 use hir_expand::{
@@ -67,7 +67,6 @@ use hir_expand::{
 };
 use intern::Symbol;
 use itertools::Itertools;
-use la_arena::Arena;
 use rustc_hash::{FxHashMap, FxHashSet};
 use span::{Edition, FileAstId, FileId, ROOT_ERASED_FILE_AST_ID};
 use stdx::format_to;
@@ -76,8 +75,8 @@ use triomphe::Arc;
 use tt::TextRange;
 
 use crate::{
-    AstId, BlockId, BlockLoc, CrateRootModuleId, ExternCrateId, FunctionId, FxIndexMap,
-    LocalModuleId, Lookup, MacroCallStyles, MacroExpander, MacroId, ModuleId, ProcMacroId, UseId,
+    AstId, BlockId, BlockIdLt, ExternCrateId, FunctionId, FxIndexMap, Lookup, MacroCallStyles,
+    MacroExpander, MacroId, ModuleId, ModuleIdLt, ProcMacroId, UseId,
     db::DefDatabase,
     item_scope::{BuiltinShadowMode, ItemScope},
     item_tree::TreeId,
@@ -109,7 +108,7 @@ pub struct LocalDefMap {
     // FIXME: There are probably some other things that could be here, but this is less severe and you
     // need to be careful with things that block def maps also have.
     /// The extern prelude which contains all root modules of external crates that are in scope.
-    extern_prelude: FxIndexMap<Name, (CrateRootModuleId, Option<ExternCrateId>)>,
+    extern_prelude: FxIndexMap<Name, (ModuleId, Option<ExternCrateId>)>,
 }
 
 impl std::hash::Hash for LocalDefMap {
@@ -135,8 +134,7 @@ impl LocalDefMap {
 
     pub(crate) fn extern_prelude(
         &self,
-    ) -> impl DoubleEndedIterator<Item = (&Name, (CrateRootModuleId, Option<ExternCrateId>))> + '_
-    {
+    ) -> impl DoubleEndedIterator<Item = (&Name, (ModuleId, Option<ExternCrateId>))> + '_ {
         self.extern_prelude.iter().map(|(name, &def)| (name, def))
     }
 }
@@ -157,8 +155,9 @@ pub struct DefMap {
     /// When this is a block def map, this will hold the block id of the block and module that
     /// contains this block.
     block: Option<BlockInfo>,
+    pub root: ModuleId,
     /// The modules and their data declared in this crate.
-    pub modules: Arena<ModuleData>,
+    pub modules: ModulesMap,
     /// The prelude module for this crate. This either comes from an import
     /// marked with the `prelude_import` attribute, or (in the normal case) from
     /// a dependency (`std` or `core`).
@@ -245,33 +244,22 @@ struct BlockInfo {
     /// The `BlockId` this `DefMap` was created from.
     block: BlockId,
     /// The containing module.
-    parent: BlockRelativeModuleId,
+    parent: ModuleId,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-struct BlockRelativeModuleId {
-    block: Option<BlockId>,
-    local_id: LocalModuleId,
-}
-
-impl BlockRelativeModuleId {
-    fn def_map(self, db: &dyn DefDatabase, krate: Crate) -> &DefMap {
-        self.into_module(krate).def_map(db)
-    }
-
-    fn into_module(self, krate: Crate) -> ModuleId {
-        ModuleId { krate, block: self.block, local_id: self.local_id }
-    }
+impl std::ops::Index<ModuleIdLt<'_>> for DefMap {
+    type Output = ModuleData;
 
-    fn is_block_module(self) -> bool {
-        self.block.is_some() && self.local_id == DefMap::ROOT
+    fn index(&self, id: ModuleIdLt<'_>) -> &ModuleData {
+        self.modules
+            .get(&unsafe { id.to_static() })
+            .unwrap_or_else(|| panic!("ModuleId not found in ModulesMap {:#?}: {id:#?}", self.root))
     }
 }
 
-impl std::ops::Index<LocalModuleId> for DefMap {
-    type Output = ModuleData;
-    fn index(&self, id: LocalModuleId) -> &ModuleData {
-        &self.modules[id]
+impl std::ops::IndexMut<ModuleId> for DefMap {
+    fn index_mut(&mut self, id: ModuleId) -> &mut ModuleData {
+        &mut self.modules[id]
     }
 }
 
@@ -358,8 +346,8 @@ pub struct ModuleData {
     /// Parent module in the same `DefMap`.
     ///
     /// [`None`] for block modules because they are always its `DefMap`'s root.
-    pub parent: Option<LocalModuleId>,
-    pub children: FxIndexMap<Name, LocalModuleId>,
+    pub parent: Option<ModuleId>,
+    pub children: FxIndexMap<Name, ModuleId>,
     pub scope: ItemScope,
 }
 
@@ -392,11 +380,19 @@ pub(crate) fn crate_local_def_map(db: &dyn DefDatabase, crate_id: Crate) -> DefM
     .entered();
 
     let root_file_id = crate_id.root_file_id(db);
-    let module_data =
-        ModuleData::new(ModuleOrigin::CrateRoot { definition: root_file_id }, Visibility::Public);
+    let module_data = ModuleData::new(
+        ModuleOrigin::CrateRoot { definition: root_file_id },
+        Visibility::Public,
+        None,
+    );
 
-    let def_map =
-        DefMap::empty(crate_id, Arc::new(DefMapCrateData::new(krate.edition)), module_data, None);
+    let def_map = DefMap::empty(
+        db,
+        crate_id,
+        Arc::new(DefMapCrateData::new(krate.edition)),
+        module_data,
+        None,
+    );
     let (def_map, local_def_map) =
         collector::collect_defs(db, def_map, TreeId::new(root_file_id.into(), None), None);
 
@@ -404,25 +400,23 @@ pub(crate) fn crate_local_def_map(db: &dyn DefDatabase, crate_id: Crate) -> DefM
 }
 
 #[salsa_macros::tracked(returns(ref))]
-pub fn block_def_map(db: &dyn DefDatabase, block_id: BlockId) -> DefMap {
-    let BlockLoc { ast_id, module } = block_id.lookup(db);
+pub fn block_def_map<'db>(db: &'db dyn DefDatabase, block_id: BlockIdLt<'db>) -> DefMap {
+    let block_id = unsafe { block_id.to_static() };
+    let ast_id = block_id.ast_id(db);
+    let module = unsafe { block_id.module(db).to_static() };
 
-    let visibility = Visibility::Module(
-        ModuleId { krate: module.krate, local_id: DefMap::ROOT, block: module.block },
-        VisibilityExplicitness::Implicit,
-    );
+    let visibility = Visibility::Module(module, VisibilityExplicitness::Implicit);
     let module_data =
-        ModuleData::new(ModuleOrigin::BlockExpr { block: ast_id, id: block_id }, visibility);
+        ModuleData::new(ModuleOrigin::BlockExpr { block: ast_id, id: block_id }, visibility, None);
 
-    let local_def_map = crate_local_def_map(db, module.krate);
+    let krate = module.krate(db);
+    let local_def_map = crate_local_def_map(db, krate);
     let def_map = DefMap::empty(
-        module.krate,
+        db,
+        krate,
         local_def_map.def_map(db).data.clone(),
         module_data,
-        Some(BlockInfo {
-            block: block_id,
-            parent: BlockRelativeModuleId { block: module.block, local_id: module.local_id },
-        }),
+        Some(BlockInfo { block: block_id, parent: module }),
     );
 
     let (def_map, _) = collector::collect_defs(
@@ -435,25 +429,24 @@ pub fn block_def_map(db: &dyn DefDatabase, block_id: BlockId) -> DefMap {
 }
 
 impl DefMap {
-    /// The module id of a crate or block root.
-    pub const ROOT: LocalModuleId = LocalModuleId::from_raw(la_arena::RawIdx::from_u32(0));
-
     pub fn edition(&self) -> Edition {
         self.data.edition
     }
 
     fn empty(
+        db: &dyn DefDatabase,
         krate: Crate,
         crate_data: Arc<DefMapCrateData>,
         module_data: ModuleData,
         block: Option<BlockInfo>,
     ) -> DefMap {
-        let mut modules: Arena<ModuleData> = Arena::default();
-        let root = modules.alloc(module_data);
-        assert_eq!(root, Self::ROOT);
+        let mut modules = ModulesMap::new();
+        let root = unsafe { ModuleIdLt::new(db, krate, block.map(|it| it.block)).to_static() };
+        modules.insert(root, module_data);
 
         DefMap {
             block,
+            root,
             modules,
             krate,
             prelude: None,
@@ -471,6 +464,7 @@ impl DefMap {
             diagnostics,
             modules,
             derive_helpers_in_scope,
+            root: _,
             block: _,
             krate: _,
             prelude: _,
@@ -495,7 +489,7 @@ impl DefMap {
         &'a self,
         db: &'a dyn DefDatabase,
         file_id: FileId,
-    ) -> impl Iterator<Item = LocalModuleId> + 'a {
+    ) -> impl Iterator<Item = ModuleId> + 'a {
         self.modules
             .iter()
             .filter(move |(_id, data)| {
@@ -504,7 +498,7 @@ impl DefMap {
             .map(|(id, _data)| id)
     }
 
-    pub fn modules(&self) -> impl Iterator<Item = (LocalModuleId, &ModuleData)> + '_ {
+    pub fn modules(&self) -> impl Iterator<Item = (ModuleId, &ModuleData)> + '_ {
         self.modules.iter()
     }
 
@@ -543,40 +537,32 @@ impl DefMap {
         self.krate
     }
 
-    pub fn module_id(&self, local_id: LocalModuleId) -> ModuleId {
-        let block = self.block.map(|b| b.block);
-        ModuleId { krate: self.krate, local_id, block }
-    }
-
-    pub fn crate_root(&self) -> CrateRootModuleId {
-        CrateRootModuleId { krate: self.krate }
+    #[inline]
+    pub fn crate_root(&self, db: &dyn DefDatabase) -> ModuleId {
+        match self.block {
+            Some(_) => crate_def_map(db, self.krate()).root,
+            None => self.root,
+        }
     }
 
     /// This is the same as [`Self::crate_root`] for crate def maps, but for block def maps, it
     /// returns the root block module.
     pub fn root_module_id(&self) -> ModuleId {
-        self.module_id(Self::ROOT)
+        self.root
     }
 
     /// If this `DefMap` is for a block expression, returns the module containing the block (which
     /// might again be a block, or a module inside a block).
     pub fn parent(&self) -> Option<ModuleId> {
-        let BlockRelativeModuleId { block, local_id } = self.block?.parent;
-        Some(ModuleId { krate: self.krate, block, local_id })
+        Some(self.block?.parent)
     }
 
     /// Returns the module containing `local_mod`, either the parent `mod`, or the module (or block) containing
     /// the block, if `self` corresponds to a block expression.
-    pub fn containing_module(&self, local_mod: LocalModuleId) -> Option<ModuleId> {
+    pub fn containing_module(&self, local_mod: ModuleIdLt<'_>) -> Option<ModuleId> {
         match self[local_mod].parent {
-            Some(parent) => Some(self.module_id(parent)),
-            None => {
-                self.block.map(
-                    |BlockInfo { parent: BlockRelativeModuleId { block, local_id }, .. }| {
-                        ModuleId { krate: self.krate, block, local_id }
-                    },
-                )
-            }
+            Some(parent) => Some(parent),
+            None => self.block.map(|BlockInfo { parent, .. }| parent),
         }
     }
 
@@ -594,30 +580,21 @@ impl DefMap {
     // even), as this should be a great debugging aid.
     pub fn dump(&self, db: &dyn DefDatabase) -> String {
         let mut buf = String::new();
-        let mut arc;
         let mut current_map = self;
         while let Some(block) = current_map.block {
-            go(&mut buf, db, current_map, "(block scope)", Self::ROOT);
+            go(&mut buf, db, current_map, "(block scope)", current_map.root);
             buf.push('\n');
-            arc = block.parent.def_map(db, self.krate);
-            current_map = arc;
+            current_map = block.parent.def_map(db);
         }
-        go(&mut buf, db, current_map, "crate", Self::ROOT);
+        go(&mut buf, db, current_map, "crate", current_map.root);
         return buf;
 
-        fn go(
-            buf: &mut String,
-            db: &dyn DefDatabase,
-            map: &DefMap,
-            path: &str,
-            module: LocalModuleId,
-        ) {
+        fn go(buf: &mut String, db: &dyn DefDatabase, map: &DefMap, path: &str, module: ModuleId) {
             format_to!(buf, "{}\n", path);
 
-            map.modules[module].scope.dump(db, buf);
+            map[module].scope.dump(db, buf);
 
-            for (name, child) in
-                map.modules[module].children.iter().sorted_by(|a, b| Ord::cmp(&a.0, &b.0))
+            for (name, child) in map[module].children.iter().sorted_by(|a, b| Ord::cmp(&a.0, &b.0))
             {
                 let path = format!("{path}::{}", name.display(db, Edition::LATEST));
                 buf.push('\n');
@@ -625,20 +602,6 @@ impl DefMap {
             }
         }
     }
-
-    pub fn dump_block_scopes(&self, db: &dyn DefDatabase) -> String {
-        let mut buf = String::new();
-        let mut arc;
-        let mut current_map = self;
-        while let Some(block) = current_map.block {
-            format_to!(buf, "{:?} in {:?}\n", block.block, block.parent);
-            arc = block.parent.def_map(db, self.krate);
-            current_map = arc;
-        }
-
-        format_to!(buf, "crate scope\n");
-        buf
-    }
 }
 
 impl DefMap {
@@ -658,7 +621,7 @@ impl DefMap {
         &self,
         local_def_map: &LocalDefMap,
         db: &dyn DefDatabase,
-        original_module: LocalModuleId,
+        original_module: ModuleId,
         path: &ModPath,
         shadow: BuiltinShadowMode,
         expected_macro_subns: Option<MacroSubNs>,
@@ -681,7 +644,7 @@ impl DefMap {
         &self,
         local_def_map: &LocalDefMap,
         db: &dyn DefDatabase,
-        original_module: LocalModuleId,
+        original_module: ModuleId,
         path: &ModPath,
         shadow: BuiltinShadowMode,
     ) -> (PerNs, Option<usize>, ResolvePathResultPrefixInfo) {
@@ -701,19 +664,19 @@ impl DefMap {
     ///
     /// If `f` returns `Some(val)`, iteration is stopped and `Some(val)` is returned. If `f` returns
     /// `None`, iteration continues.
-    pub(crate) fn with_ancestor_maps<T>(
+    pub(crate) fn with_ancestor_maps<'db, T>(
         &self,
-        db: &dyn DefDatabase,
-        local_mod: LocalModuleId,
-        f: &mut dyn FnMut(&DefMap, LocalModuleId) -> Option<T>,
+        db: &'db dyn DefDatabase,
+        local_mod: ModuleIdLt<'db>,
+        f: &mut dyn FnMut(&DefMap, ModuleIdLt<'db>) -> Option<T>,
     ) -> Option<T> {
         if let Some(it) = f(self, local_mod) {
             return Some(it);
         }
         let mut block = self.block;
         while let Some(block_info) = block {
-            let parent = block_info.parent.def_map(db, self.krate);
-            if let Some(it) = f(parent, block_info.parent.local_id) {
+            let parent = block_info.parent.def_map(db);
+            if let Some(it) = f(parent, block_info.parent) {
                 return Some(it);
             }
             block = parent.block;
@@ -724,11 +687,15 @@ impl DefMap {
 }
 
 impl ModuleData {
-    pub(crate) fn new(origin: ModuleOrigin, visibility: Visibility) -> Self {
+    pub(crate) fn new(
+        origin: ModuleOrigin,
+        visibility: Visibility,
+        parent: Option<ModuleId>,
+    ) -> Self {
         ModuleData {
             origin,
             visibility,
-            parent: None,
+            parent,
             children: Default::default(),
             scope: ItemScope::default(),
         }
@@ -852,3 +819,55 @@ fn sub_namespace_match(
         None => true,
     }
 }
+
+/// A newtype wrapper around `FxHashMap<ModuleId, ModuleData>` that implements `IndexMut`.
+#[derive(Debug, PartialEq, Eq)]
+pub struct ModulesMap {
+    inner: FxIndexMap<ModuleId, ModuleData>,
+}
+
+impl ModulesMap {
+    fn new() -> Self {
+        Self { inner: FxIndexMap::default() }
+    }
+
+    fn iter(&self) -> impl Iterator<Item = (ModuleId, &ModuleData)> + '_ {
+        self.inner.iter().map(|(&k, v)| (k, v))
+    }
+
+    fn iter_mut(&mut self) -> impl Iterator<Item = (ModuleId, &mut ModuleData)> + '_ {
+        self.inner.iter_mut().map(|(&k, v)| (k, v))
+    }
+}
+
+impl Deref for ModulesMap {
+    type Target = FxIndexMap<ModuleId, ModuleData>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl DerefMut for ModulesMap {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+impl Index<ModuleIdLt<'_>> for ModulesMap {
+    type Output = ModuleData;
+
+    fn index(&self, id: ModuleIdLt<'_>) -> &ModuleData {
+        self.inner
+            .get(&unsafe { id.to_static() })
+            .unwrap_or_else(|| panic!("ModuleId not found in ModulesMap: {id:#?}"))
+    }
+}
+
+impl IndexMut<ModuleId> for ModulesMap {
+    fn index_mut(&mut self, id: ModuleId) -> &mut ModuleData {
+        self.inner
+            .get_mut(&id)
+            .unwrap_or_else(|| panic!("ModuleId not found in ModulesMap: {id:#?}"))
+    }
+}
diff --git a/crates/hir-def/src/nameres/assoc.rs b/crates/hir-def/src/nameres/assoc.rs
index b67853347bde..9d2b2109fbcb 100644
--- a/crates/hir-def/src/nameres/assoc.rs
+++ b/crates/hir-def/src/nameres/assoc.rs
@@ -165,7 +165,7 @@ impl<'a> AssocItemCollector<'a> {
             local_def_map,
             ast_id_map: db.ast_id_map(file_id),
             span_map: db.span_map(file_id),
-            cfg_options: module_id.krate.cfg_options(db),
+            cfg_options: module_id.krate(db).cfg_options(db),
             file_id,
             container,
             items: Vec::new(),
@@ -197,7 +197,7 @@ impl<'a> AssocItemCollector<'a> {
                 AttrsOrCfg::Enabled { attrs } => attrs,
                 AttrsOrCfg::CfgDisabled(cfg) => {
                     self.diagnostics.push(DefDiagnostic::unconfigured_code(
-                        self.module_id.local_id,
+                        self.module_id,
                         InFile::new(self.file_id, ast_id.erase()),
                         cfg.0,
                         self.cfg_options.clone(),
@@ -213,7 +213,7 @@ impl<'a> AssocItemCollector<'a> {
             match self.def_map.resolve_attr_macro(
                 self.local_def_map,
                 self.db,
-                self.module_id.local_id,
+                self.module_id,
                 ast_id_with_path,
                 attr,
                 attr_id,
@@ -226,9 +226,9 @@ impl<'a> AssocItemCollector<'a> {
                         // crate failed), skip expansion like we would if it was
                         // disabled. This is analogous to the handling in
                         // `DefCollector::collect_macros`.
-                        if let Some(err) = exp.as_expand_error(self.module_id.krate) {
+                        if let Some(err) = exp.as_expand_error(self.module_id.krate(self.db)) {
                             self.diagnostics.push(DefDiagnostic::macro_error(
-                                self.module_id.local_id,
+                                self.module_id,
                                 ast_id,
                                 (*attr.path).clone(),
                                 err,
@@ -244,7 +244,7 @@ impl<'a> AssocItemCollector<'a> {
                 Ok(_) => (),
                 Err(_) => {
                     self.diagnostics.push(DefDiagnostic::unresolved_macro_call(
-                        self.module_id.local_id,
+                        self.module_id,
                         MacroCallKind::Attr {
                             ast_id,
                             attr_args: None,
@@ -307,7 +307,7 @@ impl<'a> AssocItemCollector<'a> {
                         .resolve_path(
                             self.local_def_map,
                             self.db,
-                            self.module_id.local_id,
+                            self.module_id,
                             path,
                             crate::item_scope::BuiltinShadowMode::Other,
                             Some(MacroSubNs::Bang),
@@ -322,7 +322,7 @@ impl<'a> AssocItemCollector<'a> {
                     &path,
                     ctxt,
                     ExpandTo::Items,
-                    self.module_id.krate(),
+                    self.module_id.krate(self.db),
                     resolver,
                     &mut |ptr, call_id| {
                         self.macro_calls.push((ptr.map(|(_, it)| it.upcast()), call_id))
@@ -338,7 +338,7 @@ impl<'a> AssocItemCollector<'a> {
                     },
                     Err(_) => {
                         self.diagnostics.push(DefDiagnostic::unresolved_macro_call(
-                            self.module_id.local_id,
+                            self.module_id,
                             MacroCallKind::FnLike {
                                 ast_id,
                                 expand_to: ExpandTo::Items,
diff --git a/crates/hir-def/src/nameres/attr_resolution.rs b/crates/hir-def/src/nameres/attr_resolution.rs
index fb755026c3e0..ec05c02bd635 100644
--- a/crates/hir-def/src/nameres/attr_resolution.rs
+++ b/crates/hir-def/src/nameres/attr_resolution.rs
@@ -12,7 +12,7 @@ use syntax::ast;
 use triomphe::Arc;
 
 use crate::{
-    AstIdWithPath, LocalModuleId, MacroId, UnresolvedMacro,
+    AstIdWithPath, MacroId, ModuleId, UnresolvedMacro,
     db::DefDatabase,
     item_scope::BuiltinShadowMode,
     nameres::{LocalDefMap, path_resolution::ResolveMode},
@@ -33,7 +33,7 @@ impl DefMap {
         &self,
         local_def_map: &LocalDefMap,
         db: &dyn DefDatabase,
-        original_module: LocalModuleId,
+        original_module: ModuleId,
         ast_id: AstIdWithPath<ast::Item>,
         attr: &Attr,
         attr_id: AttrId,
diff --git a/crates/hir-def/src/nameres/collector.rs b/crates/hir-def/src/nameres/collector.rs
index 9aa7febdfd02..08edf41c5694 100644
--- a/crates/hir-def/src/nameres/collector.rs
+++ b/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::{cmp::Ordering, iter, mem};
+use std::{iter, mem};
 
 use base_db::{BuiltDependency, Crate, CrateOrigin, LangCrateOrigin};
 use cfg::{CfgAtom, CfgExpr, CfgOptions};
@@ -27,12 +27,11 @@ use syntax::ast;
 use triomphe::Arc;
 
 use crate::{
-    AdtId, AssocItemId, AstId, AstIdWithPath, ConstLoc, CrateRootModuleId, EnumLoc, ExternBlockLoc,
-    ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc, FxIndexMap, ImplLoc, Intern,
-    ItemContainerId, LocalModuleId, Lookup, Macro2Id, Macro2Loc, MacroExpander, MacroId,
-    MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ModuleDefId, ModuleId, ProcMacroId,
-    ProcMacroLoc, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc, UnresolvedMacro, UseId,
-    UseLoc,
+    AdtId, AssocItemId, AstId, AstIdWithPath, ConstLoc, EnumLoc, ExternBlockLoc, ExternCrateId,
+    ExternCrateLoc, FunctionId, FunctionLoc, FxIndexMap, ImplLoc, Intern, ItemContainerId, Lookup,
+    Macro2Id, Macro2Loc, MacroExpander, MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags,
+    ModuleDefId, ModuleId, ProcMacroId, ProcMacroLoc, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc,
+    UnionLoc, UnresolvedMacro, UseId, UseLoc,
     db::DefDatabase,
     item_scope::{GlobId, ImportId, ImportOrExternCrate, PerNsGlobImports},
     item_tree::{
@@ -177,14 +176,14 @@ impl Import {
 #[derive(Debug, Eq, PartialEq)]
 struct ImportDirective {
     /// The module this import directive is in.
-    module_id: LocalModuleId,
+    module_id: ModuleId,
     import: Import,
     status: PartialResolvedImport,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct MacroDirective<'db> {
-    module_id: LocalModuleId,
+    module_id: ModuleId,
     depth: usize,
     kind: MacroDirectiveKind<'db>,
     container: ItemContainerId,
@@ -224,7 +223,7 @@ struct DefCollector<'db> {
     crate_local_def_map: Option<&'db LocalDefMap>,
     // The dependencies of the current crate, including optional deps like `test`.
     deps: FxIndexMap<Name, BuiltDependency>,
-    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, Visibility, GlobId)>>,
+    glob_imports: FxHashMap<ModuleId, Vec<(ModuleId, Visibility, GlobId)>>,
     unresolved_imports: Vec<ImportDirective>,
     indeterminate_imports: Vec<(ImportDirective, PerNs)>,
     unresolved_macros: Vec<MacroDirective<'db>>,
@@ -232,7 +231,7 @@ struct DefCollector<'db> {
     // resolve. When we emit diagnostics for unresolved imports, we only do so if the import
     // doesn't start with an unresolved crate's name.
     unresolved_extern_crates: FxHashSet<Name>,
-    mod_dirs: FxHashMap<LocalModuleId, ModDir>,
+    mod_dirs: FxHashMap<ModuleId, ModDir>,
     cfg_options: &'db CfgOptions,
     /// List of procedural macros defined by this crate. This is read from the dynamic library
     /// built by the build system, and is the list of proc-macros we can actually expand. It is
@@ -337,9 +336,14 @@ impl<'db> DefCollector<'db> {
                     continue;
                 }
 
-                self.local_def_map
-                    .extern_prelude
-                    .insert(name.clone(), (CrateRootModuleId { krate: dep.crate_id }, None));
+                // This eagerly draws a dependency edge between the crate def maps even if the
+                // things the crates are not used. This is not great, but at the same time we would
+                // like to compute our dependency def maps in parallel here anyways in the future
+                // which will have the same effect.
+                self.local_def_map.extern_prelude.insert(
+                    name.clone(),
+                    (crate_def_map(self.db, dep.crate_id).root_module_id(), None),
+                );
             }
         }
 
@@ -349,10 +353,11 @@ impl<'db> DefCollector<'db> {
             return;
         }
 
+        let module_id = self.def_map.root;
         ModCollector {
             def_collector: self,
             macro_depth: 0,
-            module_id: DefMap::ROOT,
+            module_id,
             tree_id: TreeId::new(file_id.into(), None),
             item_tree,
             mod_dir: ModDir::root(),
@@ -367,10 +372,11 @@ impl<'db> DefCollector<'db> {
         if is_cfg_enabled {
             self.inject_prelude();
 
+            let module_id = self.def_map.root;
             ModCollector {
                 def_collector: self,
                 macro_depth: 0,
-                module_id: DefMap::ROOT,
+                module_id,
                 tree_id,
                 item_tree,
                 mod_dir: ModDir::root(),
@@ -433,7 +439,8 @@ impl<'db> DefCollector<'db> {
             // Additionally, while the proc macro entry points must be `pub`, they are not publicly
             // exported in type/value namespace. This function reduces the visibility of all items
             // in the crate root that aren't proc macros.
-            let root = &mut self.def_map.modules[DefMap::ROOT];
+            let module_id = self.def_map.root_module_id();
+            let root = &mut self.def_map.modules[module_id];
             root.scope.censor_non_proc_macros(self.def_map.krate);
         }
     }
@@ -537,7 +544,7 @@ impl<'db> DefCollector<'db> {
         let (per_ns, _) = self.def_map.resolve_path(
             self.crate_local_def_map.unwrap_or(&self.local_def_map),
             self.db,
-            DefMap::ROOT,
+            self.def_map.root_module_id(),
             &path,
             BuiltinShadowMode::Other,
             None,
@@ -592,7 +599,7 @@ impl<'db> DefCollector<'db> {
         };
 
         let proc_macro_id = ProcMacroLoc {
-            container: self.def_map.crate_root(),
+            container: self.def_map.root_module_id(),
             id: ast_id,
             expander,
             kind,
@@ -636,7 +643,7 @@ impl<'db> DefCollector<'db> {
     /// ```
     fn define_macro_rules(
         &mut self,
-        module_id: LocalModuleId,
+        module_id: ModuleId,
         name: Name,
         macro_: MacroRulesId,
         export: bool,
@@ -648,7 +655,7 @@ impl<'db> DefCollector<'db> {
         // In Rust, `#[macro_export]` macros are unconditionally visible at the
         // crate root, even if the parent modules is **not** visible.
         if export {
-            let module_id = DefMap::ROOT;
+            let module_id = self.def_map.root;
             self.def_map.modules[module_id].scope.declare(macro_.into());
             self.update(
                 module_id,
@@ -666,7 +673,7 @@ impl<'db> DefCollector<'db> {
     /// the definition of current module.
     /// And also, `macro_use` on a module will import all legacy macros visible inside to
     /// current legacy scope, with possible shadowing.
-    fn define_legacy_macro(&mut self, module_id: LocalModuleId, name: Name, mac: MacroId) {
+    fn define_legacy_macro(&mut self, module_id: ModuleId, name: Name, mac: MacroId) {
         // Always shadowing
         self.def_map.modules[module_id].scope.define_legacy_macro(name, mac);
     }
@@ -676,7 +683,7 @@ impl<'db> DefCollector<'db> {
     /// The scoped of macro 2.0 macro is equal to normal function
     fn define_macro_def(
         &mut self,
-        module_id: LocalModuleId,
+        module_id: ModuleId,
         name: Name,
         macro_: Macro2Id,
         vis: &RawVisibility,
@@ -705,7 +712,7 @@ impl<'db> DefCollector<'db> {
     /// A proc macro is similar to normal macro scope, but it would not visible in legacy textual scoped.
     /// And unconditionally exported.
     fn define_proc_macro(&mut self, name: Name, macro_: ProcMacroId) {
-        let module_id = DefMap::ROOT;
+        let module_id = self.def_map.root;
         self.def_map.modules[module_id].scope.declare(macro_.into());
         self.update(
             module_id,
@@ -730,7 +737,7 @@ impl<'db> DefCollector<'db> {
         let def_map = crate_def_map(self.db, krate);
         // `#[macro_use]` brings macros into macro_use prelude. Yes, even non-`macro_rules!`
         // macros.
-        let root_scope = &def_map[DefMap::ROOT].scope;
+        let root_scope = &def_map[def_map.root].scope;
         match names {
             Some(names) => {
                 for name in names {
@@ -803,7 +810,7 @@ impl<'db> DefCollector<'db> {
         res
     }
 
-    fn resolve_import(&self, module_id: LocalModuleId, import: &Import) -> PartialResolvedImport {
+    fn resolve_import(&self, module_id: ModuleId, import: &Import) -> PartialResolvedImport {
         let _p = tracing::info_span!("resolve_import", import_path = %import.path.display(self.db, Edition::LATEST))
             .entered();
         tracing::debug!("resolving import: {:?} ({:?})", import, self.def_map.data.edition);
@@ -916,11 +923,10 @@ impl<'db> DefCollector<'db> {
                             // implementation seems to work the same though.
                             cov_mark::hit!(std_prelude);
                             self.def_map.prelude = Some((m, Some(id)));
-                        } else if m.krate != self.def_map.krate {
+                        } else if m.krate(self.db) != self.def_map.krate {
                             cov_mark::hit!(glob_across_crates);
                             // glob import from other crate => we can just import everything once
-                            let item_map = m.def_map(self.db);
-                            let scope = &item_map[m.local_id].scope;
+                            let scope = &m.def_map(self.db)[m].scope;
 
                             // Module scoped macros is included
                             let items = scope
@@ -942,12 +948,10 @@ impl<'db> DefCollector<'db> {
                             // glob import from same crate => we do an initial
                             // import, and then need to propagate any further
                             // additions
-                            let def_map;
-                            let scope = if m.block == self.def_map.block_id() {
-                                &self.def_map[m.local_id].scope
+                            let scope = if m.block(self.db) == self.def_map.block_id() {
+                                &self.def_map[m].scope
                             } else {
-                                def_map = m.def_map(self.db);
-                                &def_map[m.local_id].scope
+                                &m.def_map(self.db)[m].scope
                             };
 
                             // Module scoped macros is included
@@ -976,11 +980,12 @@ impl<'db> DefCollector<'db> {
                                 Some(ImportOrExternCrate::Glob(glob)),
                             );
                             // record the glob import in case we add further items
-                            let glob_imports = self.glob_imports.entry(m.local_id).or_default();
+                            let glob_imports = self.glob_imports.entry(m).or_default();
                             match glob_imports.iter_mut().find(|(mid, _, _)| *mid == module_id) {
                                 None => glob_imports.push((module_id, vis, glob)),
                                 Some((_, old_vis, _)) => {
-                                    if let Some(new_vis) = old_vis.max(vis, &self.def_map) {
+                                    if let Some(new_vis) = old_vis.max(self.db, vis, &self.def_map)
+                                    {
                                         *old_vis = new_vis;
                                     }
                                 }
@@ -1056,20 +1061,19 @@ impl<'db> DefCollector<'db> {
     fn update(
         &mut self,
         // The module for which `resolutions` have been resolve
-        module_id: LocalModuleId,
+        module_id: ModuleId,
         resolutions: &[(Option<Name>, PerNs)],
         // Visibility this import will have
         vis: Visibility,
         import: Option<ImportOrExternCrate>,
     ) {
-        self.db.unwind_if_revision_cancelled();
         self.update_recursive(module_id, resolutions, vis, import, 0)
     }
 
     fn update_recursive(
         &mut self,
         // The module for which `resolutions` have been resolved.
-        module_id: LocalModuleId,
+        module_id: ModuleId,
         resolutions: &[(Option<Name>, PerNs)],
         // All resolutions are imported with this visibility; the visibilities in
         // the `PerNs` values are ignored and overwritten
@@ -1104,7 +1108,7 @@ impl<'db> DefCollector<'db> {
                     let should_update = match old_vis {
                         None => true,
                         Some(old_vis) => {
-                            let max_vis = old_vis.max(vis, &self.def_map).unwrap_or_else(|| {
+                            let max_vis = old_vis.max(self.db, vis, &self.def_map).unwrap_or_else(|| {
                                 panic!("`Tr as _` imports with unrelated visibilities {old_vis:?} and {vis:?} (trait {tr:?})");
                             });
 
@@ -1146,7 +1150,7 @@ impl<'db> DefCollector<'db> {
             .collect::<Vec<_>>();
 
         for (glob_importing_module, glob_import_vis, glob) in glob_imports {
-            let vis = glob_import_vis.min(vis, &self.def_map).unwrap_or(glob_import_vis);
+            let vis = glob_import_vis.min(self.db, vis, &self.def_map).unwrap_or(glob_import_vis);
             self.update_recursive(
                 glob_importing_module,
                 resolutions,
@@ -1159,20 +1163,20 @@ impl<'db> DefCollector<'db> {
 
     fn push_res_and_update_glob_vis(
         &mut self,
-        module_id: LocalModuleId,
+        module_id: ModuleId,
         name: &Name,
         mut defs: PerNs,
         vis: Visibility,
         def_import_type: Option<ImportOrExternCrate>,
     ) -> bool {
         if let Some(def) = defs.types.as_mut() {
-            def.vis = def.vis.min(vis, &self.def_map).unwrap_or(vis);
+            def.vis = def.vis.min(self.db, vis, &self.def_map).unwrap_or(vis);
         }
         if let Some(def) = defs.values.as_mut() {
-            def.vis = def.vis.min(vis, &self.def_map).unwrap_or(vis);
+            def.vis = def.vis.min(self.db, vis, &self.def_map).unwrap_or(vis);
         }
         if let Some(def) = defs.macros.as_mut() {
-            def.vis = def.vis.min(vis, &self.def_map).unwrap_or(vis);
+            def.vis = def.vis.min(self.db, vis, &self.def_map).unwrap_or(vis);
         }
 
         let mut changed = false;
@@ -1188,7 +1192,7 @@ impl<'db> DefCollector<'db> {
                 && def.def == prev_def.def
                 && self.from_glob_import.contains_type(module_id, name.clone())
                 && def.vis != prev_def.vis
-                && def.vis.max(prev_def.vis, &self.def_map) == Some(def.vis)
+                && def.vis.max(self.db, prev_def.vis, &self.def_map) == Some(def.vis)
             {
                 changed = true;
                 // This import is being handled here, don't pass it down to
@@ -1202,7 +1206,7 @@ impl<'db> DefCollector<'db> {
                 && def.def == prev_def.def
                 && self.from_glob_import.contains_value(module_id, name.clone())
                 && def.vis != prev_def.vis
-                && def.vis.max(prev_def.vis, &self.def_map) == Some(def.vis)
+                && def.vis.max(self.db, prev_def.vis, &self.def_map) == Some(def.vis)
             {
                 changed = true;
                 // See comment above.
@@ -1215,7 +1219,7 @@ impl<'db> DefCollector<'db> {
                 && def.def == prev_def.def
                 && self.from_glob_import.contains_macro(module_id, name.clone())
                 && def.vis != prev_def.vis
-                && def.vis.max(prev_def.vis, &self.def_map) == Some(def.vis)
+                && def.vis.max(self.db, prev_def.vis, &self.def_map) == Some(def.vis)
             {
                 changed = true;
                 // See comment above.
@@ -1555,7 +1559,7 @@ impl<'db> DefCollector<'db> {
 
     fn collect_macro_expansion(
         &mut self,
-        module_id: LocalModuleId,
+        module_id: ModuleId,
         macro_call_id: MacroCallId,
         depth: usize,
         container: ItemContainerId,
@@ -1713,7 +1717,7 @@ impl<'db> DefCollector<'db> {
 struct ModCollector<'a, 'db> {
     def_collector: &'a mut DefCollector<'db>,
     macro_depth: usize,
-    module_id: LocalModuleId,
+    module_id: ModuleId,
     tree_id: TreeId,
     item_tree: &'db ItemTree,
     mod_dir: ModDir,
@@ -1721,14 +1725,13 @@ struct ModCollector<'a, 'db> {
 
 impl ModCollector<'_, '_> {
     fn collect_in_top_module(&mut self, items: &[ModItemId]) {
-        let module = self.def_collector.def_map.module_id(self.module_id);
-        self.collect(items, module.into())
+        self.collect(items, self.module_id.into())
     }
 
     fn collect(&mut self, items: &[ModItemId], container: ItemContainerId) {
         let krate = self.def_collector.def_map.krate;
-        let is_crate_root =
-            self.module_id == DefMap::ROOT && self.def_collector.def_map.block.is_none();
+        let is_crate_root = self.module_id == self.def_collector.def_map.root
+            && self.def_collector.def_map.block.is_none();
 
         // Note: don't assert that inserted value is fresh: it's simply not true
         // for macros.
@@ -1737,10 +1740,10 @@ impl ModCollector<'_, '_> {
         // Prelude module is always considered to be `#[macro_use]`.
         if let Some((prelude_module, _use)) = self.def_collector.def_map.prelude {
             // Don't insert macros from the prelude into blocks, as they can be shadowed by other macros.
-            if prelude_module.krate != krate && is_crate_root {
+            if is_crate_root && prelude_module.krate(self.def_collector.db) != krate {
                 cov_mark::hit!(prelude_is_macro_use);
                 self.def_collector.import_macros_from_extern_crate(
-                    prelude_module.krate,
+                    prelude_module.krate(self.def_collector.db),
                     None,
                     None,
                 );
@@ -1781,7 +1784,6 @@ impl ModCollector<'_, '_> {
                 return;
             }
 
-            let module = self.def_collector.def_map.module_id(module_id);
             let def_map = &mut self.def_collector.def_map;
             let local_def_map =
                 self.def_collector.crate_local_def_map.unwrap_or(&self.def_collector.local_def_map);
@@ -1789,9 +1791,11 @@ impl ModCollector<'_, '_> {
             match item {
                 ModItemId::Mod(m) => self.collect_module(m, attrs),
                 ModItemId::Use(item_tree_id) => {
-                    let id =
-                        UseLoc { container: module, id: InFile::new(self.file_id(), item_tree_id) }
-                            .intern(db);
+                    let id = UseLoc {
+                        container: module_id,
+                        id: InFile::new(self.file_id(), item_tree_id),
+                    }
+                    .intern(db);
                     let is_prelude = attrs.by_key(sym::prelude_import).exists();
                     Import::from_use(self.item_tree, item_tree_id, id, is_prelude, |import| {
                         self.def_collector.unresolved_imports.push(ImportDirective {
@@ -1806,7 +1810,7 @@ impl ModCollector<'_, '_> {
                         &self.item_tree[item_tree_id];
 
                     let id = ExternCrateLoc {
-                        container: module,
+                        container: module_id,
                         id: InFile::new(self.tree_id.file_id(), item_tree_id),
                     }
                     .intern(db);
@@ -1815,12 +1819,12 @@ impl ModCollector<'_, '_> {
                     let is_self = *name == sym::self_;
                     let resolved = if is_self {
                         cov_mark::hit!(extern_crate_self_as);
-                        Some(def_map.crate_root())
+                        Some(def_map.crate_root(db))
                     } else {
                         self.def_collector
                             .deps
                             .get(name)
-                            .map(|dep| CrateRootModuleId { krate: dep.crate_id })
+                            .map(|dep| crate_def_map(db, dep.crate_id).root_module_id())
                     };
 
                     let name = match alias {
@@ -1845,7 +1849,7 @@ impl ModCollector<'_, '_> {
                                 self.process_macro_use_extern_crate(
                                     id,
                                     attrs.by_key(sym::macro_use).attrs(),
-                                    resolved.krate,
+                                    resolved.krate(self.def_collector.db),
                                 );
                             }
                         }
@@ -1877,7 +1881,7 @@ impl ModCollector<'_, '_> {
                 }
                 ModItemId::ExternBlock(block) => {
                     let extern_block_id = ExternBlockLoc {
-                        container: module,
+                        container: module_id,
                         id: InFile::new(self.file_id(), block),
                     }
                     .intern(db);
@@ -1890,11 +1894,11 @@ impl ModCollector<'_, '_> {
                     )
                 }
                 ModItemId::MacroCall(mac) => self.collect_macro_call(mac, container),
-                ModItemId::MacroRules(id) => self.collect_macro_rules(id, module),
-                ModItemId::Macro2(id) => self.collect_macro_def(id, module),
+                ModItemId::MacroRules(id) => self.collect_macro_rules(id, module_id),
+                ModItemId::Macro2(id) => self.collect_macro_def(id, module_id),
                 ModItemId::Impl(imp) => {
                     let impl_id =
-                        ImplLoc { container: module, id: InFile::new(self.file_id(), imp) }
+                        ImplLoc { container: module_id, id: InFile::new(self.file_id(), imp) }
                             .intern(db);
                     self.def_collector.def_map.modules[self.module_id].scope.define_impl(impl_id)
                 }
@@ -1908,7 +1912,7 @@ impl ModCollector<'_, '_> {
 
                     if self.def_collector.def_map.block.is_none()
                         && self.def_collector.is_proc_macro
-                        && self.module_id == DefMap::ROOT
+                        && self.module_id == self.def_collector.def_map.root
                         && let Some(proc_macro) = attrs.parse_proc_macro_decl(&it.name)
                     {
                         self.def_collector.export_proc_macro(
@@ -1926,7 +1930,7 @@ impl ModCollector<'_, '_> {
                     let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]);
                     update_def(
                         self.def_collector,
-                        StructLoc { container: module, id: InFile::new(self.file_id(), id) }
+                        StructLoc { container: module_id, id: InFile::new(self.file_id(), id) }
                             .intern(db)
                             .into(),
                         &it.name,
@@ -1940,7 +1944,7 @@ impl ModCollector<'_, '_> {
                     let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]);
                     update_def(
                         self.def_collector,
-                        UnionLoc { container: module, id: InFile::new(self.file_id(), id) }
+                        UnionLoc { container: module_id, id: InFile::new(self.file_id(), id) }
                             .intern(db)
                             .into(),
                         &it.name,
@@ -1950,9 +1954,11 @@ impl ModCollector<'_, '_> {
                 }
                 ModItemId::Enum(id) => {
                     let it = &self.item_tree[id];
-                    let enum_ =
-                        EnumLoc { container: module, id: InFile::new(self.tree_id.file_id(), id) }
-                            .intern(db);
+                    let enum_ = EnumLoc {
+                        container: module_id,
+                        id: InFile::new(self.tree_id.file_id(), id),
+                    }
+                    .intern(db);
 
                     let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]);
                     update_def(self.def_collector, enum_.into(), &it.name, vis, false);
@@ -1997,7 +2003,7 @@ impl ModCollector<'_, '_> {
                     let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]);
                     update_def(
                         self.def_collector,
-                        TraitLoc { container: module, id: InFile::new(self.file_id(), id) }
+                        TraitLoc { container: module_id, id: InFile::new(self.file_id(), id) }
                             .intern(db)
                             .into(),
                         &it.name,
@@ -2172,9 +2178,10 @@ impl ModCollector<'_, '_> {
         declaration: FileAstId<ast::Module>,
         definition: Option<(EditionedFileId, bool)>,
         visibility: &crate::visibility::RawVisibility,
-    ) -> LocalModuleId {
-        let def_map = &mut self.def_collector.def_map;
-        let vis = def_map
+    ) -> ModuleId {
+        let vis = self
+            .def_collector
+            .def_map
             .resolve_visibility(
                 self.def_collector.crate_local_def_map.unwrap_or(&self.def_collector.local_def_map),
                 self.def_collector.db,
@@ -2195,21 +2202,25 @@ impl ModCollector<'_, '_> {
             },
         };
 
+        let module = unsafe {
+            crate::ModuleIdLt::new(
+                self.def_collector.db,
+                self.def_collector.def_map.krate,
+                self.def_collector.def_map.block_id(),
+            )
+            .to_static()
+        };
+        let def_map = &mut self.def_collector.def_map;
         let modules = &mut def_map.modules;
-        let res = modules.alloc(ModuleData::new(origin, vis));
-        modules[res].parent = Some(self.module_id);
-
-        if let Some((target, source)) = Self::borrow_modules(modules.as_mut(), res, self.module_id)
-        {
-            for (name, macs) in source.scope.legacy_macros() {
-                for &mac in macs {
-                    target.scope.define_legacy_macro(name.clone(), mac);
-                }
+        let mut data = ModuleData::new(origin, vis, Some(self.module_id));
+        for (name, macs) in modules[self.module_id].scope.legacy_macros() {
+            for &mac in macs {
+                data.scope.define_legacy_macro(name.clone(), mac);
             }
         }
-        modules[self.module_id].children.insert(name.clone(), res);
+        modules[self.module_id].children.insert(name.clone(), module);
+        modules.insert(module, data);
 
-        let module = def_map.module_id(res);
         let def = ModuleDefId::from(module);
 
         def_map.modules[self.module_id].scope.declare(def);
@@ -2219,7 +2230,7 @@ impl ModCollector<'_, '_> {
             vis,
             None,
         );
-        res
+        module
     }
 
     /// Resolves attributes on an item.
@@ -2516,12 +2527,10 @@ impl ModCollector<'_, '_> {
         });
     }
 
-    fn import_all_legacy_macros(&mut self, module_id: LocalModuleId) {
-        let Some((source, target)) = Self::borrow_modules(
-            self.def_collector.def_map.modules.as_mut(),
-            module_id,
-            self.module_id,
-        ) else {
+    fn import_all_legacy_macros(&mut self, module_id: ModuleId) {
+        let [Some(source), Some(target)] =
+            self.def_collector.def_map.modules.get_disjoint_mut([&module_id, &self.module_id])
+        else {
             return;
         };
 
@@ -2532,29 +2541,6 @@ impl ModCollector<'_, '_> {
         }
     }
 
-    /// Mutably borrow two modules at once, retu
-    fn borrow_modules(
-        modules: &mut [ModuleData],
-        a: LocalModuleId,
-        b: LocalModuleId,
-    ) -> Option<(&mut ModuleData, &mut ModuleData)> {
-        let a = a.into_raw().into_u32() as usize;
-        let b = b.into_raw().into_u32() as usize;
-
-        let (a, b) = match a.cmp(&b) {
-            Ordering::Equal => return None,
-            Ordering::Less => {
-                let (prefix, b) = modules.split_at_mut(b);
-                (&mut prefix[a], &mut b[0])
-            }
-            Ordering::Greater => {
-                let (prefix, a) = modules.split_at_mut(a);
-                (&mut a[0], &mut prefix[b])
-            }
-        };
-        Some((a, b))
-    }
-
     fn emit_unconfigured_diagnostic(&mut self, ast_id: ErasedAstId, cfg: &CfgExpr) {
         self.def_collector.def_map.diagnostics.push(DefDiagnostic::unconfigured_code(
             self.module_id,
@@ -2574,48 +2560,15 @@ impl ModCollector<'_, '_> {
 mod tests {
     use test_fixture::WithFixture;
 
-    use crate::{nameres::DefMapCrateData, test_db::TestDB};
+    use crate::test_db::TestDB;
 
     use super::*;
 
-    fn do_collect_defs(db: &dyn DefDatabase, def_map: DefMap) -> DefMap {
-        let mut collector = DefCollector {
-            db,
-            def_map,
-            local_def_map: LocalDefMap::default(),
-            crate_local_def_map: None,
-            deps: FxIndexMap::default(),
-            glob_imports: FxHashMap::default(),
-            unresolved_imports: Vec::new(),
-            indeterminate_imports: Vec::new(),
-            unresolved_macros: Vec::new(),
-            mod_dirs: FxHashMap::default(),
-            cfg_options: &CfgOptions::default(),
-            proc_macros: Default::default(),
-            from_glob_import: Default::default(),
-            skip_attrs: Default::default(),
-            prev_active_attrs: Default::default(),
-            is_proc_macro: false,
-            unresolved_extern_crates: Default::default(),
-        };
-        collector.seed_with_top_level();
-        collector.collect();
-        collector.def_map
-    }
-
-    fn do_resolve(not_ra_fixture: &str) -> DefMap {
-        let (db, file_id) = TestDB::with_single_file(not_ra_fixture);
+    fn do_resolve(not_ra_fixture: &str) {
+        let (db, _) = TestDB::with_single_file(not_ra_fixture);
         let krate = db.test_crate();
 
-        let edition = krate.data(&db).edition;
-        let module_origin = ModuleOrigin::CrateRoot { definition: file_id };
-        let def_map = DefMap::empty(
-            krate,
-            Arc::new(DefMapCrateData::new(edition)),
-            ModuleData::new(module_origin, Visibility::Public),
-            None,
-        );
-        do_collect_defs(&db, def_map)
+        crate_def_map(&db, krate);
     }
 
     #[test]
diff --git a/crates/hir-def/src/nameres/diagnostics.rs b/crates/hir-def/src/nameres/diagnostics.rs
index 6a07c56aeebe..be28e085094e 100644
--- a/crates/hir-def/src/nameres/diagnostics.rs
+++ b/crates/hir-def/src/nameres/diagnostics.rs
@@ -7,7 +7,7 @@ use hir_expand::{ErasedAstId, ExpandErrorKind, MacroCallKind, attrs::AttrId, mod
 use la_arena::Idx;
 use syntax::ast;
 
-use crate::{AstId, nameres::LocalModuleId};
+use crate::{AstId, nameres::ModuleId};
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum DefDiagnosticKind {
@@ -43,13 +43,13 @@ impl DefDiagnostics {
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct DefDiagnostic {
-    pub in_module: LocalModuleId,
+    pub in_module: ModuleId,
     pub kind: DefDiagnosticKind,
 }
 
 impl DefDiagnostic {
     pub(super) fn unresolved_module(
-        container: LocalModuleId,
+        container: ModuleId,
         declaration: AstId<ast::Module>,
         candidates: Box<[String]>,
     ) -> Self {
@@ -60,7 +60,7 @@ impl DefDiagnostic {
     }
 
     pub(super) fn unresolved_extern_crate(
-        container: LocalModuleId,
+        container: ModuleId,
         declaration: AstId<ast::ExternCrate>,
     ) -> Self {
         Self {
@@ -70,7 +70,7 @@ impl DefDiagnostic {
     }
 
     pub(super) fn unresolved_import(
-        container: LocalModuleId,
+        container: ModuleId,
         id: AstId<ast::Use>,
         index: Idx<ast::UseTree>,
     ) -> Self {
@@ -78,7 +78,7 @@ impl DefDiagnostic {
     }
 
     pub fn macro_error(
-        container: LocalModuleId,
+        container: ModuleId,
         ast: AstId<ast::Item>,
         path: ModPath,
         err: ExpandErrorKind,
@@ -87,7 +87,7 @@ impl DefDiagnostic {
     }
 
     pub fn unconfigured_code(
-        container: LocalModuleId,
+        container: ModuleId,
         ast_id: ErasedAstId,
         cfg: CfgExpr,
         opts: CfgOptions,
@@ -100,33 +100,26 @@ impl DefDiagnostic {
 
     // FIXME: Whats the difference between this and unresolved_proc_macro
     pub(crate) fn unresolved_macro_call(
-        container: LocalModuleId,
+        container: ModuleId,
         ast: MacroCallKind,
         path: ModPath,
     ) -> Self {
         Self { in_module: container, kind: DefDiagnosticKind::UnresolvedMacroCall { ast, path } }
     }
 
-    pub(super) fn unimplemented_builtin_macro(
-        container: LocalModuleId,
-        ast: AstId<ast::Macro>,
-    ) -> Self {
+    pub(super) fn unimplemented_builtin_macro(container: ModuleId, ast: AstId<ast::Macro>) -> Self {
         Self { in_module: container, kind: DefDiagnosticKind::UnimplementedBuiltinMacro { ast } }
     }
 
     pub(super) fn invalid_derive_target(
-        container: LocalModuleId,
+        container: ModuleId,
         ast: AstId<ast::Item>,
         id: AttrId,
     ) -> Self {
         Self { in_module: container, kind: DefDiagnosticKind::InvalidDeriveTarget { ast, id } }
     }
 
-    pub(super) fn malformed_derive(
-        container: LocalModuleId,
-        ast: AstId<ast::Adt>,
-        id: AttrId,
-    ) -> Self {
+    pub(super) fn malformed_derive(container: ModuleId, ast: AstId<ast::Adt>, id: AttrId) -> Self {
         Self { in_module: container, kind: DefDiagnosticKind::MalformedDerive { ast, id } }
     }
 }
diff --git a/crates/hir-def/src/nameres/path_resolution.rs b/crates/hir-def/src/nameres/path_resolution.rs
index 184a57410d02..e4b1d2a98735 100644
--- a/crates/hir-def/src/nameres/path_resolution.rs
+++ b/crates/hir-def/src/nameres/path_resolution.rs
@@ -19,7 +19,7 @@ use span::Edition;
 use stdx::TupleExt;
 
 use crate::{
-    AdtId, LocalModuleId, ModuleDefId,
+    AdtId, ModuleDefId, ModuleId,
     db::DefDatabase,
     item_scope::{BUILTIN_SCOPE, ImportOrExternCrate},
     item_tree::FieldsShape,
@@ -97,7 +97,7 @@ impl DefMap {
         local_def_map: &LocalDefMap,
         db: &dyn DefDatabase,
         // module to import to
-        original_module: LocalModuleId,
+        original_module: ModuleId,
         // pub(path)
         //     ^^^^ this
         visibility: &RawVisibility,
@@ -130,8 +130,8 @@ impl DefMap {
                 // DefMap they're written in, so we restrict them when that happens.
                 if let Visibility::Module(m, mv) = vis {
                     // ...unless we're resolving visibility for an associated item in an impl.
-                    if self.block_id() != m.block && !within_impl {
-                        vis = Visibility::Module(self.module_id(Self::ROOT), mv);
+                    if self.block_id() != m.block(db) && !within_impl {
+                        vis = Visibility::Module(self.root, mv);
                         tracing::debug!(
                             "visibility {:?} points outside DefMap, adjusting to {:?}",
                             m,
@@ -142,7 +142,7 @@ impl DefMap {
                 vis
             }
             RawVisibility::PubSelf(explicitness) => {
-                Visibility::Module(self.module_id(original_module), *explicitness)
+                Visibility::Module(original_module, *explicitness)
             }
             RawVisibility::Public => Visibility::Public,
             RawVisibility::PubCrate => Visibility::PubCrate(self.krate),
@@ -158,7 +158,7 @@ impl DefMap {
         db: &dyn DefDatabase,
         mode: ResolveMode,
         // module to import to
-        mut original_module: LocalModuleId,
+        mut original_module: ModuleId,
         path: &ModPath,
         shadow: BuiltinShadowMode,
         // Pass `MacroSubNs` if we know we're resolving macro names and which kind of macro we're
@@ -198,17 +198,17 @@ impl DefMap {
 
         loop {
             match current_map.block {
-                Some(block) if original_module == Self::ROOT => {
+                Some(block) if original_module == current_map.root => {
                     // Block modules "inherit" names from its parent module.
-                    original_module = block.parent.local_id;
-                    current_map = block.parent.def_map(db, current_map.krate);
+                    original_module = block.parent;
+                    current_map = block.parent.def_map(db);
                 }
                 // Proper (non-block) modules, including those in block `DefMap`s, don't.
                 _ => {
-                    if original_module != Self::ROOT && current_map.block.is_some() {
+                    if original_module != current_map.root && current_map.block.is_some() {
                         // A module inside a block. Do not resolve items declared in upper blocks, but we do need to get
                         // the prelude items (which are not inserted into blocks because they can be overridden there).
-                        original_module = Self::ROOT;
+                        original_module = current_map.root;
                         current_map = crate_def_map(db, self.krate);
 
                         let new = current_map.resolve_path_fp_in_all_preludes(
@@ -245,7 +245,7 @@ impl DefMap {
         local_def_map: &LocalDefMap,
         db: &dyn DefDatabase,
         mode: ResolveMode,
-        original_module: LocalModuleId,
+        original_module: ModuleId,
         path: &ModPath,
         shadow: BuiltinShadowMode,
         expected_macro_subns: Option<MacroSubNs>,
@@ -255,15 +255,15 @@ impl DefMap {
             PathKind::DollarCrate(krate) => {
                 if krate == self.krate {
                     cov_mark::hit!(macro_dollar_crate_self);
-                    PerNs::types(self.crate_root().into(), Visibility::Public, None)
+                    PerNs::types(self.crate_root(db).into(), Visibility::Public, None)
                 } else {
                     let def_map = crate_def_map(db, krate);
-                    let module = def_map.module_id(Self::ROOT);
+                    let module = def_map.root;
                     cov_mark::hit!(macro_dollar_crate_other);
                     PerNs::types(module.into(), Visibility::Public, None)
                 }
             }
-            PathKind::Crate => PerNs::types(self.crate_root().into(), Visibility::Public, None),
+            PathKind::Crate => PerNs::types(self.crate_root(db).into(), Visibility::Public, None),
             // plain import or absolute path in 2015: crate-relative with
             // fallback to extern prelude (with the simplification in
             // rust-lang/rust#57745)
@@ -310,14 +310,10 @@ impl DefMap {
             }
             PathKind::Super(lvl) => {
                 let mut local_id = original_module;
-                let mut ext;
                 let mut def_map = self;
 
                 // Adjust `local_id` to `self`, i.e. the nearest non-block module.
-                if def_map.module_id(local_id).is_block_module() {
-                    (ext, local_id) = adjust_to_nearest_non_block_module(db, def_map, local_id);
-                    def_map = ext;
-                }
+                (def_map, local_id) = adjust_to_nearest_non_block_module(db, def_map, local_id);
 
                 // Go up the module tree but skip block modules as `super` always refers to the
                 // nearest non-block module.
@@ -325,12 +321,8 @@ impl DefMap {
                     // Loop invariant: at the beginning of each loop, `local_id` must refer to a
                     // non-block module.
                     if let Some(parent) = def_map.modules[local_id].parent {
-                        local_id = parent;
-                        if def_map.module_id(local_id).is_block_module() {
-                            (ext, local_id) =
-                                adjust_to_nearest_non_block_module(db, def_map, local_id);
-                            def_map = ext;
-                        }
+                        (def_map, local_id) =
+                            adjust_to_nearest_non_block_module(db, def_map, parent);
                     } else {
                         stdx::always!(def_map.block.is_none());
                         tracing::debug!("super path in root module");
@@ -338,9 +330,6 @@ impl DefMap {
                     }
                 }
 
-                let module = def_map.module_id(local_id);
-                stdx::never!(module.is_block_module());
-
                 if self.block != def_map.block {
                     // If we have a different `DefMap` from `self` (the original `DefMap` we started
                     // with), resolve the remaining path segments in that `DefMap`.
@@ -358,7 +347,7 @@ impl DefMap {
                     );
                 }
 
-                PerNs::types(module.into(), Visibility::Public, None)
+                PerNs::types(local_id.into(), Visibility::Public, None)
             }
             PathKind::Abs => match self.resolve_path_abs(local_def_map, &mut segments, path) {
                 Either::Left(it) => it,
@@ -385,7 +374,7 @@ impl DefMap {
         local_def_map: &LocalDefMap,
         db: &dyn DefDatabase,
         mode: ResolveMode,
-        original_module: LocalModuleId,
+        original_module: ModuleId,
         path: &ModPath,
         shadow: BuiltinShadowMode,
     ) -> ResolvePathResult {
@@ -467,7 +456,7 @@ impl DefMap {
         mut curr_per_ns: PerNs,
         path: &ModPath,
         shadow: BuiltinShadowMode,
-        original_module: LocalModuleId,
+        original_module: ModuleId,
     ) -> ResolvePathResult {
         while let Some((i, segment)) = segments.next() {
             let curr = match curr_per_ns.take_types_full() {
@@ -485,7 +474,7 @@ impl DefMap {
 
             curr_per_ns = match curr.def {
                 ModuleDefId::ModuleId(module) => {
-                    if module.krate != self.krate {
+                    if module.krate(db) != self.krate {
                         // FIXME: Inefficient
                         let path = ModPath::from_segments(
                             PathKind::SELF,
@@ -501,7 +490,7 @@ impl DefMap {
                             LocalDefMap::EMPTY,
                             db,
                             mode,
-                            module.local_id,
+                            module,
                             &path,
                             shadow,
                             None,
@@ -518,11 +507,11 @@ impl DefMap {
                     }
 
                     let def_map;
-                    let module_data = if module.block == self.block_id() {
-                        &self[module.local_id]
+                    let module_data = if module.block(db) == self.block_id() {
+                        &self[module]
                     } else {
                         def_map = module.def_map(db);
-                        &def_map[module.local_id]
+                        &def_map[module]
                     };
 
                     // Since it is a qualified path here, it should not contains legacy macros
@@ -649,7 +638,7 @@ impl DefMap {
         &self,
         local_def_map: &LocalDefMap,
         db: &dyn DefDatabase,
-        module: LocalModuleId,
+        module: ModuleId,
         name: &Name,
         shadow: BuiltinShadowMode,
         expected_macro_subns: Option<MacroSubNs>,
@@ -684,7 +673,7 @@ impl DefMap {
         };
 
         let extern_prelude = || {
-            if self.block.is_some() && module == DefMap::ROOT {
+            if self.block.is_some() && module == self.root {
                 // Don't resolve extern prelude in pseudo-modules of blocks, because
                 // they might been shadowed by local names.
                 return PerNs::none();
@@ -693,7 +682,7 @@ impl DefMap {
         };
         let macro_use_prelude = || self.resolve_in_macro_use_prelude(name);
         let prelude = || {
-            if self.block.is_some() && module == DefMap::ROOT {
+            if self.block.is_some() && module == self.root {
                 return PerNs::none();
             }
             self.resolve_in_prelude(db, name)
@@ -746,18 +735,18 @@ impl DefMap {
         &self,
         local_def_map: &LocalDefMap,
         db: &dyn DefDatabase,
-        module: LocalModuleId,
+        module: ModuleId,
         name: &Name,
     ) -> PerNs {
         let from_crate_root = match self.block {
             Some(_) => {
-                let def_map = self.crate_root().def_map(db);
-                def_map[Self::ROOT].scope.get(name)
+                let def_map = self.crate_root(db).def_map(db);
+                def_map[def_map.root].scope.get(name)
             }
-            None => self[Self::ROOT].scope.get(name),
+            None => self[self.root].scope.get(name),
         };
         let from_extern_prelude = || {
-            if self.block.is_some() && module == DefMap::ROOT {
+            if self.block.is_some() && module == self.root {
                 // Don't resolve extern prelude in pseudo-module of a block.
                 return PerNs::none();
             }
@@ -770,14 +759,14 @@ impl DefMap {
     fn resolve_in_prelude(&self, db: &dyn DefDatabase, name: &Name) -> PerNs {
         if let Some((prelude, _use)) = self.prelude {
             let keep;
-            let def_map = if prelude.krate == self.krate {
+            let def_map = if prelude.krate(db) == self.krate {
                 self
             } else {
                 // Extend lifetime
                 keep = prelude.def_map(db);
                 keep
             };
-            def_map[prelude.local_id].scope.get(name)
+            def_map[prelude].scope.get(name)
         } else {
             PerNs::none()
         }
@@ -785,23 +774,23 @@ impl DefMap {
 }
 
 /// Given a block module, returns its nearest non-block module and the `DefMap` it belongs to.
+#[inline]
 fn adjust_to_nearest_non_block_module<'db>(
     db: &'db dyn DefDatabase,
-    def_map: &'db DefMap,
-    mut local_id: LocalModuleId,
-) -> (&'db DefMap, LocalModuleId) {
-    // INVARIANT: `local_id` in `def_map` must be a block module.
-    stdx::always!(def_map.module_id(local_id).is_block_module());
-
-    // This needs to be a local variable due to our mighty lifetime.
-    let mut def_map = def_map;
-    loop {
-        let BlockInfo { parent, .. } = def_map.block.expect("block module without parent module");
-
-        def_map = parent.def_map(db, def_map.krate);
-        local_id = parent.local_id;
-        if !parent.is_block_module() {
+    mut def_map: &'db DefMap,
+    mut local_id: ModuleId,
+) -> (&'db DefMap, ModuleId) {
+    if def_map.root_module_id() != local_id {
+        // if we aren't the root, we are either not a block module, or a non-block module inside a
+        // block def map.
+        return (def_map, local_id);
+    }
+    while let Some(BlockInfo { parent, .. }) = def_map.block {
+        def_map = parent.def_map(db);
+        local_id = parent;
+        if def_map.root_module_id() != local_id {
             return (def_map, local_id);
         }
     }
+    (def_map, local_id)
 }
diff --git a/crates/hir-def/src/nameres/tests/incremental.rs b/crates/hir-def/src/nameres/tests/incremental.rs
index 40283f67cc5c..57243346019f 100644
--- a/crates/hir-def/src/nameres/tests/incremental.rs
+++ b/crates/hir-def/src/nameres/tests/incremental.rs
@@ -63,7 +63,7 @@ pub const BAZ: u32 = 0;
     let all_crates_before = db.all_crates();
 
     {
-        // Add a dependency a -> b.
+        // Add dependencies: c -> b, b -> a.
         let mut new_crate_graph = CrateGraphBuilder::default();
 
         let mut add_crate = |crate_name, root_file_idx: usize| {
@@ -111,10 +111,13 @@ pub const BAZ: u32 = 0;
                 crate_def_map(&db, krate);
             }
         },
-        &[("crate_local_def_map", 1)],
+        // `c` gets invalidated as its dependency `b` changed
+        // `b` gets invalidated due to its new dependency edge to `a`
+        &[("crate_local_def_map", 2)],
         expect![[r#"
             [
                 "crate_local_def_map",
+                "crate_local_def_map",
             ]
         "#]],
     );
@@ -280,6 +283,8 @@ fn f() { foo }
                 "ast_id_map_shim",
                 "parse_shim",
                 "real_span_map_shim",
+                "crate_local_def_map",
+                "proc_macros_for_crate_shim",
                 "file_item_tree_query",
                 "ast_id_map_shim",
                 "parse_shim",
@@ -288,8 +293,6 @@ fn f() { foo }
                 "ast_id_map_shim",
                 "parse_shim",
                 "real_span_map_shim",
-                "crate_local_def_map",
-                "proc_macros_for_crate_shim",
                 "file_item_tree_query",
                 "ast_id_map_shim",
                 "parse_shim",
@@ -404,6 +407,12 @@ pub struct S {}
                 "ast_id_map_shim",
                 "parse_shim",
                 "real_span_map_shim",
+                "crate_local_def_map",
+                "proc_macros_for_crate_shim",
+                "file_item_tree_query",
+                "ast_id_map_shim",
+                "parse_shim",
+                "real_span_map_shim",
                 "decl_macro_expander_shim",
                 "file_item_tree_query",
                 "ast_id_map_shim",
@@ -424,12 +433,6 @@ pub struct S {}
                 "ast_id_map_shim",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
-                "crate_local_def_map",
-                "proc_macros_for_crate_shim",
-                "file_item_tree_query",
-                "ast_id_map_shim",
-                "parse_shim",
-                "real_span_map_shim",
                 "macro_def_shim",
                 "file_item_tree_query",
                 "ast_id_map_shim",
@@ -509,7 +512,8 @@ m!(Z);
         &db,
         || {
             let crate_def_map = crate_def_map(&db, krate);
-            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
+            let module_data = &crate_def_map
+                [crate_def_map.modules_for_file(&db, pos.file_id.file_id(&db)).next().unwrap()];
             assert_eq!(module_data.scope.resolutions().count(), 4);
         },
         &[("file_item_tree_query", 6), ("parse_macro_expansion_shim", 3)],
@@ -558,7 +562,8 @@ m!(Z);
         &db,
         || {
             let crate_def_map = crate_def_map(&db, krate);
-            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
+            let module_data = &crate_def_map
+                [crate_def_map.modules_for_file(&db, pos.file_id.file_id(&db)).next().unwrap()];
             assert_eq!(module_data.scope.resolutions().count(), 4);
         },
         &[("file_item_tree_query", 1), ("parse_macro_expansion_shim", 0)],
diff --git a/crates/hir-def/src/nameres/tests/macros.rs b/crates/hir-def/src/nameres/tests/macros.rs
index a5fd0488e785..c8eb968b3587 100644
--- a/crates/hir-def/src/nameres/tests/macros.rs
+++ b/crates/hir-def/src/nameres/tests/macros.rs
@@ -784,7 +784,7 @@ macro_rules! foo {
 
 pub use core::clone::Clone;
 "#,
-        |map| assert_eq!(map.modules[DefMap::ROOT].scope.impls().len(), 1),
+        |map| assert_eq!(map.modules[map.root].scope.impls().len(), 1),
     );
 }
 
@@ -806,7 +806,7 @@ pub macro Copy {}
 #[rustc_builtin_macro]
 pub macro Clone {}
 "#,
-        |map| assert_eq!(map.modules[DefMap::ROOT].scope.impls().len(), 2),
+        |map| assert_eq!(map.modules[map.root].scope.impls().len(), 2),
     );
 }
 
@@ -849,7 +849,7 @@ pub macro derive($item:item) {}
 #[rustc_builtin_macro]
 pub macro Clone {}
 "#,
-        |map| assert_eq!(map.modules[DefMap::ROOT].scope.impls().len(), 1),
+        |map| assert_eq!(map.modules[map.root].scope.impls().len(), 1),
     );
 }
 
@@ -1502,7 +1502,7 @@ fn proc_attr(a: TokenStream, b: TokenStream) -> TokenStream { a }
     let krate = *db.all_crates().last().expect("no crate graph present");
     let def_map = crate_def_map(&db, krate);
 
-    let root_module = &def_map[DefMap::ROOT].scope;
+    let root_module = &def_map[def_map.root].scope;
     assert!(
         root_module.legacy_macros().count() == 0,
         "`#[macro_use]` shouldn't bring macros into textual macro scope",
@@ -1609,7 +1609,7 @@ macro_rules! derive { () => {} }
 #[derive(Clone)]
 struct S;
     "#,
-        |map| assert_eq!(map.modules[DefMap::ROOT].scope.impls().len(), 1),
+        |map| assert_eq!(map.modules[map.root].scope.impls().len(), 1),
     );
 }
 
diff --git a/crates/hir-def/src/resolver.rs b/crates/hir-def/src/resolver.rs
index ccea043739c2..45d5dc9fcd27 100644
--- a/crates/hir-def/src/resolver.rs
+++ b/crates/hir-def/src/resolver.rs
@@ -16,11 +16,11 @@ use syntax::ast::HasName;
 use triomphe::Arc;
 
 use crate::{
-    AdtId, AstIdLoc, ConstId, ConstParamId, CrateRootModuleId, DefWithBodyId, EnumId,
-    EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, FxIndexMap, GenericDefId,
-    GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalModuleId, Lookup,
-    Macro2Id, MacroId, MacroRulesId, ModuleDefId, ModuleId, ProcMacroId, StaticId, StructId,
-    TraitId, TypeAliasId, TypeOrConstParamId, TypeParamId, UseId, VariantId,
+    AdtId, AstIdLoc, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId, ExternBlockId,
+    ExternCrateId, FunctionId, FxIndexMap, GenericDefId, GenericParamId, HasModule, ImplId,
+    ItemContainerId, LifetimeParamId, Lookup, Macro2Id, MacroId, MacroRulesId, ModuleDefId,
+    ModuleId, ProcMacroId, StaticId, StructId, TraitId, TypeAliasId, TypeOrConstParamId,
+    TypeParamId, UseId, VariantId,
     builtin_type::BuiltinType,
     db::DefDatabase,
     expr_store::{
@@ -55,7 +55,7 @@ pub struct Resolver<'db> {
 struct ModuleItemMap<'db> {
     def_map: &'db DefMap,
     local_def_map: &'db LocalDefMap,
-    module_id: LocalModuleId,
+    module_id: ModuleId,
 }
 
 impl fmt::Debug for ModuleItemMap<'_> {
@@ -608,14 +608,14 @@ impl<'db> Resolver<'db> {
             },
         );
         local_def_map.extern_prelude().for_each(|(name, (def, _extern_crate))| {
-            res.add(name, ScopeDef::ModuleDef(ModuleDefId::ModuleId(def.into())));
+            res.add(name, ScopeDef::ModuleDef(ModuleDefId::ModuleId(def)));
         });
         BUILTIN_SCOPE.iter().for_each(|(name, &def)| {
             res.add_per_ns(name, def);
         });
         if let Some((prelude, _use)) = def_map.prelude() {
             let prelude_def_map = prelude.def_map(db);
-            for (name, def) in prelude_def_map[prelude.local_id].scope.entries() {
+            for (name, def) in prelude_def_map[prelude].scope.entries() {
                 res.add_per_ns(name, def)
             }
         }
@@ -647,7 +647,7 @@ impl<'db> Resolver<'db> {
         self.module_scope
             .local_def_map
             .extern_prelude()
-            .map(|(name, module_id)| (name.clone(), module_id.0.into()))
+            .map(|(name, module_id)| (name.clone(), module_id.0))
     }
 
     pub fn traits_in_scope(&self, db: &dyn DefDatabase) -> FxHashSet<TraitId> {
@@ -674,7 +674,7 @@ impl<'db> Resolver<'db> {
         // Fill in the prelude traits
         if let Some((prelude, _use)) = self.module_scope.def_map.prelude() {
             let prelude_def_map = prelude.def_map(db);
-            traits.extend(prelude_def_map[prelude.local_id].scope.traits());
+            traits.extend(prelude_def_map[prelude].scope.traits());
         }
         // Fill in module visible traits
         traits.extend(self.module_scope.def_map[self.module_scope.module_id].scope.traits());
@@ -691,8 +691,7 @@ impl<'db> Resolver<'db> {
     }
 
     pub fn module(&self) -> ModuleId {
-        let (def_map, _, local_id) = self.item_scope_();
-        def_map.module_id(local_id)
+        self.item_scope_().2
     }
 
     pub fn item_scope(&self) -> &ItemScope {
@@ -882,11 +881,11 @@ impl<'db> Resolver<'db> {
             }));
             if let Some(block) = expr_scopes.block(scope_id) {
                 let def_map = block_def_map(db, block);
-                let local_def_map = block.lookup(db).module.only_local_def_map(db);
+                let local_def_map = block.module(db).only_local_def_map(db);
                 resolver.scopes.push(Scope::BlockScope(ModuleItemMap {
                     def_map,
                     local_def_map,
-                    module_id: DefMap::ROOT,
+                    module_id: def_map.root,
                 }));
                 // FIXME: This adds as many module scopes as there are blocks, but resolving in each
                 // already traverses all parents, so this is O(n²). I think we could only store the
@@ -985,7 +984,7 @@ impl<'db> Resolver<'db> {
     }
 
     /// The innermost block scope that contains items or the module scope that contains this resolver.
-    fn item_scope_(&self) -> (&DefMap, &LocalDefMap, LocalModuleId) {
+    fn item_scope_(&self) -> (&DefMap, &LocalDefMap, ModuleId) {
         self.scopes()
             .find_map(|scope| match scope {
                 Scope::BlockScope(m) => Some((m.def_map, m.local_def_map, m.module_id)),
@@ -1088,10 +1087,10 @@ fn resolver_for_scope_<'db>(
     for scope in scope_chain.into_iter().rev() {
         if let Some(block) = scopes.block(scope) {
             let def_map = block_def_map(db, block);
-            let local_def_map = block.lookup(db).module.only_local_def_map(db);
+            let local_def_map = block.module(db).only_local_def_map(db);
             // Using `DefMap::ROOT` is okay here since inside modules other than the root,
             // there can't directly be expressions.
-            r = r.push_block_scope(def_map, local_def_map, DefMap::ROOT);
+            r = r.push_block_scope(def_map, local_def_map, def_map.root);
             // FIXME: This adds as many module scopes as there are blocks, but resolving in each
             // already traverses all parents, so this is O(n²). I think we could only store the
             // innermost module scope instead?
@@ -1124,7 +1123,7 @@ impl<'db> Resolver<'db> {
         self,
         def_map: &'db DefMap,
         local_def_map: &'db LocalDefMap,
-        module_id: LocalModuleId,
+        module_id: ModuleId,
     ) -> Resolver<'db> {
         self.push_scope(Scope::BlockScope(ModuleItemMap { def_map, local_def_map, module_id }))
     }
@@ -1284,9 +1283,9 @@ pub trait HasResolver: Copy {
 impl HasResolver for ModuleId {
     fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
         let (mut def_map, local_def_map) = self.local_def_map(db);
-        let mut module_id = self.local_id;
+        let mut module_id = self;
 
-        if !self.is_within_block() {
+        if self.block(db).is_none() {
             return Resolver {
                 scopes: vec![],
                 module_scope: ModuleItemMap { def_map, local_def_map, module_id },
@@ -1296,9 +1295,9 @@ impl HasResolver for ModuleId {
         let mut modules: SmallVec<[_; 1]> = smallvec![];
         while let Some(parent) = def_map.parent() {
             let block_def_map = mem::replace(&mut def_map, parent.def_map(db));
-            let block_module_id = mem::replace(&mut module_id, parent.local_id);
+            let block_module_id = mem::replace(&mut module_id, parent);
             modules.push((block_def_map, block_module_id));
-            if !parent.is_within_block() {
+            if parent.block(db).is_none() {
                 break;
             }
         }
@@ -1313,16 +1312,6 @@ impl HasResolver for ModuleId {
     }
 }
 
-impl HasResolver for CrateRootModuleId {
-    fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
-        let (def_map, local_def_map) = self.local_def_map(db);
-        Resolver {
-            scopes: vec![],
-            module_scope: ModuleItemMap { def_map, local_def_map, module_id: DefMap::ROOT },
-        }
-    }
-}
-
 impl HasResolver for TraitId {
     fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
         lookup_resolver(db, self).push_generic_params_scope(db, self.into())
diff --git a/crates/hir-def/src/signatures.rs b/crates/hir-def/src/signatures.rs
index e8ccf56059f0..a13ef484baa5 100644
--- a/crates/hir-def/src/signatures.rs
+++ b/crates/hir-def/src/signatures.rs
@@ -860,7 +860,7 @@ fn lower_fields<Field: ast::HasAttrs + ast::HasVisibility>(
     mut field_name: impl FnMut(usize, &Field) -> Name,
     override_visibility: Option<Option<ast::Visibility>>,
 ) -> Option<(Arena<FieldData>, ExpressionStore, ExpressionStoreSourceMap)> {
-    let cfg_options = module.krate.cfg_options(db);
+    let cfg_options = module.krate(db).cfg_options(db);
     let mut col = ExprCollector::new(db, module, fields.file_id);
     let override_visibility = override_visibility.map(|vis| {
         LazyCell::new(|| {
@@ -938,7 +938,7 @@ impl EnumVariants {
         let ast_id_map = db.ast_id_map(source.file_id);
 
         let mut diagnostics = ThinVec::new();
-        let cfg_options = loc.container.krate.cfg_options(db);
+        let cfg_options = loc.container.krate(db).cfg_options(db);
         let mut index = 0;
         let Some(variants) = source.value.variant_list() else {
             return (EnumVariants { variants: Box::default() }, None);
diff --git a/crates/hir-def/src/src.rs b/crates/hir-def/src/src.rs
index 153fd195f0ad..6fe016f1e680 100644
--- a/crates/hir-def/src/src.rs
+++ b/crates/hir-def/src/src.rs
@@ -148,7 +148,7 @@ impl HasChildSource<LocalFieldId> for VariantId {
         let mut map = ArenaMap::new();
         match &src.value {
             ast::StructKind::Tuple(fl) => {
-                let cfg_options = container.krate.cfg_options(db);
+                let cfg_options = container.krate(db).cfg_options(db);
                 let mut idx = 0;
                 for fd in fl.fields() {
                     let enabled = AttrFlags::is_cfg_enabled_for(&fd, cfg_options).is_ok();
@@ -163,7 +163,7 @@ impl HasChildSource<LocalFieldId> for VariantId {
                 }
             }
             ast::StructKind::Record(fl) => {
-                let cfg_options = container.krate.cfg_options(db);
+                let cfg_options = container.krate(db).cfg_options(db);
                 let mut idx = 0;
                 for fd in fl.fields() {
                     let enabled = AttrFlags::is_cfg_enabled_for(&fd, cfg_options).is_ok();
diff --git a/crates/hir-def/src/test_db.rs b/crates/hir-def/src/test_db.rs
index 3bb9c361b3c8..cdb49b297042 100644
--- a/crates/hir-def/src/test_db.rs
+++ b/crates/hir-def/src/test_db.rs
@@ -13,7 +13,7 @@ use syntax::{AstNode, algo, ast};
 use triomphe::Arc;
 
 use crate::{
-    LocalModuleId, Lookup, ModuleDefId, ModuleId,
+    Lookup, ModuleDefId, ModuleId,
     db::DefDatabase,
     nameres::{DefMap, ModuleSource, block_def_map, crate_def_map},
     src::HasSource,
@@ -154,7 +154,7 @@ impl TestDB {
             let crate_def_map = crate_def_map(self, krate);
             for (local_id, data) in crate_def_map.modules() {
                 if data.origin.file_id().map(|file_id| file_id.file_id(self)) == Some(file_id) {
-                    return crate_def_map.module_id(local_id);
+                    return local_id;
                 }
             }
         }
@@ -168,7 +168,7 @@ impl TestDB {
 
         def_map = match self.block_at_position(def_map, position) {
             Some(it) => it,
-            None => return def_map.module_id(module),
+            None => return module,
         };
         loop {
             let new_map = self.block_at_position(def_map, position);
@@ -178,16 +178,16 @@ impl TestDB {
                 }
                 _ => {
                     // FIXME: handle `mod` inside block expression
-                    return def_map.module_id(DefMap::ROOT);
+                    return def_map.root;
                 }
             }
         }
     }
 
     /// Finds the smallest/innermost module in `def_map` containing `position`.
-    fn mod_at_position(&self, def_map: &DefMap, position: FilePosition) -> LocalModuleId {
+    fn mod_at_position(&self, def_map: &DefMap, position: FilePosition) -> ModuleId {
         let mut size = None;
-        let mut res = DefMap::ROOT;
+        let mut res = def_map.root;
         for (module, data) in def_map.modules() {
             let src = data.definition_source(self);
             // We're not comparing the `base_db::EditionedFileId`, but rather the VFS `FileId`, because
diff --git a/crates/hir-def/src/visibility.rs b/crates/hir-def/src/visibility.rs
index 948f6ed8c32b..95554c63b97d 100644
--- a/crates/hir-def/src/visibility.rs
+++ b/crates/hir-def/src/visibility.rs
@@ -9,7 +9,7 @@ use syntax::ast::{self, HasVisibility};
 use triomphe::Arc;
 
 use crate::{
-    AssocItemId, HasModule, ItemContainerId, LocalFieldId, LocalModuleId, ModuleId, TraitId,
+    AssocItemId, HasModule, ItemContainerId, LocalFieldId, ModuleId, ModuleIdLt, TraitId,
     VariantId, db::DefDatabase, nameres::DefMap, resolver::HasResolver, src::HasSource,
 };
 
@@ -41,10 +41,14 @@ impl Visibility {
     }
 
     #[tracing::instrument(skip_all)]
-    pub fn is_visible_from(self, db: &dyn DefDatabase, from_module: ModuleId) -> bool {
+    pub fn is_visible_from<'db>(
+        self,
+        db: &'db dyn DefDatabase,
+        from_module: ModuleIdLt<'db>,
+    ) -> bool {
         let to_module = match self {
-            Visibility::Module(m, _) => m,
-            Visibility::PubCrate(krate) => return from_module.krate == krate,
+            Visibility::Module(m, _) => unsafe { m.to_db(db) },
+            Visibility::PubCrate(krate) => return from_module.krate(db) == krate,
             Visibility::Public => return true,
         };
         if from_module == to_module {
@@ -52,43 +56,50 @@ impl Visibility {
             return true;
         }
         // if they're not in the same crate, it can't be visible
-        if from_module.krate != to_module.krate {
+        if from_module.krate(db) != to_module.krate(db) {
             return false;
         }
         let def_map = from_module.def_map(db);
-        Self::is_visible_from_def_map_(db, def_map, to_module, from_module.local_id)
+        Self::is_visible_from_def_map_(db, def_map, to_module, from_module)
     }
 
-    pub(crate) fn is_visible_from_def_map(
+    pub(crate) fn is_visible_from_def_map<'db>(
         self,
-        db: &dyn DefDatabase,
-        def_map: &DefMap,
-        from_module: LocalModuleId,
+        db: &'db dyn DefDatabase,
+        def_map: &'db DefMap,
+        from_module: ModuleIdLt<'db>,
     ) -> bool {
+        if cfg!(debug_assertions) {
+            _ = def_map.modules[from_module];
+        }
         let to_module = match self {
             Visibility::Module(m, _) => m,
-            Visibility::PubCrate(krate) => return def_map.krate() == krate,
+            Visibility::PubCrate(krate) => return from_module.krate(db) == krate,
             Visibility::Public => return true,
         };
+        if from_module == to_module {
+            // if the modules are the same, visibility is trivially satisfied
+            return true;
+        }
         // if they're not in the same crate, it can't be visible
-        if def_map.krate() != to_module.krate {
+        if def_map.krate() != to_module.krate(db) {
             return false;
         }
 
-        if from_module == to_module.local_id && def_map.block_id() == to_module.block {
+        if from_module == to_module && def_map.block_id() == to_module.block(db) {
             // if the modules are the same, visibility is trivially satisfied
             return true;
         }
         Self::is_visible_from_def_map_(db, def_map, to_module, from_module)
     }
 
-    fn is_visible_from_def_map_(
-        db: &dyn DefDatabase,
-        def_map: &DefMap,
-        mut to_module: ModuleId,
-        mut from_module: LocalModuleId,
+    fn is_visible_from_def_map_<'db>(
+        db: &'db dyn DefDatabase,
+        def_map: &'db DefMap,
+        mut to_module: ModuleIdLt<'db>,
+        mut from_module: ModuleIdLt<'db>,
     ) -> bool {
-        debug_assert_eq!(to_module.krate, def_map.krate());
+        debug_assert_eq!(to_module.krate(db), def_map.krate());
         // `to_module` might be the root module of a block expression. Those have the same
         // visibility as the containing module (even though no items are directly nameable from
         // there, getting this right is important for method resolution).
@@ -98,7 +109,7 @@ impl Visibility {
         // currently computing, so we must not call the `def_map` query for it.
         let def_map_block = def_map.block_id();
         loop {
-            match (to_module.block, def_map_block) {
+            match (to_module.block(db), def_map_block) {
                 // `to_module` is not a block, so there is no parent def map to use.
                 (None, _) => (),
                 // `to_module` is at `def_map`'s block, no need to move further.
@@ -117,7 +128,7 @@ impl Visibility {
         let mut def_map = def_map;
         let mut parent_arc;
         loop {
-            if def_map.module_id(from_module) == to_module {
+            if from_module == to_module {
                 return true;
             }
             match def_map[from_module].parent {
@@ -127,7 +138,7 @@ impl Visibility {
                         Some(module) => {
                             parent_arc = module.def_map(db);
                             def_map = parent_arc;
-                            from_module = module.local_id;
+                            from_module = module;
                         }
                         // Reached the root module, nothing left to check.
                         None => return false,
@@ -141,7 +152,12 @@ impl Visibility {
     ///
     /// If there is no subset relation between `self` and `other`, returns `None` (ie. they're only
     /// visible in unrelated modules).
-    pub(crate) fn max(self, other: Visibility, def_map: &DefMap) -> Option<Visibility> {
+    pub(crate) fn max(
+        self,
+        db: &dyn DefDatabase,
+        other: Visibility,
+        def_map: &DefMap,
+    ) -> Option<Visibility> {
         match (self, other) {
             (_, Visibility::Public) | (Visibility::Public, _) => Some(Visibility::Public),
             (Visibility::PubCrate(krate), Visibility::PubCrate(krateb)) => {
@@ -153,11 +169,7 @@ impl Visibility {
             }
             (Visibility::Module(mod_, _), Visibility::PubCrate(krate))
             | (Visibility::PubCrate(krate), Visibility::Module(mod_, _)) => {
-                if mod_.krate == krate {
-                    Some(Visibility::PubCrate(krate))
-                } else {
-                    None
-                }
+                if mod_.krate(db) == krate { Some(Visibility::PubCrate(krate)) } else { None }
             }
             (Visibility::Module(mod_a, expl_a), Visibility::Module(mod_b, expl_b)) => {
                 if mod_a == mod_b {
@@ -175,26 +187,24 @@ impl Visibility {
                     ));
                 }
 
-                if mod_a.krate() != def_map.krate() || mod_b.krate() != def_map.krate() {
+                if mod_a.krate(db) != def_map.krate() || mod_b.krate(db) != def_map.krate() {
                     return None;
                 }
 
                 let def_block = def_map.block_id();
-                if mod_a.containing_block() != def_block || mod_b.containing_block() != def_block {
+                if mod_a.block(db) != def_block || mod_b.block(db) != def_block {
                     return None;
                 }
 
-                let mut a_ancestors =
-                    iter::successors(Some(mod_a.local_id), |&m| def_map[m].parent);
+                let mut a_ancestors = iter::successors(Some(mod_a), |&m| def_map[m].parent);
 
-                if a_ancestors.any(|m| m == mod_b.local_id) {
+                if a_ancestors.any(|m| m == mod_b) {
                     // B is above A
                     return Some(Visibility::Module(mod_b, expl_b));
                 }
 
-                let mut b_ancestors =
-                    iter::successors(Some(mod_b.local_id), |&m| def_map[m].parent);
-                if b_ancestors.any(|m| m == mod_a.local_id) {
+                let mut b_ancestors = iter::successors(Some(mod_b), |&m| def_map[m].parent);
+                if b_ancestors.any(|m| m == mod_a) {
                     // A is above B
                     return Some(Visibility::Module(mod_a, expl_a));
                 }
@@ -208,7 +218,12 @@ impl Visibility {
     ///
     /// If there is no subset relation between `self` and `other`, returns `None` (ie. they're only
     /// visible in unrelated modules).
-    pub(crate) fn min(self, other: Visibility, def_map: &DefMap) -> Option<Visibility> {
+    pub(crate) fn min(
+        self,
+        db: &dyn DefDatabase,
+        other: Visibility,
+        def_map: &DefMap,
+    ) -> Option<Visibility> {
         match (self, other) {
             (vis, Visibility::Public) | (Visibility::Public, vis) => Some(vis),
             (Visibility::PubCrate(krate), Visibility::PubCrate(krateb)) => {
@@ -220,10 +235,10 @@ impl Visibility {
             }
             (Visibility::Module(mod_, exp), Visibility::PubCrate(krate))
             | (Visibility::PubCrate(krate), Visibility::Module(mod_, exp)) => {
-                if mod_.krate == krate { Some(Visibility::Module(mod_, exp)) } else { None }
+                if mod_.krate(db) == krate { Some(Visibility::Module(mod_, exp)) } else { None }
             }
             (Visibility::Module(mod_a, expl_a), Visibility::Module(mod_b, expl_b)) => {
-                if mod_a == mod_b {
+                if mod_a.krate(db) != mod_b.krate(db) {
                     // Most module visibilities are `pub(self)`, and assuming no errors
                     // this will be the common and thus fast path.
                     return Some(Visibility::Module(
@@ -238,26 +253,24 @@ impl Visibility {
                     ));
                 }
 
-                if mod_a.krate() != def_map.krate() || mod_b.krate() != def_map.krate() {
+                if mod_a.krate(db) != def_map.krate() || mod_b.krate(db) != def_map.krate() {
                     return None;
                 }
 
                 let def_block = def_map.block_id();
-                if mod_a.containing_block() != def_block || mod_b.containing_block() != def_block {
+                if mod_a.block(db) != def_block || mod_b.block(db) != def_block {
                     return None;
                 }
 
-                let mut a_ancestors =
-                    iter::successors(Some(mod_a.local_id), |&m| def_map[m].parent);
+                let mut a_ancestors = iter::successors(Some(mod_a), |&m| def_map[m].parent);
 
-                if a_ancestors.any(|m| m == mod_b.local_id) {
+                if a_ancestors.any(|m| m == mod_b) {
                     // B is above A
                     return Some(Visibility::Module(mod_a, expl_a));
                 }
 
-                let mut b_ancestors =
-                    iter::successors(Some(mod_b.local_id), |&m| def_map[m].parent);
-                if b_ancestors.any(|m| m == mod_a.local_id) {
+                let mut b_ancestors = iter::successors(Some(mod_b), |&m| def_map[m].parent);
+                if b_ancestors.any(|m| m == mod_a) {
                     // A is above B
                     return Some(Visibility::Module(mod_b, expl_b));
                 }
diff --git a/crates/hir-ty/src/consteval/tests.rs b/crates/hir-ty/src/consteval/tests.rs
index f25147622f06..2dc937d76031 100644
--- a/crates/hir-ty/src/consteval/tests.rs
+++ b/crates/hir-ty/src/consteval/tests.rs
@@ -126,7 +126,7 @@ fn eval_goal(db: &TestDB, file_id: EditionedFileId) -> Result<Const<'_>, ConstEv
     let interner = DbInterner::new_no_crate(db);
     let module_id = db.module_for_file(file_id.file_id(db));
     let def_map = module_id.def_map(db);
-    let scope = &def_map[module_id.local_id].scope;
+    let scope = &def_map[module_id].scope;
     let const_id = scope
         .declarations()
         .find_map(|x| match x {
diff --git a/crates/hir-ty/src/diagnostics/decl_check.rs b/crates/hir-ty/src/diagnostics/decl_check.rs
index 79dc6e367226..a6852b87f601 100644
--- a/crates/hir-ty/src/diagnostics/decl_check.rs
+++ b/crates/hir-ty/src/diagnostics/decl_check.rs
@@ -164,7 +164,7 @@ impl<'a> DeclValidator<'a> {
         else {
             return;
         };
-        let module_data = &module_id.def_map(self.db)[module_id.local_id];
+        let module_data = &module_id.def_map(self.db)[module_id];
         let Some(module_src) = module_data.declaration_source(self.db) else {
             return;
         };
diff --git a/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs b/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
index e7ee7c62b9fd..91448d5806f9 100644
--- a/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
+++ b/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
@@ -113,7 +113,7 @@ impl<'a, 'db> MatchCheckCtx<'a, 'db> {
 
     /// Returns whether the given ADT is from another crate declared `#[non_exhaustive]`.
     fn is_foreign_non_exhaustive(&self, adt: hir_def::AdtId) -> bool {
-        let is_local = adt.krate(self.db) == self.module.krate();
+        let is_local = adt.krate(self.db) == self.module.krate(self.db);
         !is_local && AttrFlags::query(self.db, adt.into()).contains(AttrFlags::NON_EXHAUSTIVE)
     }
 
diff --git a/crates/hir-ty/src/diagnostics/unsafe_check.rs b/crates/hir-ty/src/diagnostics/unsafe_check.rs
index 6160962e3bb7..bbc381ba5d51 100644
--- a/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir-ty/src/diagnostics/unsafe_check.rs
@@ -165,7 +165,7 @@ impl<'db> UnsafeVisitor<'db> {
             DefWithBodyId::FunctionId(func) => TargetFeatures::from_fn(db, func),
             _ => TargetFeatures::default(),
         };
-        let krate = resolver.module().krate();
+        let krate = resolver.krate();
         let edition = krate.data(db).edition;
         let target_feature_is_safe = match &krate.workspace_data(db).target {
             Ok(target) => target_feature_is_safe_in_target(target),
diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index 16c292273134..e1d62a9c7a3e 100644
--- a/crates/hir-ty/src/display.rs
+++ b/crates/hir-ty/src/display.rs
@@ -18,7 +18,6 @@ use hir_def::{
     item_scope::ItemInNs,
     item_tree::FieldsShape,
     lang_item::LangItems,
-    nameres::DefMap,
     signatures::VariantFields,
     type_ref::{
         ConstRef, LifetimeRef, LifetimeRefId, TraitBoundModifier, TypeBound, TypeRef, TypeRefId,
@@ -310,7 +309,7 @@ pub trait HirDisplay<'db> {
         allow_opaque: bool,
     ) -> Result<String, DisplaySourceCodeError> {
         let mut result = String::new();
-        let interner = DbInterner::new_with(db, module_id.krate());
+        let interner = DbInterner::new_with(db, module_id.krate(db));
         match self.hir_fmt(&mut HirFormatter {
             db,
             interner,
@@ -321,7 +320,7 @@ pub trait HirDisplay<'db> {
             entity_limit: None,
             omit_verbose_types: false,
             closure_style: ClosureStyle::ImplFn,
-            display_target: DisplayTarget::from_crate(db, module_id.krate()),
+            display_target: DisplayTarget::from_crate(db, module_id.krate(db)),
             display_kind: DisplayKind::SourceCode { target_module_id: module_id, allow_opaque },
             show_container_bounds: false,
             display_lifetimes: DisplayLifetime::OnlyNamedOrStatic,
@@ -1516,7 +1515,7 @@ impl<'db> HirDisplay<'db> for Ty<'db> {
                                     _ => false,
                                 })
                                 .collect::<Vec<_>>();
-                            let krate = param.id.parent().module(db).krate();
+                            let krate = param.id.parent().module(db).krate(db);
                             write_bounds_like_dyn_trait_with_prefix(
                                 f,
                                 "impl",
@@ -2031,13 +2030,14 @@ pub fn write_visibility<'db>(
         Visibility::PubCrate(_) => write!(f, "pub(crate) "),
         Visibility::Module(vis_id, _) => {
             let def_map = module_id.def_map(f.db);
-            let root_module_id = def_map.module_id(DefMap::ROOT);
+            let root_module_id = def_map.root_module_id();
             if vis_id == module_id {
                 // pub(self) or omitted
                 Ok(())
-            } else if root_module_id == vis_id && !root_module_id.is_within_block() {
+            } else if root_module_id == vis_id && root_module_id.block(f.db).is_none() {
                 write!(f, "pub(crate) ")
-            } else if module_id.containing_module(f.db) == Some(vis_id) && !vis_id.is_block_module()
+            } else if module_id.containing_module(f.db) == Some(vis_id)
+                && !vis_id.is_block_module(f.db)
             {
                 write!(f, "pub(super) ")
             } else {
diff --git a/crates/hir-ty/src/drop.rs b/crates/hir-ty/src/drop.rs
index def3c44927a1..3ae6451d6952 100644
--- a/crates/hir-ty/src/drop.rs
+++ b/crates/hir-ty/src/drop.rs
@@ -25,12 +25,12 @@ fn has_destructor(interner: DbInterner<'_>, adt: AdtId) -> bool {
     let Some(drop_trait) = interner.lang_items().Drop else {
         return false;
     };
-    let impls = match module.containing_block() {
+    let impls = match module.block(db) {
         Some(block) => match TraitImpls::for_block(db, block) {
             Some(it) => &**it,
             None => return false,
         },
-        None => TraitImpls::for_crate(db, module.krate()),
+        None => TraitImpls::for_crate(db, module.krate(db)),
     };
     !impls.for_trait_and_self_ty(drop_trait, &SimplifiedType::Adt(adt.into())).is_empty()
 }
diff --git a/crates/hir-ty/src/dyn_compatibility.rs b/crates/hir-ty/src/dyn_compatibility.rs
index 4c1590a4502e..506c4abc8377 100644
--- a/crates/hir-ty/src/dyn_compatibility.rs
+++ b/crates/hir-ty/src/dyn_compatibility.rs
@@ -3,9 +3,9 @@
 use std::ops::ControlFlow;
 
 use hir_def::{
-    AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,
-    TypeAliasId, TypeOrConstParamId, TypeParamId, hir::generics::LocalTypeOrConstParamId,
-    signatures::TraitFlags,
+    AssocItemId, ConstId, FunctionId, GenericDefId, HasModule, TraitId, TypeAliasId,
+    TypeOrConstParamId, TypeParamId, hir::generics::LocalTypeOrConstParamId,
+    nameres::crate_def_map, signatures::TraitFlags,
 };
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
@@ -130,7 +130,7 @@ pub fn dyn_compatibility_of_trait_query(
 }
 
 pub fn generics_require_sized_self(db: &dyn HirDatabase, def: GenericDefId) -> bool {
-    let krate = def.module(db).krate();
+    let krate = def.module(db).krate(db);
     let interner = DbInterner::new_with(db, krate);
     let Some(sized) = interner.lang_items().Sized else {
         return false;
@@ -295,7 +295,7 @@ where
             })
         }
         AssocItemId::TypeAliasId(it) => {
-            let def_map = CrateRootModuleId::from(trait_.krate(db)).def_map(db);
+            let def_map = crate_def_map(db, trait_.krate(db));
             if def_map.is_unstable_feature_enabled(&intern::sym::generic_associated_type_extended) {
                 ControlFlow::Continue(())
             } else {
@@ -402,7 +402,7 @@ fn receiver_is_dispatchable<'db>(
     let sig = sig.instantiate_identity();
 
     let module = trait_.module(db);
-    let interner = DbInterner::new_with(db, module.krate());
+    let interner = DbInterner::new_with(db, module.krate(db));
     let self_param_id = TypeParamId::from_unchecked(TypeOrConstParamId {
         parent: trait_.into(),
         local_id: LocalTypeOrConstParamId::from_raw(la_arena::RawIdx::from_u32(0)),
diff --git a/crates/hir-ty/src/dyn_compatibility/tests.rs b/crates/hir-ty/src/dyn_compatibility/tests.rs
index f90cd608e997..5c9b06e39a70 100644
--- a/crates/hir-ty/src/dyn_compatibility/tests.rs
+++ b/crates/hir-ty/src/dyn_compatibility/tests.rs
@@ -35,7 +35,7 @@ fn check_dyn_compatibility<'a>(
     for (trait_id, name) in file_ids.into_iter().flat_map(|file_id| {
         let module_id = db.module_for_file(file_id.file_id(&db));
         let def_map = module_id.def_map(&db);
-        let scope = &def_map[module_id.local_id].scope;
+        let scope = &def_map[module_id].scope;
         scope
             .declarations()
             .filter_map(|def| {
diff --git a/crates/hir-ty/src/infer.rs b/crates/hir-ty/src/infer.rs
index cafe0329692c..70868e4b95aa 100644
--- a/crates/hir-ty/src/infer.rs
+++ b/crates/hir-ty/src/infer.rs
@@ -653,19 +653,16 @@ impl<'db> InferenceResult<'db> {
     }
     pub fn type_of_expr_with_adjust(&self, id: ExprId) -> Option<Ty<'db>> {
         match self.expr_adjustments.get(&id).and_then(|adjustments| {
-            adjustments
-                .iter()
-                .filter(|adj| {
-                    // https://github.com/rust-lang/rust/blob/67819923ac8ea353aaa775303f4c3aacbf41d010/compiler/rustc_mir_build/src/thir/cx/expr.rs#L140
-                    !matches!(
-                        adj,
-                        Adjustment {
-                            kind: Adjust::NeverToAny,
-                            target,
-                        } if target.is_never()
-                    )
-                })
-                .next_back()
+            adjustments.iter().rfind(|adj| {
+                // https://github.com/rust-lang/rust/blob/67819923ac8ea353aaa775303f4c3aacbf41d010/compiler/rustc_mir_build/src/thir/cx/expr.rs#L140
+                !matches!(
+                    adj,
+                    Adjustment {
+                        kind: Adjust::NeverToAny,
+                        target,
+                    } if target.is_never()
+                )
+            })
         }) {
             Some(adjustment) => Some(adjustment.target),
             None => self.type_of_expr.get(id).copied(),
diff --git a/crates/hir-ty/src/infer/closure/analysis.rs b/crates/hir-ty/src/infer/closure/analysis.rs
index 251e7f7cf6b8..d6d63891bb06 100644
--- a/crates/hir-ty/src/infer/closure/analysis.rs
+++ b/crates/hir-ty/src/infer/closure/analysis.rs
@@ -47,7 +47,7 @@ impl<'db> HirPlace<'db> {
                 |_, _, _| {
                     unreachable!("Closure field only happens in MIR");
                 },
-                ctx.owner.module(ctx.db).krate(),
+                ctx.owner.module(ctx.db).krate(ctx.db),
             );
         }
         ty
@@ -149,7 +149,7 @@ impl<'db> CapturedItem<'db> {
                 }
             }
         }
-        if is_raw_identifier(&result, owner.module(db).krate().data(db).edition) {
+        if is_raw_identifier(&result, owner.module(db).krate(db).data(db).edition) {
             result.insert_str(0, "r#");
         }
         result
@@ -843,7 +843,7 @@ impl<'db> InferenceContext<'_, 'db> {
                     |_, _, _| {
                         unreachable!("Closure field only happens in MIR");
                     },
-                    self.owner.module(self.db).krate(),
+                    self.owner.module(self.db).krate(self.db),
                 );
                 if ty.is_raw_ptr() || ty.is_union() {
                     capture.kind = CaptureKind::ByRef(BorrowKind::Shared);
diff --git a/crates/hir-ty/src/layout/tests.rs b/crates/hir-ty/src/layout/tests.rs
index 43215253ba16..be6a76478a11 100644
--- a/crates/hir-ty/src/layout/tests.rs
+++ b/crates/hir-ty/src/layout/tests.rs
@@ -45,7 +45,7 @@ fn eval_goal(
         .find_map(|file_id| {
             let module_id = db.module_for_file(file_id.file_id(&db));
             let def_map = module_id.def_map(&db);
-            let scope = &def_map[module_id.local_id].scope;
+            let scope = &def_map[module_id].scope;
             let adt_or_type_alias_id = scope.declarations().find_map(|x| match x {
                 hir_def::ModuleDefId::AdtId(x) => {
                     let name = match x {
@@ -118,7 +118,7 @@ fn eval_expr(
     crate::attach_db(&db, || {
         let module_id = db.module_for_file(file_id.file_id(&db));
         let def_map = module_id.def_map(&db);
-        let scope = &def_map[module_id.local_id].scope;
+        let scope = &def_map[module_id].scope;
         let function_id = scope
             .declarations()
             .find_map(|x| match x {
diff --git a/crates/hir-ty/src/lower.rs b/crates/hir-ty/src/lower.rs
index 301e89556df2..dd34bbe2fd02 100644
--- a/crates/hir-ty/src/lower.rs
+++ b/crates/hir-ty/src/lower.rs
@@ -1755,13 +1755,12 @@ pub(crate) fn trait_environment_query<'db>(
     def: GenericDefId,
 ) -> ParamEnv<'db> {
     let module = def.module(db);
-    let interner = DbInterner::new_with(db, module.krate());
+    let interner = DbInterner::new_with(db, module.krate(db));
     let predicates = GenericPredicates::query_all(db, def);
     let clauses = rustc_type_ir::elaborate::elaborate(interner, predicates.iter_identity_copied());
     let clauses = Clauses::new_from_iter(interner, clauses);
 
     // FIXME: We should normalize projections here, like rustc does.
-
     ParamEnv { clauses }
 }
 
@@ -2280,7 +2279,7 @@ pub(crate) fn associated_type_by_name_including_super_traits<'db>(
     name: &Name,
 ) -> Option<(TraitRef<'db>, TypeAliasId)> {
     let module = trait_ref.def_id.0.module(db);
-    let interner = DbInterner::new_with(db, module.krate());
+    let interner = DbInterner::new_with(db, module.krate(db));
     rustc_type_ir::elaborate::supertraits(interner, Binder::dummy(trait_ref)).find_map(|t| {
         let trait_id = t.as_ref().skip_binder().def_id.0;
         let assoc_type = trait_id.trait_items(db).associated_type_by_name(name)?;
diff --git a/crates/hir-ty/src/method_resolution.rs b/crates/hir-ty/src/method_resolution.rs
index a5ec2a3fec66..d9cfe6d84c2b 100644
--- a/crates/hir-ty/src/method_resolution.rs
+++ b/crates/hir-ty/src/method_resolution.rs
@@ -13,8 +13,8 @@ use tracing::{debug, instrument};
 
 use base_db::Crate;
 use hir_def::{
-    AssocItemId, BlockId, ConstId, FunctionId, GenericParamId, HasModule, ImplId, ItemContainerId,
-    ModuleId, TraitId,
+    AssocItemId, BlockIdLt, ConstId, FunctionId, GenericParamId, HasModule, ImplId,
+    ItemContainerId, ModuleId, TraitId,
     attrs::AttrFlags,
     expr_store::path::GenericArgs as HirGenericArgs,
     hir::ExprId,
@@ -558,9 +558,9 @@ pub struct InherentImpls {
 }
 
 #[salsa::tracked]
-impl InherentImpls {
+impl<'db> InherentImpls {
     #[salsa::tracked(returns(ref))]
-    pub fn for_crate(db: &dyn HirDatabase, krate: Crate) -> Self {
+    pub fn for_crate(db: &'db dyn HirDatabase, krate: Crate) -> Self {
         let _p = tracing::info_span!("inherent_impls_in_crate_query", ?krate).entered();
 
         let crate_def_map = crate_def_map(db, krate);
@@ -569,7 +569,7 @@ impl InherentImpls {
     }
 
     #[salsa::tracked(returns(ref))]
-    pub fn for_block(db: &dyn HirDatabase, block: BlockId) -> Option<Box<Self>> {
+    pub fn for_block(db: &'db dyn HirDatabase, block: BlockIdLt<'db>) -> Option<Box<Self>> {
         let _p = tracing::info_span!("inherent_impls_in_block_query").entered();
 
         let block_def_map = block_def_map(db, block);
@@ -627,13 +627,13 @@ impl InherentImpls {
         self.map.get(self_ty).map(|it| &**it).unwrap_or_default()
     }
 
-    pub fn for_each_crate_and_block(
-        db: &dyn HirDatabase,
+    pub fn for_each_crate_and_block<'db>(
+        db: &'db dyn HirDatabase,
         krate: Crate,
-        block: Option<BlockId>,
+        block: Option<BlockIdLt<'db>>,
         for_each: &mut dyn FnMut(&InherentImpls),
     ) {
-        let blocks = std::iter::successors(block, |block| block.loc(db).module.containing_block());
+        let blocks = std::iter::successors(block, |block| block.module(db).block(db));
         blocks.filter_map(|block| Self::for_block(db, block).as_deref()).for_each(&mut *for_each);
         for_each(Self::for_crate(db, krate));
     }
@@ -670,9 +670,9 @@ pub struct TraitImpls {
 }
 
 #[salsa::tracked]
-impl TraitImpls {
+impl<'db> TraitImpls {
     #[salsa::tracked(returns(ref))]
-    pub fn for_crate(db: &dyn HirDatabase, krate: Crate) -> Arc<Self> {
+    pub fn for_crate(db: &'db dyn HirDatabase, krate: Crate) -> Arc<Self> {
         let _p = tracing::info_span!("inherent_impls_in_crate_query", ?krate).entered();
 
         let crate_def_map = crate_def_map(db, krate);
@@ -681,7 +681,7 @@ impl TraitImpls {
     }
 
     #[salsa::tracked(returns(ref))]
-    pub fn for_block(db: &dyn HirDatabase, block: BlockId) -> Option<Box<Self>> {
+    pub fn for_block(db: &'db dyn HirDatabase, block: BlockIdLt<'db>) -> Option<Box<Self>> {
         let _p = tracing::info_span!("inherent_impls_in_block_query").entered();
 
         let block_def_map = block_def_map(db, block);
@@ -690,7 +690,7 @@ impl TraitImpls {
     }
 
     #[salsa::tracked(returns(ref))]
-    pub fn for_crate_and_deps(db: &dyn HirDatabase, krate: Crate) -> Box<[Arc<Self>]> {
+    pub fn for_crate_and_deps(db: &'db dyn HirDatabase, krate: Crate) -> Box<[Arc<Self>]> {
         krate.transitive_deps(db).iter().map(|&dep| Self::for_crate(db, dep).clone()).collect()
     }
 }
@@ -792,23 +792,23 @@ impl TraitImpls {
         }
     }
 
-    pub fn for_each_crate_and_block(
-        db: &dyn HirDatabase,
+    pub fn for_each_crate_and_block<'db>(
+        db: &'db dyn HirDatabase,
         krate: Crate,
-        block: Option<BlockId>,
+        block: Option<BlockIdLt<'db>>,
         for_each: &mut dyn FnMut(&TraitImpls),
     ) {
-        let blocks = std::iter::successors(block, |block| block.loc(db).module.containing_block());
+        let blocks = std::iter::successors(block, |block| block.module(db).block(db));
         blocks.filter_map(|block| Self::for_block(db, block).as_deref()).for_each(&mut *for_each);
         Self::for_crate_and_deps(db, krate).iter().map(|it| &**it).for_each(for_each);
     }
 
     /// Like [`Self::for_each_crate_and_block()`], but takes in account two blocks, one for a trait and one for a self type.
-    pub fn for_each_crate_and_block_trait_and_type(
-        db: &dyn HirDatabase,
+    pub fn for_each_crate_and_block_trait_and_type<'db>(
+        db: &'db dyn HirDatabase,
         krate: Crate,
-        type_block: Option<BlockId>,
-        trait_block: Option<BlockId>,
+        type_block: Option<BlockIdLt<'db>>,
+        trait_block: Option<BlockIdLt<'db>>,
         for_each: &mut dyn FnMut(&TraitImpls),
     ) {
         let in_self_and_deps = TraitImpls::for_crate_and_deps(db, krate);
@@ -819,10 +819,11 @@ impl TraitImpls {
         // that means there can't be duplicate impls; if they meet, we stop the search of the deeper block.
         // This breaks when they are equal (both will stop immediately), therefore we handle this case
         // specifically.
-        let blocks_iter = |block: Option<BlockId>| {
-            std::iter::successors(block, |block| block.loc(db).module.containing_block())
+        let blocks_iter = |block: Option<BlockIdLt<'db>>| {
+            std::iter::successors(block, |block| block.module(db).block(db))
         };
-        let for_each_block = |current_block: Option<BlockId>, other_block: Option<BlockId>| {
+        let for_each_block = |current_block: Option<BlockIdLt<'db>>,
+                              other_block: Option<BlockIdLt<'db>>| {
             blocks_iter(current_block)
                 .take_while(move |&block| {
                     other_block.is_none_or(|other_block| other_block != block)
diff --git a/crates/hir-ty/src/method_resolution/probe.rs b/crates/hir-ty/src/method_resolution/probe.rs
index 02f86815edd2..6af47ab68bfc 100644
--- a/crates/hir-ty/src/method_resolution/probe.rs
+++ b/crates/hir-ty/src/method_resolution/probe.rs
@@ -980,8 +980,8 @@ impl<'a, 'db, Choice: ProbeChoice<'db>> ProbeContext<'a, 'db, Choice> {
         };
         InherentImpls::for_each_crate_and_block(
             self.db(),
-            module.krate(),
-            module.containing_block(),
+            module.krate(self.db()),
+            module.block(self.db()),
             &mut |impls| {
                 for &impl_def_id in impls.for_self_ty(self_ty) {
                     self.assemble_inherent_impl_probe(impl_def_id, receiver_steps);
diff --git a/crates/hir-ty/src/mir/borrowck.rs b/crates/hir-ty/src/mir/borrowck.rs
index 031654a25984..4d76a9f3fb3d 100644
--- a/crates/hir-ty/src/mir/borrowck.rs
+++ b/crates/hir-ty/src/mir/borrowck.rs
@@ -97,7 +97,7 @@ pub fn borrowck_query<'db>(
 ) -> Result<Arc<[BorrowckResult<'db>]>, MirLowerError<'db>> {
     let _p = tracing::info_span!("borrowck_query").entered();
     let module = def.module(db);
-    let interner = DbInterner::new_with(db, module.krate());
+    let interner = DbInterner::new_with(db, module.krate(db));
     let env = db.trait_environment_for_body(def);
     let mut res = vec![];
     // This calculates opaques defining scope which is a bit costly therefore is put outside `all_mir_bodies()`.
@@ -148,7 +148,7 @@ fn moved_out_of_ref<'db>(
                     infcx,
                     ty,
                     make_fetch_closure_field(db),
-                    body.owner.module(db).krate(),
+                    body.owner.module(db).krate(db),
                 );
             }
             if is_dereference_of_ref
@@ -244,7 +244,7 @@ fn partially_moved<'db>(
                     infcx,
                     ty,
                     make_fetch_closure_field(db),
-                    body.owner.module(db).krate(),
+                    body.owner.module(db).krate(db),
                 );
             }
             if !infcx.type_is_copy_modulo_regions(env, ty) && !ty.references_non_lt_error() {
@@ -397,7 +397,7 @@ fn place_case<'db>(
             infcx,
             ty,
             make_fetch_closure_field(db),
-            body.owner.module(db).krate(),
+            body.owner.module(db).krate(db),
         );
     }
     if is_part_of { ProjectionCase::DirectPart } else { ProjectionCase::Direct }
diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs
index 02e322f03781..35b45174c209 100644
--- a/crates/hir-ty/src/mir/eval.rs
+++ b/crates/hir-ty/src/mir/eval.rs
@@ -635,7 +635,7 @@ impl<'db> Evaluator<'db> {
         trait_env: Option<ParamEnvAndCrate<'db>>,
     ) -> Result<'db, Evaluator<'db>> {
         let module = owner.module(db);
-        let crate_id = module.krate();
+        let crate_id = module.krate(db);
         let target_data_layout = match db.target_data_layout(crate_id) {
             Ok(target_data_layout) => target_data_layout,
             Err(e) => return Err(MirEvalError::TargetDataLayoutNotAvailable(e)),
diff --git a/crates/hir-ty/src/mir/eval/tests.rs b/crates/hir-ty/src/mir/eval/tests.rs
index 2c0c3427cbde..c13b76c12579 100644
--- a/crates/hir-ty/src/mir/eval/tests.rs
+++ b/crates/hir-ty/src/mir/eval/tests.rs
@@ -20,7 +20,7 @@ fn eval_main(db: &TestDB, file_id: EditionedFileId) -> Result<(String, String),
         let interner = DbInterner::new_no_crate(db);
         let module_id = db.module_for_file(file_id.file_id(db));
         let def_map = module_id.def_map(db);
-        let scope = &def_map[module_id.local_id].scope;
+        let scope = &def_map[module_id].scope;
         let func_id = scope
             .declarations()
             .find_map(|x| match x {
@@ -90,7 +90,7 @@ fn check_pass_and_stdio(
                         line_index(range.end())
                     )
                 };
-                let krate = db.module_for_file(file_id.file_id(&db)).krate();
+                let krate = db.module_for_file(file_id.file_id(&db)).krate(&db);
                 e.pretty_print(
                     &mut err,
                     &db,
diff --git a/crates/hir-ty/src/mir/lower/tests.rs b/crates/hir-ty/src/mir/lower/tests.rs
index 38fc7ad78a28..357f617a21e1 100644
--- a/crates/hir-ty/src/mir/lower/tests.rs
+++ b/crates/hir-ty/src/mir/lower/tests.rs
@@ -9,7 +9,7 @@ fn lower_mir(#[rust_analyzer::rust_fixture] ra_fixture: &str) {
         let file_id = *file_ids.last().unwrap();
         let module_id = db.module_for_file(file_id.file_id(&db));
         let def_map = module_id.def_map(&db);
-        let scope = &def_map[module_id.local_id].scope;
+        let scope = &def_map[module_id].scope;
         let funcs = scope.declarations().filter_map(|x| match x {
             hir_def::ModuleDefId::FunctionId(it) => Some(it),
             _ => None,
diff --git a/crates/hir-ty/src/next_solver/interner.rs b/crates/hir-ty/src/next_solver/interner.rs
index 2e52dcea6c5b..2541ed43ec38 100644
--- a/crates/hir-ty/src/next_solver/interner.rs
+++ b/crates/hir-ty/src/next_solver/interner.rs
@@ -1694,7 +1694,7 @@ impl<'db> Interner for DbInterner<'db> {
         mut f: impl FnMut(Self::ImplId),
     ) {
         let krate = self.krate.expect("trait solving requires setting `DbInterner::krate`");
-        let trait_block = trait_def_id.0.loc(self.db).container.containing_block();
+        let trait_block = trait_def_id.0.loc(self.db).container.block(self.db);
         let mut consider_impls_for_simplified_type = |simp: SimplifiedType| {
             let type_block = simp.def().and_then(|def_id| {
                 let module = match def_id {
@@ -1713,7 +1713,7 @@ impl<'db> Interner for DbInterner<'db> {
                     | SolverDefId::EnumVariantId(_)
                     | SolverDefId::Ctor(_) => return None,
                 };
-                module.containing_block()
+                module.block(self.db)
             });
             TraitImpls::for_each_crate_and_block_trait_and_type(
                 self.db,
@@ -1828,7 +1828,7 @@ impl<'db> Interner for DbInterner<'db> {
 
     fn for_each_blanket_impl(self, trait_def_id: Self::TraitId, mut f: impl FnMut(Self::ImplId)) {
         let Some(krate) = self.krate else { return };
-        let block = trait_def_id.0.loc(self.db).container.containing_block();
+        let block = trait_def_id.0.loc(self.db).container.block(self.db);
 
         TraitImpls::for_each_crate_and_block(self.db, krate, block, &mut |impls| {
             for &impl_ in impls.blanket_impls(trait_def_id.0) {
diff --git a/crates/hir-ty/src/next_solver/ty.rs b/crates/hir-ty/src/next_solver/ty.rs
index c0a7c9adc485..ff89f8e059a5 100644
--- a/crates/hir-ty/src/next_solver/ty.rs
+++ b/crates/hir-ty/src/next_solver/ty.rs
@@ -656,7 +656,7 @@ impl<'db> Ty<'db> {
             }
             TyKind::Coroutine(coroutine_id, _args) => {
                 let InternedCoroutine(owner, _) = coroutine_id.0.loc(db);
-                let krate = owner.module(db).krate();
+                let krate = owner.module(db).krate(db);
                 if let Some(future_trait) = hir_def::lang_item::lang_items(db, krate).Future {
                     // This is only used by type walking.
                     // Parameters will be walked outside, and projection predicate is not used.
diff --git a/crates/hir-ty/src/opaques.rs b/crates/hir-ty/src/opaques.rs
index dbac20074b28..4c6b585016fa 100644
--- a/crates/hir-ty/src/opaques.rs
+++ b/crates/hir-ty/src/opaques.rs
@@ -118,7 +118,7 @@ pub(crate) fn tait_hidden_types<'db>(
 
     let loc = type_alias.loc(db);
     let module = loc.module(db);
-    let interner = DbInterner::new_with(db, module.krate());
+    let interner = DbInterner::new_with(db, module.krate(db));
     let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());
     let mut ocx = ObligationCtxt::new(&infcx);
     let cause = ObligationCause::dummy();
diff --git a/crates/hir-ty/src/specialization.rs b/crates/hir-ty/src/specialization.rs
index 495a9937f6c9..9ae9a8e2a993 100644
--- a/crates/hir-ty/src/specialization.rs
+++ b/crates/hir-ty/src/specialization.rs
@@ -148,7 +148,7 @@ pub(crate) fn specializes(
     // `#[allow_internal_unstable(specialization)]`, but `#[allow_internal_unstable]`
     // is an internal feature, std is not using it for specialization nor is likely to
     // ever use it, and we don't have the span information necessary to replicate that.
-    let def_map = crate_def_map(db, module.krate());
+    let def_map = crate_def_map(db, module.krate(db));
     if !def_map.is_unstable_feature_enabled(&sym::specialization)
         && !def_map.is_unstable_feature_enabled(&sym::min_specialization)
     {
diff --git a/crates/hir-ty/src/test_db.rs b/crates/hir-ty/src/test_db.rs
index 7044ca5d23ae..7bd314cb8e39 100644
--- a/crates/hir-ty/src/test_db.rs
+++ b/crates/hir-ty/src/test_db.rs
@@ -138,9 +138,9 @@ impl TestDB {
         let file_id = file_id.into();
         for &krate in self.relevant_crates(file_id).iter() {
             let crate_def_map = crate_def_map(self, krate);
-            for (local_id, data) in crate_def_map.modules() {
+            for (module_id, data) in crate_def_map.modules() {
                 if data.origin.file_id().map(|file_id| file_id.file_id(self)) == Some(file_id) {
-                    return Some(crate_def_map.module_id(local_id));
+                    return Some(module_id);
                 }
             }
         }
diff --git a/crates/hir-ty/src/tests.rs b/crates/hir-ty/src/tests.rs
index 1acb0b82b146..a31353f1e336 100644
--- a/crates/hir-ty/src/tests.rs
+++ b/crates/hir-ty/src/tests.rs
@@ -16,7 +16,7 @@ mod traits;
 use base_db::{Crate, SourceDatabase};
 use expect_test::Expect;
 use hir_def::{
-    AssocItemId, DefWithBodyId, HasModule, LocalModuleId, Lookup, ModuleDefId, SyntheticSyntax,
+    AssocItemId, DefWithBodyId, HasModule, Lookup, ModuleDefId, ModuleId, SyntheticSyntax,
     db::DefDatabase,
     expr_store::{Body, BodySourceMap},
     hir::{ExprId, Pat, PatId},
@@ -114,7 +114,7 @@ fn check_impl(
                 None => continue,
             };
             let def_map = module.def_map(&db);
-            visit_module(&db, def_map, module.local_id, &mut |it| {
+            visit_module(&db, def_map, module, &mut |it| {
                 let def = match it {
                     ModuleDefId::FunctionId(it) => it.into(),
                     ModuleDefId::EnumVariantId(it) => it.into(),
@@ -122,7 +122,7 @@ fn check_impl(
                     ModuleDefId::StaticId(it) => it.into(),
                     _ => return,
                 };
-                defs.push((def, module.krate()))
+                defs.push((def, module.krate(&db)))
             });
         }
         defs.sort_by_key(|(def, _)| match def {
@@ -412,7 +412,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
         let def_map = module.def_map(&db);
 
         let mut defs: Vec<(DefWithBodyId, Crate)> = Vec::new();
-        visit_module(&db, def_map, module.local_id, &mut |it| {
+        visit_module(&db, def_map, module, &mut |it| {
             let def = match it {
                 ModuleDefId::FunctionId(it) => it.into(),
                 ModuleDefId::EnumVariantId(it) => it.into(),
@@ -420,7 +420,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
                 ModuleDefId::StaticId(it) => it.into(),
                 _ => return,
             };
-            defs.push((def, module.krate()))
+            defs.push((def, module.krate(&db)))
         });
         defs.sort_by_key(|(def, _)| match def {
             DefWithBodyId::FunctionId(it) => {
@@ -454,7 +454,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
 pub(crate) fn visit_module(
     db: &TestDB,
     crate_def_map: &DefMap,
-    module_id: LocalModuleId,
+    module_id: ModuleId,
     cb: &mut dyn FnMut(ModuleDefId),
 ) {
     visit_scope(db, crate_def_map, &crate_def_map[module_id].scope, cb);
@@ -517,7 +517,7 @@ pub(crate) fn visit_module(
                         }
                     }
                 }
-                ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it.local_id, cb),
+                ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it, cb),
                 _ => (),
             }
         }
@@ -593,7 +593,7 @@ fn salsa_bug() {
     crate::attach_db(&db, || {
         let module = db.module_for_file(pos.file_id.file_id(&db));
         let crate_def_map = module.def_map(&db);
-        visit_module(&db, crate_def_map, module.local_id, &mut |def| {
+        visit_module(&db, crate_def_map, module, &mut |def| {
             InferenceResult::for_body(
                 &db,
                 match def {
@@ -637,7 +637,7 @@ fn salsa_bug() {
     crate::attach_db(&db, || {
         let module = db.module_for_file(pos.file_id.file_id(&db));
         let crate_def_map = module.def_map(&db);
-        visit_module(&db, crate_def_map, module.local_id, &mut |def| {
+        visit_module(&db, crate_def_map, module, &mut |def| {
             InferenceResult::for_body(
                 &db,
                 match def {
diff --git a/crates/hir-ty/src/tests/closure_captures.rs b/crates/hir-ty/src/tests/closure_captures.rs
index ef71681636ef..ff55ff54cefb 100644
--- a/crates/hir-ty/src/tests/closure_captures.rs
+++ b/crates/hir-ty/src/tests/closure_captures.rs
@@ -24,7 +24,7 @@ fn check_closure_captures(#[rust_analyzer::rust_fixture] ra_fixture: &str, expec
         let def_map = module.def_map(&db);
 
         let mut defs = Vec::new();
-        visit_module(&db, def_map, module.local_id, &mut |it| defs.push(it));
+        visit_module(&db, def_map, module, &mut |it| defs.push(it));
 
         let mut captures_info = Vec::new();
         for def in defs {
@@ -75,7 +75,7 @@ fn check_closure_captures(#[rust_analyzer::rust_fixture] ra_fixture: &str, expec
                         let capture_ty = capture
                             .ty
                             .skip_binder()
-                            .display_test(db, DisplayTarget::from_crate(db, module.krate()))
+                            .display_test(db, DisplayTarget::from_crate(db, module.krate(db)))
                             .to_string();
                         let spans = capture
                             .spans()
diff --git a/crates/hir-ty/src/tests/incremental.rs b/crates/hir-ty/src/tests/incremental.rs
index fd564a300dce..7b0c1d35442e 100644
--- a/crates/hir-ty/src/tests/incremental.rs
+++ b/crates/hir-ty/src/tests/incremental.rs
@@ -22,7 +22,7 @@ fn foo() -> i32 {
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let crate_def_map = module.def_map(&db);
-            visit_module(&db, crate_def_map, module.local_id, &mut |def| {
+            visit_module(&db, crate_def_map, module, &mut |def| {
                 if let ModuleDefId::FunctionId(it) = def {
                     InferenceResult::for_body(&db, it.into());
                 }
@@ -66,7 +66,7 @@ fn foo() -> i32 {
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let crate_def_map = module.def_map(&db);
-            visit_module(&db, crate_def_map, module.local_id, &mut |def| {
+            visit_module(&db, crate_def_map, module, &mut |def| {
                 if let ModuleDefId::FunctionId(it) = def {
                     InferenceResult::for_body(&db, it.into());
                 }
@@ -109,7 +109,7 @@ fn baz() -> i32 {
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let crate_def_map = module.def_map(&db);
-            visit_module(&db, crate_def_map, module.local_id, &mut |def| {
+            visit_module(&db, crate_def_map, module, &mut |def| {
                 if let ModuleDefId::FunctionId(it) = def {
                     InferenceResult::for_body(&db, it.into());
                 }
@@ -178,7 +178,7 @@ fn baz() -> i32 {
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let crate_def_map = module.def_map(&db);
-            visit_module(&db, crate_def_map, module.local_id, &mut |def| {
+            visit_module(&db, crate_def_map, module, &mut |def| {
                 if let ModuleDefId::FunctionId(it) = def {
                     InferenceResult::for_body(&db, it.into());
                 }
@@ -232,7 +232,7 @@ $0",
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let _crate_def_map = module.def_map(&db);
-            TraitImpls::for_crate(&db, module.krate());
+            TraitImpls::for_crate(&db, module.krate(&db));
         },
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
@@ -268,7 +268,7 @@ pub struct NewStruct {
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let _crate_def_map = module.def_map(&db);
-            TraitImpls::for_crate(&db, module.krate());
+            TraitImpls::for_crate(&db, module.krate(&db));
         },
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
@@ -303,7 +303,7 @@ $0",
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let _crate_def_map = module.def_map(&db);
-            TraitImpls::for_crate(&db, module.krate());
+            TraitImpls::for_crate(&db, module.krate(&db));
         },
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
@@ -340,7 +340,7 @@ pub enum SomeEnum {
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let _crate_def_map = module.def_map(&db);
-            TraitImpls::for_crate(&db, module.krate());
+            TraitImpls::for_crate(&db, module.krate(&db));
         },
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
@@ -375,7 +375,7 @@ $0",
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let _crate_def_map = module.def_map(&db);
-            TraitImpls::for_crate(&db, module.krate());
+            TraitImpls::for_crate(&db, module.krate(&db));
         },
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
@@ -409,7 +409,7 @@ fn bar() -> f32 {
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let _crate_def_map = module.def_map(&db);
-            TraitImpls::for_crate(&db, module.krate());
+            TraitImpls::for_crate(&db, module.krate(&db));
         },
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
@@ -448,7 +448,7 @@ $0",
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let _crate_def_map = module.def_map(&db);
-            TraitImpls::for_crate(&db, module.krate());
+            TraitImpls::for_crate(&db, module.krate(&db));
         },
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
@@ -490,7 +490,7 @@ impl SomeStruct {
         || {
             let module = db.module_for_file(pos.file_id.file_id(&db));
             let _crate_def_map = module.def_map(&db);
-            TraitImpls::for_crate(&db, module.krate());
+            TraitImpls::for_crate(&db, module.krate(&db));
         },
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
@@ -546,7 +546,7 @@ fn main() {
             let module = db.module_for_file(file_id.file_id(&db));
             let crate_def_map = module.def_map(&db);
             let mut defs: Vec<DefWithBodyId> = vec![];
-            visit_module(&db, crate_def_map, module.local_id, &mut |it| {
+            visit_module(&db, crate_def_map, module, &mut |it| {
                 let def = match it {
                     ModuleDefId::FunctionId(it) => it.into(),
                     ModuleDefId::EnumVariantId(it) => it.into(),
@@ -643,7 +643,7 @@ fn main() {
             let crate_def_map = module.def_map(&db);
             let mut defs: Vec<DefWithBodyId> = vec![];
 
-            visit_module(&db, crate_def_map, module.local_id, &mut |it| {
+            visit_module(&db, crate_def_map, module, &mut |it| {
                 let def = match it {
                     ModuleDefId::FunctionId(it) => it.into(),
                     ModuleDefId::EnumVariantId(it) => it.into(),
diff --git a/crates/hir-ty/src/traits.rs b/crates/hir-ty/src/traits.rs
index b1a2802264e4..2f8c31ec6074 100644
--- a/crates/hir-ty/src/traits.rs
+++ b/crates/hir-ty/src/traits.rs
@@ -207,10 +207,10 @@ pub fn is_inherent_impl_coherent(db: &dyn HirDatabase, def_map: &DefMap, impl_id
         | TyKind::Uint(_)
         | TyKind::Float(_) => def_map.is_rustc_coherence_is_core(),
 
-        TyKind::Adt(adt_def, _) => adt_def.def_id().0.module(db).krate() == def_map.krate(),
+        TyKind::Adt(adt_def, _) => adt_def.def_id().0.module(db).krate(db) == def_map.krate(),
         TyKind::Dynamic(it, _) => it
             .principal_def_id()
-            .is_some_and(|trait_id| trait_id.0.module(db).krate() == def_map.krate()),
+            .is_some_and(|trait_id| trait_id.0.module(db).krate(db) == def_map.krate()),
 
         _ => true,
     };
@@ -283,12 +283,12 @@ pub fn check_orphan_rules<'db>(db: &'db dyn HirDatabase, impl_: ImplId) -> bool
         return true;
     };
 
-    let local_crate = impl_.lookup(db).container.krate();
+    let local_crate = impl_.lookup(db).container.krate(db);
     let is_local = |tgt_crate| tgt_crate == local_crate;
 
     let trait_ref = impl_trait.instantiate_identity();
     let trait_id = trait_ref.def_id.0;
-    if is_local(trait_id.module(db).krate()) {
+    if is_local(trait_id.module(db).krate(db)) {
         // trait to be implemented is local
         return true;
     }
@@ -322,10 +322,10 @@ pub fn check_orphan_rules<'db>(db: &'db dyn HirDatabase, impl_: ImplId) -> bool
     // FIXME: param coverage
     //   - No uncovered type parameters `P1..=Pn` may appear in `T0..Ti`` (excluding `Ti`)
     let is_not_orphan = trait_ref.args.types().any(|ty| match unwrap_fundamental(ty).kind() {
-        TyKind::Adt(adt_def, _) => is_local(adt_def.def_id().0.module(db).krate()),
+        TyKind::Adt(adt_def, _) => is_local(adt_def.def_id().0.module(db).krate(db)),
         TyKind::Error(_) => true,
         TyKind::Dynamic(it, _) => {
-            it.principal_def_id().is_some_and(|trait_id| is_local(trait_id.0.module(db).krate()))
+            it.principal_def_id().is_some_and(|trait_id| is_local(trait_id.0.module(db).krate(db)))
         }
         _ => false,
     });
diff --git a/crates/hir-ty/src/variance.rs b/crates/hir-ty/src/variance.rs
index df9d53f3e579..5c0af6dafb52 100644
--- a/crates/hir-ty/src/variance.rs
+++ b/crates/hir-ty/src/variance.rs
@@ -874,7 +874,7 @@ struct FixedPoint<T, U, V>(&'static FixedPoint<(), T, U>, V);
             let mut defs: Vec<GenericDefId> = Vec::new();
             let module = db.module_for_file_opt(file_id.file_id(&db)).unwrap();
             let def_map = module.def_map(&db);
-            crate::tests::visit_module(&db, def_map, module.local_id, &mut |it| {
+            crate::tests::visit_module(&db, def_map, module, &mut |it| {
                 defs.push(match it {
                     ModuleDefId::FunctionId(it) => it.into(),
                     ModuleDefId::AdtId(it) => it.into(),
diff --git a/crates/hir/src/attrs.rs b/crates/hir/src/attrs.rs
index 2f412d88ab33..d1056f31e19e 100644
--- a/crates/hir/src/attrs.rs
+++ b/crates/hir/src/attrs.rs
@@ -3,8 +3,7 @@
 use cfg::CfgExpr;
 use either::Either;
 use hir_def::{
-    AssocItemId, AttrDefId, FieldId, InternedModuleId, LifetimeParamId, ModuleDefId,
-    TypeOrConstParamId,
+    AssocItemId, AttrDefId, FieldId, LifetimeParamId, ModuleDefId, TypeOrConstParamId,
     attrs::{AttrFlags, Docs, IsInnerDoc},
     expr_store::path::Path,
     item_scope::ItemInNs,
@@ -213,8 +212,8 @@ impl_has_attrs_enum![TypeParam, ConstParam, LifetimeParam for GenericParam];
 
 impl HasAttrs for Module {
     #[inline]
-    fn attr_id(self, db: &dyn HirDatabase) -> AttrsOwner {
-        AttrsOwner::AttrDef(AttrDefId::ModuleId(InternedModuleId::new(db, self.id)))
+    fn attr_id(self, _: &dyn HirDatabase) -> AttrsOwner {
+        AttrsOwner::AttrDef(AttrDefId::ModuleId(self.id))
     }
 }
 
@@ -243,7 +242,7 @@ impl HasAttrs for AssocItem {
 impl HasAttrs for crate::Crate {
     #[inline]
     fn attr_id(self, db: &dyn HirDatabase) -> AttrsOwner {
-        self.root_module().attr_id(db)
+        self.root_module(db).attr_id(db)
     }
 }
 
@@ -274,7 +273,6 @@ fn resolve_doc_path_on_(
 ) -> Option<DocLinkDef> {
     let resolver = match attr_id {
         AttrsOwner::AttrDef(AttrDefId::ModuleId(it)) => {
-            let it = it.loc(db);
             if is_inner_doc.yes() {
                 it.resolver(db)
             } else if let Some(parent) = Module::from(it).parent(db) {
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index 9ea1456a4124..1aa799400106 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -35,23 +35,23 @@ impl Module {
     /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
     pub fn definition_source(self, db: &dyn HirDatabase) -> InFile<ModuleSource> {
         let def_map = self.id.def_map(db);
-        def_map[self.id.local_id].definition_source(db)
+        def_map[self.id].definition_source(db)
     }
 
     /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
     pub fn definition_source_range(self, db: &dyn HirDatabase) -> InFile<TextRange> {
         let def_map = self.id.def_map(db);
-        def_map[self.id.local_id].definition_source_range(db)
+        def_map[self.id].definition_source_range(db)
     }
 
     pub fn definition_source_file_id(self, db: &dyn HirDatabase) -> HirFileId {
         let def_map = self.id.def_map(db);
-        def_map[self.id.local_id].definition_source_file_id()
+        def_map[self.id].definition_source_file_id()
     }
 
     pub fn is_mod_rs(self, db: &dyn HirDatabase) -> bool {
         let def_map = self.id.def_map(db);
-        match def_map[self.id.local_id].origin {
+        match def_map[self.id].origin {
             ModuleOrigin::File { is_mod_rs, .. } => is_mod_rs,
             _ => false,
         }
@@ -59,7 +59,7 @@ impl Module {
 
     pub fn as_source_file_id(self, db: &dyn HirDatabase) -> Option<EditionedFileId> {
         let def_map = self.id.def_map(db);
-        match def_map[self.id.local_id].origin {
+        match def_map[self.id].origin {
             ModuleOrigin::File { definition, .. } | ModuleOrigin::CrateRoot { definition, .. } => {
                 Some(definition)
             }
@@ -69,21 +69,21 @@ impl Module {
 
     pub fn is_inline(self, db: &dyn HirDatabase) -> bool {
         let def_map = self.id.def_map(db);
-        def_map[self.id.local_id].origin.is_inline()
+        def_map[self.id].origin.is_inline()
     }
 
     /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
     /// `None` for the crate root.
     pub fn declaration_source(self, db: &dyn HirDatabase) -> Option<InFile<ast::Module>> {
         let def_map = self.id.def_map(db);
-        def_map[self.id.local_id].declaration_source(db)
+        def_map[self.id].declaration_source(db)
     }
 
     /// Returns a text range which declares this module, either a `mod foo;` or a `mod foo {}`.
     /// `None` for the crate root.
     pub fn declaration_source_range(self, db: &dyn HirDatabase) -> Option<InFile<TextRange>> {
         let def_map = self.id.def_map(db);
-        def_map[self.id.local_id].declaration_source_range(db)
+        def_map[self.id].declaration_source_range(db)
     }
 }
 
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 63da5a3a37cf..e57f031f009a 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -48,11 +48,11 @@ use arrayvec::ArrayVec;
 use base_db::{CrateDisplayName, CrateOrigin, LangCrateOrigin};
 use either::Either;
 use hir_def::{
-    AdtId, AssocItemId, AssocItemLoc, CallableDefId, ConstId, ConstParamId, CrateRootModuleId,
-    DefWithBodyId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, GenericDefId,
-    GenericParamId, HasModule, ImplId, InternedModuleId, ItemContainerId, LifetimeParamId,
-    LocalFieldId, Lookup, MacroExpander, MacroId, StaticId, StructId, SyntheticSyntax, TupleId,
-    TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,
+    AdtId, AssocItemId, AssocItemLoc, CallableDefId, ConstId, ConstParamId, DefWithBodyId, EnumId,
+    EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, GenericDefId, GenericParamId,
+    HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalFieldId, Lookup, MacroExpander,
+    MacroId, StaticId, StructId, SyntheticSyntax, TupleId, TypeAliasId, TypeOrConstParamId,
+    TypeParamId, UnionId,
     attrs::AttrFlags,
     expr_store::{ExpressionStoreDiagnostics, ExpressionStoreSourceMap},
     hir::{
@@ -258,13 +258,13 @@ impl Crate {
             .flatten()
     }
 
-    pub fn root_module(self) -> Module {
-        Module { id: CrateRootModuleId::from(self.id).into() }
+    pub fn root_module(self, db: &dyn HirDatabase) -> Module {
+        Module { id: crate_def_map(db, self.id).root_module_id() }
     }
 
     pub fn modules(self, db: &dyn HirDatabase) -> Vec<Module> {
         let def_map = crate_def_map(db, self.id);
-        def_map.modules().map(|(id, _)| def_map.module_id(id).into()).collect()
+        def_map.modules().map(|(id, _)| id.into()).collect()
     }
 
     pub fn root_file(self, db: &dyn HirDatabase) -> FileId {
@@ -520,7 +520,7 @@ impl ModuleDef {
 impl HasCrate for ModuleDef {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
         match self.module(db) {
-            Some(module) => module.krate(),
+            Some(module) => module.krate(db),
             None => Crate::core(db).unwrap_or_else(|| db.all_crates()[0].into()),
         }
     }
@@ -550,29 +550,29 @@ impl Module {
     }
 
     /// Returns the crate this module is part of.
-    pub fn krate(self) -> Crate {
-        Crate { id: self.id.krate() }
+    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
+        Crate { id: self.id.krate(db) }
     }
 
     /// Topmost parent of this module. Every module has a `crate_root`, but some
     /// might be missing `krate`. This can happen if a module's file is not included
     /// in the module tree of any target in `Cargo.toml`.
     pub fn crate_root(self, db: &dyn HirDatabase) -> Module {
-        let def_map = crate_def_map(db, self.id.krate());
-        Module { id: def_map.crate_root().into() }
+        let def_map = crate_def_map(db, self.id.krate(db));
+        Module { id: def_map.crate_root(db) }
     }
 
-    pub fn is_crate_root(self) -> bool {
-        DefMap::ROOT == self.id.local_id
+    pub fn is_crate_root(self, db: &dyn HirDatabase) -> bool {
+        self.crate_root(db) == self
     }
 
     /// Iterates over all child modules.
     pub fn children(self, db: &dyn HirDatabase) -> impl Iterator<Item = Module> {
         let def_map = self.id.def_map(db);
-        let children = def_map[self.id.local_id]
+        let children = def_map[self.id]
             .children
             .values()
-            .map(|module_id| Module { id: def_map.module_id(*module_id) })
+            .map(|module_id| Module { id: *module_id })
             .collect::<Vec<_>>();
         children.into_iter()
     }
@@ -580,17 +580,17 @@ impl Module {
     /// Finds a parent module.
     pub fn parent(self, db: &dyn HirDatabase) -> Option<Module> {
         let def_map = self.id.def_map(db);
-        let parent_id = def_map.containing_module(self.id.local_id)?;
+        let parent_id = def_map.containing_module(self.id)?;
         Some(Module { id: parent_id })
     }
 
     /// Finds nearest non-block ancestor `Module` (`self` included).
     pub fn nearest_non_block_module(self, db: &dyn HirDatabase) -> Module {
         let mut id = self.id;
-        while id.is_block_module() {
+        while id.is_block_module(db) {
             id = id.containing_module(db).expect("block without parent module");
         }
-        Module { id }
+        Module { id: unsafe { id.to_static() } }
     }
 
     pub fn path_to_root(self, db: &dyn HirDatabase) -> Vec<Module> {
@@ -609,7 +609,7 @@ impl Module {
         db: &dyn HirDatabase,
         visible_from: Option<Module>,
     ) -> Vec<(Name, ScopeDef)> {
-        self.id.def_map(db)[self.id.local_id]
+        self.id.def_map(db)[self.id]
             .scope
             .entries()
             .filter_map(|(name, def)| {
@@ -646,19 +646,19 @@ impl Module {
         style_lints: bool,
     ) {
         let _p = tracing::info_span!("diagnostics", name = ?self.name(db)).entered();
-        let edition = self.id.krate().data(db).edition;
+        let edition = self.id.krate(db).data(db).edition;
         let def_map = self.id.def_map(db);
         for diag in def_map.diagnostics() {
-            if diag.in_module != self.id.local_id {
+            if diag.in_module != self.id {
                 // FIXME: This is accidentally quadratic.
                 continue;
             }
             emit_def_diagnostic(db, acc, diag, edition, def_map.krate());
         }
 
-        if !self.id.is_block_module() {
+        if !self.id.is_block_module(db) {
             // These are reported by the body of block modules
-            let scope = &def_map[self.id.local_id].scope;
+            let scope = &def_map[self.id].scope;
             scope.all_macro_calls().for_each(|it| macro_call_diagnostics(db, it, acc));
         }
 
@@ -666,7 +666,7 @@ impl Module {
             match def {
                 ModuleDef::Module(m) => {
                     // Only add diagnostics from inline modules
-                    if def_map[m.id.local_id].origin.is_inline() {
+                    if def_map[m.id].origin.is_inline() {
                         m.diagnostics(db, acc, style_lints)
                     }
                     acc.extend(def.diagnostics(db, style_lints))
@@ -765,7 +765,7 @@ impl Module {
         }
         self.legacy_macros(db).into_iter().for_each(|m| emit_macro_def_diagnostics(db, acc, m));
 
-        let interner = DbInterner::new_with(db, self.id.krate());
+        let interner = DbInterner::new_with(db, self.id.krate(db));
         let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());
 
         let mut impl_assoc_items_scratch = vec![];
@@ -790,7 +790,7 @@ impl Module {
             let ast_id_map = db.ast_id_map(file_id);
 
             for diag in impl_def.id.impl_items_with_diagnostics(db).1.iter() {
-                emit_def_diagnostic(db, acc, diag, edition, loc.container.krate());
+                emit_def_diagnostic(db, acc, diag, edition, loc.container.krate(db));
             }
 
             if impl_signature.target_trait.is_none()
@@ -939,7 +939,7 @@ impl Module {
 
     pub fn declarations(self, db: &dyn HirDatabase) -> Vec<ModuleDef> {
         let def_map = self.id.def_map(db);
-        let scope = &def_map[self.id.local_id].scope;
+        let scope = &def_map[self.id].scope;
         scope
             .declarations()
             .map(ModuleDef::from)
@@ -949,13 +949,13 @@ impl Module {
 
     pub fn legacy_macros(self, db: &dyn HirDatabase) -> Vec<Macro> {
         let def_map = self.id.def_map(db);
-        let scope = &def_map[self.id.local_id].scope;
+        let scope = &def_map[self.id].scope;
         scope.legacy_macros().flat_map(|(_, it)| it).map(|&it| it.into()).collect()
     }
 
     pub fn impl_defs(self, db: &dyn HirDatabase) -> Vec<Impl> {
         let def_map = self.id.def_map(db);
-        def_map[self.id.local_id].scope.impls().map(Impl::from).collect()
+        def_map[self.id].scope.impls().map(Impl::from).collect()
     }
 
     /// Finds a path that can be used to refer to the given item from within
@@ -990,7 +990,7 @@ impl Module {
 
     #[inline]
     pub fn doc_keyword(self, db: &dyn HirDatabase) -> Option<Symbol> {
-        AttrFlags::doc_keyword(db, InternedModuleId::new(db, self.id))
+        AttrFlags::doc_keyword(db, self.id)
     }
 
     /// Whether it has `#[path = "..."]` attribute.
@@ -1196,7 +1196,7 @@ fn precise_macro_call_location(
 impl HasVisibility for Module {
     fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
         let def_map = self.id.def_map(db);
-        let module_data = &def_map[self.id.local_id];
+        let module_data = &def_map[self.id];
         module_data.visibility
     }
 }
@@ -1541,7 +1541,7 @@ impl Enum {
     pub fn variant_body_ty<'db>(self, db: &'db dyn HirDatabase) -> Type<'db> {
         let interner = DbInterner::new_no_crate(db);
         Type::new_for_crate(
-            self.id.lookup(db).container.krate(),
+            self.id.lookup(db).container.krate(db),
             match EnumSignature::variant_body_type(db, self.id) {
                 layout::IntegerType::Pointer(sign) => match sign {
                     true => Ty::new_int(interner, rustc_type_ir::IntTy::Isize),
@@ -1927,7 +1927,7 @@ impl DefWithBody {
     pub fn debug_mir(self, db: &dyn HirDatabase) -> String {
         let body = db.mir_body(self.id());
         match body {
-            Ok(body) => body.pretty_print(db, self.module(db).krate().to_display_target(db)),
+            Ok(body) => body.pretty_print(db, self.module(db).krate(db).to_display_target(db)),
             Err(e) => format!("error:\n{e:?}"),
         }
     }
@@ -1938,7 +1938,7 @@ impl DefWithBody {
         acc: &mut Vec<AnyDiagnostic<'db>>,
         style_lints: bool,
     ) {
-        let krate = self.module(db).id.krate();
+        let krate = self.module(db).id.krate(db);
 
         let (body, source_map) = db.body_with_source_map(self.into());
         let sig_source_map = match self {
@@ -1952,7 +1952,7 @@ impl DefWithBody {
         };
 
         for (_, def_map) in body.blocks(db) {
-            Module { id: def_map.module_id(DefMap::ROOT) }.diagnostics(db, acc, style_lints);
+            Module { id: def_map.root_module_id() }.diagnostics(db, acc, style_lints);
         }
 
         expr_store_diagnostics(db, acc, &source_map);
@@ -2398,7 +2398,7 @@ impl Function {
     /// is this a `fn main` or a function with an `export_name` of `main`?
     pub fn is_main(self, db: &dyn HirDatabase) -> bool {
         self.exported_main(db)
-            || self.module(db).is_crate_root() && db.function_signature(self.id).name == sym::main
+            || self.module(db).is_crate_root(db) && db.function_signature(self.id).name == sym::main
     }
 
     /// Is this a function with an `export_name` of `main`?
@@ -2475,7 +2475,7 @@ impl Function {
             GenericArgs::new_from_iter(interner, []),
             ParamEnvAndCrate {
                 param_env: db.trait_environment(self.id.into()),
-                krate: self.id.module(db).krate(),
+                krate: self.id.module(db).krate(db),
             },
         )?;
         let (result, output) = interpret_mir(db, body, false, None)?;
@@ -2657,7 +2657,7 @@ impl ExternCrateDecl {
 
     pub fn resolved_crate(self, db: &dyn HirDatabase) -> Option<Crate> {
         let loc = self.id.lookup(db);
-        let krate = loc.container.krate();
+        let krate = loc.container.krate(db);
         let name = self.name(db);
         if name == sym::self_ {
             Some(krate.into())
@@ -3239,8 +3239,8 @@ impl ItemInNs {
     /// Returns the crate defining this item (or `None` if `self` is built-in).
     pub fn krate(&self, db: &dyn HirDatabase) -> Option<Crate> {
         match self {
-            ItemInNs::Types(did) | ItemInNs::Values(did) => did.module(db).map(|m| m.krate()),
-            ItemInNs::Macros(id) => Some(id.module(db).krate()),
+            ItemInNs::Types(did) | ItemInNs::Values(did) => did.module(db).map(|m| m.krate(db)),
+            ItemInNs::Macros(id) => Some(id.module(db).krate(db)),
         }
     }
 
@@ -4323,7 +4323,7 @@ impl Impl {
     }
 
     pub fn all_in_module(db: &dyn HirDatabase, module: Module) -> Vec<Impl> {
-        module.id.def_map(db)[module.id.local_id].scope.impls().map(Into::into).collect()
+        module.id.def_map(db)[module.id].scope.impls().map(Into::into).collect()
     }
 
     /// **Note:** This is an **approximation** that strives to give the *human-perceived notion* of an "impl for type",
@@ -4348,15 +4348,13 @@ impl Impl {
         if let Some(module) = method_resolution::simplified_type_module(db, &simplified_ty) {
             InherentImpls::for_each_crate_and_block(
                 db,
-                module.krate(),
-                module.containing_block(),
+                module.krate(db),
+                module.block(db),
                 &mut |impls| extend_with_impls(impls.for_self_ty(&simplified_ty)),
             );
-            std::iter::successors(module.containing_block(), |block| {
-                block.loc(db).module.containing_block()
-            })
-            .filter_map(|block| TraitImpls::for_block(db, block).as_deref())
-            .for_each(|impls| impls.for_self_ty(&simplified_ty, &mut extend_with_impls));
+            std::iter::successors(module.block(db), |block| block.module(db).block(db))
+                .filter_map(|block| TraitImpls::for_block(db, block).as_deref())
+                .for_each(|impls| impls.for_self_ty(&simplified_ty, &mut extend_with_impls));
             for &krate in &**db.all_crates() {
                 TraitImpls::for_crate(db, krate)
                     .for_self_ty(&simplified_ty, &mut extend_with_impls);
@@ -4376,10 +4374,10 @@ impl Impl {
         let mut handle_impls = |impls: &TraitImpls| {
             impls.for_trait(trait_.id, |impls| all.extend(impls.iter().copied().map(Impl::from)));
         };
-        for krate in module.krate().transitive_rev_deps(db) {
+        for krate in module.krate(db).transitive_rev_deps(db) {
             handle_impls(TraitImpls::for_crate(db, krate));
         }
-        if let Some(block) = module.containing_block()
+        if let Some(block) = module.block(db)
             && let Some(impls) = TraitImpls::for_block(db, block)
         {
             handle_impls(impls);
@@ -4431,7 +4429,7 @@ impl Impl {
             MacroCallKind::Derive { ast_id, derive_attr_index, derive_index, .. } => {
                 let module_id = self.id.lookup(db).container;
                 (
-                    crate_def_map(db, module_id.krate())[module_id.local_id]
+                    module_id.def_map(db)[module_id]
                         .scope
                         .derive_macro_invoc(ast_id, derive_attr_index)?,
                     derive_index,
@@ -5329,8 +5327,8 @@ impl<'db> Type<'db> {
         if let Some(module) = method_resolution::simplified_type_module(db, &simplified_type) {
             InherentImpls::for_each_crate_and_block(
                 db,
-                module.krate(),
-                module.containing_block(),
+                module.krate(db),
+                module.block(db),
                 &mut |impls| {
                     handle_impls(impls.for_self_ty(&simplified_type));
                 },
@@ -5466,7 +5464,7 @@ impl<'db> Type<'db> {
         f: impl FnOnce(&MethodResolutionContext<'_, 'db>) -> R,
     ) -> R {
         let module = resolver.module();
-        let interner = DbInterner::new_with(db, module.krate());
+        let interner = DbInterner::new_with(db, module.krate(db));
         let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
         let unstable_features =
             MethodResolutionUnstableFeatures::from_def_map(resolver.top_level_def_map());
@@ -6140,12 +6138,12 @@ impl ScopeDef {
 
     pub fn krate(&self, db: &dyn HirDatabase) -> Option<Crate> {
         match self {
-            ScopeDef::ModuleDef(it) => it.module(db).map(|m| m.krate()),
-            ScopeDef::GenericParam(it) => Some(it.module(db).krate()),
+            ScopeDef::ModuleDef(it) => it.module(db).map(|m| m.krate(db)),
+            ScopeDef::GenericParam(it) => Some(it.module(db).krate(db)),
             ScopeDef::ImplSelfType(_) => None,
-            ScopeDef::AdtSelfType(it) => Some(it.module(db).krate()),
-            ScopeDef::Local(it) => Some(it.module(db).krate()),
-            ScopeDef::Label(it) => Some(it.module(db).krate()),
+            ScopeDef::AdtSelfType(it) => Some(it.module(db).krate(db)),
+            ScopeDef::Local(it) => Some(it.module(db).krate(db)),
+            ScopeDef::Label(it) => Some(it.module(db).krate(db)),
             ScopeDef::Unknown => None,
         }
     }
@@ -6205,61 +6203,61 @@ pub trait HasCrate {
 
 impl<T: hir_def::HasModule> HasCrate for T {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate().into()
+        self.module(db).krate(db).into()
     }
 }
 
 impl HasCrate for AssocItem {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Struct {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Union {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Enum {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Field {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.parent_def(db).module(db).krate()
+        self.parent_def(db).module(db).krate(db)
     }
 }
 
 impl HasCrate for Variant {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Function {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Const {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for TypeAlias {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
@@ -6271,37 +6269,37 @@ impl HasCrate for Type<'_> {
 
 impl HasCrate for Macro {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Trait {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Static {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Adt {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Impl {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
+        self.module(db).krate(db)
     }
 }
 
 impl HasCrate for Module {
-    fn krate(&self, _: &dyn HirDatabase) -> Crate {
-        Module::krate(*self)
+    fn krate(&self, db: &dyn HirDatabase) -> Crate {
+        Module::krate(*self, db)
     }
 }
 
@@ -6319,8 +6317,8 @@ impl HasContainer for Module {
     fn container(&self, db: &dyn HirDatabase) -> ItemContainer {
         // FIXME: handle block expressions as modules (their parent is in a different DefMap)
         let def_map = self.id.def_map(db);
-        match def_map[self.id.local_id].parent {
-            Some(parent_id) => ItemContainer::Module(Module { id: def_map.module_id(parent_id) }),
+        match def_map[self.id].parent {
+            Some(parent_id) => ItemContainer::Module(Module { id: parent_id }),
             None => ItemContainer::Crate(def_map.krate().into()),
         }
     }
@@ -6479,7 +6477,7 @@ pub fn resolve_absolute_path<'a, I: Iterator<Item = Symbol> + Clone + 'a>(
                 .filter_map(|&krate| {
                     let segments = segments.clone();
                     let mut def_map = crate_def_map(db, krate);
-                    let mut module = &def_map[DefMap::ROOT];
+                    let mut module = &def_map[def_map.root_module_id()];
                     let mut segments = segments.with_position().peekable();
                     while let Some((_, segment)) = segments.next_if(|&(position, _)| {
                         !matches!(position, itertools::Position::Last | itertools::Position::Only)
@@ -6493,7 +6491,7 @@ pub fn resolve_absolute_path<'a, I: Iterator<Item = Symbol> + Clone + 'a>(
                                 _ => None,
                             })?;
                         def_map = res.def_map(db);
-                        module = &def_map[res.local_id];
+                        module = &def_map[res];
                     }
                     let (_, item_name) = segments.next()?;
                     let res = module.scope.get(&Name::new_symbol_root(item_name));
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 195fafad5cbc..ffb518b1e66f 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -442,13 +442,13 @@ impl<'db> SemanticsImpl<'db> {
     /// If not crate is found for the file, try to return the last crate in topological order.
     pub fn first_crate(&self, file: FileId) -> Option<Crate> {
         match self.file_to_module_defs(file).next() {
-            Some(module) => Some(module.krate()),
+            Some(module) => Some(module.krate(self.db)),
             None => self.db.all_crates().last().copied().map(Into::into),
         }
     }
 
     pub fn attach_first_edition_opt(&self, file: FileId) -> Option<EditionedFileId> {
-        let krate = self.file_to_module_defs(file).next()?.krate();
+        let krate = self.file_to_module_defs(file).next()?.krate(self.db);
         Some(EditionedFileId::new(self.db, file, krate.edition(self.db), krate.id))
     }
 
@@ -478,8 +478,8 @@ impl<'db> SemanticsImpl<'db> {
         match file_id {
             HirFileId::FileId(file_id) => {
                 let module = self.file_to_module_defs(file_id.file_id(self.db)).next()?;
-                let def_map = crate_def_map(self.db, module.krate().id);
-                match def_map[module.id.local_id].origin {
+                let def_map = crate_def_map(self.db, module.krate(self.db).id);
+                match def_map[module.id].origin {
                     ModuleOrigin::CrateRoot { .. } => None,
                     ModuleOrigin::File { declaration, declaration_tree_id, .. } => {
                         let file_id = declaration_tree_id.file_id();
@@ -505,7 +505,7 @@ impl<'db> SemanticsImpl<'db> {
     /// the `SyntaxNode` of the *definition* file, not of the *declaration*.
     pub fn module_definition_node(&self, module: Module) -> InFile<SyntaxNode> {
         let def_map = module.id.def_map(self.db);
-        let definition = def_map[module.id.local_id].origin.definition_source(self.db);
+        let definition = def_map[module.id].origin.definition_source(self.db);
         let definition = definition.map(|it| it.node());
         let root_node = find_root(&definition.value);
         self.cache(root_node, definition.file_id);
@@ -534,7 +534,7 @@ impl<'db> SemanticsImpl<'db> {
         let file_id = self.find_file(attr.syntax()).file_id;
         let krate = match file_id {
             HirFileId::FileId(file_id) => {
-                self.file_to_module_defs(file_id.file_id(self.db)).next()?.krate().id
+                self.file_to_module_defs(file_id.file_id(self.db)).next()?.krate(self.db).id
             }
             HirFileId::MacroFile(macro_file) => self.db.lookup_intern_macro_call(macro_file).krate,
         };
diff --git a/crates/hir/src/semantics/child_by_source.rs b/crates/hir/src/semantics/child_by_source.rs
index 165ac7e4a08d..d924aaa25ddc 100644
--- a/crates/hir/src/semantics/child_by_source.rs
+++ b/crates/hir/src/semantics/child_by_source.rs
@@ -20,7 +20,6 @@ use hir_def::{
     },
     hir::generics::GenericParams,
     item_scope::ItemScope,
-    nameres::DefMap,
     src::{HasChildSource, HasSource},
 };
 
@@ -87,7 +86,7 @@ impl ChildBySource for ImplId {
 impl ChildBySource for ModuleId {
     fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
         let def_map = self.def_map(db);
-        let module_data = &def_map[self.local_id];
+        let module_data = &def_map[*self];
         module_data.scope.child_by_source_to(db, res, file_id);
     }
 }
@@ -226,8 +225,8 @@ impl ChildBySource for DefWithBodyId {
         for (block, def_map) in body.blocks(db) {
             // All block expressions are merged into the same map, because they logically all add
             // inner items to the containing `DefWithBodyId`.
-            def_map[DefMap::ROOT].scope.child_by_source_to(db, res, file_id);
-            res[keys::BLOCK].insert(block.lookup(db).ast_id.to_ptr(db), block);
+            def_map[def_map.root].scope.child_by_source_to(db, res, file_id);
+            res[keys::BLOCK].insert(block.ast_id(db).to_ptr(db), block);
         }
     }
 }
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index 44df4d8fc8c8..257405992731 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -183,11 +183,7 @@ impl SourceToDefCtx<'_, '_> {
                 // Note: `mod` declarations in block modules cannot be supported here
                 let crate_def_map = crate_def_map(self.db, crate_id);
                 let n_mods = mods.len();
-                let modules = |file| {
-                    crate_def_map
-                        .modules_for_file(self.db, file)
-                        .map(|local_id| crate_def_map.module_id(local_id))
-                };
+                let modules = |file| crate_def_map.modules_for_file(self.db, file);
                 mods.extend(modules(file));
                 if mods.len() == n_mods {
                     mods.extend(
@@ -239,8 +235,8 @@ impl SourceToDefCtx<'_, '_> {
 
         let child_name = src.value.name()?.as_name();
         let def_map = parent_module.def_map(self.db);
-        let &child_id = def_map[parent_module.local_id].children.get(&child_name)?;
-        Some(def_map.module_id(child_id))
+        let &child_id = def_map[parent_module].children.get(&child_name)?;
+        Some(child_id)
     }
 
     pub(super) fn source_file_to_def(&mut self, src: InFile<&ast::SourceFile>) -> Option<ModuleId> {
diff --git a/crates/hir/src/symbols.rs b/crates/hir/src/symbols.rs
index 1530e697a3f2..a9320fdda7e1 100644
--- a/crates/hir/src/symbols.rs
+++ b/crates/hir/src/symbols.rs
@@ -255,7 +255,7 @@ impl<'a> SymbolCollector<'a> {
             };
 
         let def_map = module_id.def_map(self.db);
-        let scope = &def_map[module_id.local_id].scope;
+        let scope = &def_map[module_id].scope;
 
         for impl_id in scope.impls() {
             self.collect_from_impl(impl_id);
@@ -329,10 +329,7 @@ impl<'a> SymbolCollector<'a> {
         // Descend into the blocks and enqueue collection of all modules within.
         for (_, def_map) in body.blocks(self.db) {
             for (id, _) in def_map.modules() {
-                self.work.push(SymbolCollectorWork {
-                    module_id: def_map.module_id(id),
-                    parent: name.clone(),
-                });
+                self.work.push(SymbolCollectorWork { module_id: id, parent: name.clone() });
             }
         }
     }
@@ -451,7 +448,7 @@ impl<'a> SymbolCollector<'a> {
 
     fn push_module(&mut self, module_id: ModuleId, name: &Name) {
         let def_map = module_id.def_map(self.db);
-        let module_data = &def_map[module_id.local_id];
+        let module_data = &def_map[module_id];
         let Some(declaration) = module_data.origin.declaration() else { return };
         let module = declaration.to_node(self.db);
         let Some(name_node) = module.name() else { return };
diff --git a/crates/hir/src/term_search/tactics.rs b/crates/hir/src/term_search/tactics.rs
index 979ec8c49fe7..05a89e76529b 100644
--- a/crates/hir/src/term_search/tactics.rs
+++ b/crates/hir/src/term_search/tactics.rs
@@ -762,7 +762,7 @@ pub(super) fn make_tuple<'a, 'lt, 'db, DB: HirDatabase>(
                 .filter(|_| should_continue())
                 .map(|params| {
                     let tys: Vec<Type<'_>> = params.iter().map(|it| it.ty(db)).collect();
-                    let tuple_ty = Type::new_tuple(module.krate().into(), &tys);
+                    let tuple_ty = Type::new_tuple(module.krate(db).into(), &tys);
 
                     let expr = Expr::Tuple { ty: tuple_ty.clone(), params };
                     lookup.insert(tuple_ty, iter::once(expr.clone()));
diff --git a/crates/ide-assists/src/handlers/add_missing_impl_members.rs b/crates/ide-assists/src/handlers/add_missing_impl_members.rs
index e970bb7167d1..65ca1ceae11e 100644
--- a/crates/ide-assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ide-assists/src/handlers/add_missing_impl_members.rs
@@ -130,7 +130,7 @@ fn add_missing_impl_members_inner(
     if let IgnoreAssocItems::DocHiddenAttrPresent = ignore_items {
         // Relax condition for local crates.
         let db = ctx.db();
-        if trait_.module(db).krate().origin(db).is_local() {
+        if trait_.module(db).krate(db).origin(db).is_local() {
             ign_item = IgnoreAssocItems::No;
         }
     }
diff --git a/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index 248ce2ad6115..10c3ff0e4d2b 100644
--- a/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -92,24 +92,25 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
         bool,
         bool,
     ) = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr, self_ty.as_ref()) {
-        let is_non_exhaustive = enum_def.is_non_exhaustive(ctx.db(), module.krate());
+        let is_non_exhaustive = enum_def.is_non_exhaustive(ctx.db(), module.krate(ctx.db()));
 
         let variants = enum_def.variants(ctx.db());
 
-        let has_hidden_variants =
-            variants.iter().any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));
+        let has_hidden_variants = variants
+            .iter()
+            .any(|variant| variant.should_be_hidden(ctx.db(), module.krate(ctx.db())));
 
         let missing_pats = variants
             .into_iter()
             .filter_map(|variant| {
                 Some((
                     build_pat(ctx, &make, module, variant, cfg)?,
-                    variant.should_be_hidden(ctx.db(), module.krate()),
+                    variant.should_be_hidden(ctx.db(), module.krate(ctx.db())),
                 ))
             })
             .filter(|(variant_pat, _)| is_variant_missing(&top_lvl_pats, variant_pat));
 
-        let option_enum = FamousDefs(&ctx.sema, module.krate()).core_option_Option();
+        let option_enum = FamousDefs(&ctx.sema, module.krate(ctx.db())).core_option_Option();
         let missing_pats: Box<dyn Iterator<Item = _>> = if matches!(enum_def, ExtendedEnum::Enum { enum_: e, .. } if Some(e) == option_enum)
         {
             // Match `Some` variant first.
@@ -120,8 +121,9 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
         };
         (missing_pats.peekable(), is_non_exhaustive, has_hidden_variants)
     } else if let Some(enum_defs) = resolve_tuple_of_enum_def(&ctx.sema, &expr, self_ty.as_ref()) {
-        let is_non_exhaustive =
-            enum_defs.iter().any(|enum_def| enum_def.is_non_exhaustive(ctx.db(), module.krate()));
+        let is_non_exhaustive = enum_defs
+            .iter()
+            .any(|enum_def| enum_def.is_non_exhaustive(ctx.db(), module.krate(ctx.db())));
 
         let mut n_arms = 1;
         let variants_of_enums: Vec<Vec<ExtendedVariant>> = enum_defs
@@ -145,7 +147,7 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
         let has_hidden_variants = variants_of_enums
             .iter()
             .flatten()
-            .any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));
+            .any(|variant| variant.should_be_hidden(ctx.db(), module.krate(ctx.db())));
 
         let missing_pats = variants_of_enums
             .into_iter()
@@ -154,7 +156,7 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
             .map(|variants| {
                 let is_hidden = variants
                     .iter()
-                    .any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));
+                    .any(|variant| variant.should_be_hidden(ctx.db(), module.krate(ctx.db())));
                 let patterns = variants
                     .into_iter()
                     .filter_map(|variant| build_pat(ctx, &make, module, variant, cfg));
@@ -170,15 +172,16 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
     } else if let Some((enum_def, len)) =
         resolve_array_of_enum_def(&ctx.sema, &expr, self_ty.as_ref())
     {
-        let is_non_exhaustive = enum_def.is_non_exhaustive(ctx.db(), module.krate());
+        let is_non_exhaustive = enum_def.is_non_exhaustive(ctx.db(), module.krate(ctx.db()));
         let variants = enum_def.variants(ctx.db());
 
         if len.pow(variants.len() as u32) > 256 {
             return None;
         }
 
-        let has_hidden_variants =
-            variants.iter().any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));
+        let has_hidden_variants = variants
+            .iter()
+            .any(|variant| variant.should_be_hidden(ctx.db(), module.krate(ctx.db())));
 
         let variants_of_enums = vec![variants; len];
 
@@ -189,7 +192,7 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
             .map(|variants| {
                 let is_hidden = variants
                     .iter()
-                    .any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));
+                    .any(|variant| variant.should_be_hidden(ctx.db(), module.krate(ctx.db())));
                 let patterns = variants
                     .into_iter()
                     .filter_map(|variant| build_pat(ctx, &make, module, variant, cfg));
@@ -401,7 +404,7 @@ impl ExtendedVariant {
     fn should_be_hidden(self, db: &RootDatabase, krate: Crate) -> bool {
         match self {
             ExtendedVariant::Variant { variant: var, .. } => {
-                var.attrs(db).is_doc_hidden() && var.module(db).krate() != krate
+                var.attrs(db).is_doc_hidden() && var.module(db).krate(db) != krate
             }
             _ => false,
         }
@@ -424,7 +427,7 @@ impl ExtendedEnum {
     fn is_non_exhaustive(&self, db: &RootDatabase, krate: Crate) -> bool {
         match self {
             ExtendedEnum::Enum { enum_: e, .. } => {
-                e.attrs(db).is_non_exhaustive() && e.module(db).krate() != krate
+                e.attrs(db).is_non_exhaustive() && e.module(db).krate(db) != krate
             }
             _ => false,
         }
@@ -502,7 +505,7 @@ fn build_pat(
     let db = ctx.db();
     match var {
         ExtendedVariant::Variant { variant: var, use_self } => {
-            let edition = module.krate().edition(db);
+            let edition = module.krate(db).edition(db);
             let path = if use_self {
                 make::path_from_segments(
                     [
diff --git a/crates/ide-assists/src/handlers/apply_demorgan.rs b/crates/ide-assists/src/handlers/apply_demorgan.rs
index 3281adbcc3bb..d193e8a9d8dc 100644
--- a/crates/ide-assists/src/handlers/apply_demorgan.rs
+++ b/crates/ide-assists/src/handlers/apply_demorgan.rs
@@ -260,7 +260,7 @@ fn validate_method_call_expr(
     let receiver = method_call.receiver()?;
     let it_type = sema.type_of_expr(&receiver)?.adjusted();
     let module = sema.scope(receiver.syntax())?.module();
-    let krate = module.krate();
+    let krate = module.krate(ctx.db());
 
     let iter_trait = FamousDefs(sema, krate).core_iter_Iterator()?;
     it_type.impls_trait(sema.db, iter_trait, &[]).then_some((name_ref, arg_expr))
diff --git a/crates/ide-assists/src/handlers/auto_import.rs b/crates/ide-assists/src/handlers/auto_import.rs
index bb6a10d40b71..cc2bf8174941 100644
--- a/crates/ide-assists/src/handlers/auto_import.rs
+++ b/crates/ide-assists/src/handlers/auto_import.rs
@@ -114,7 +114,8 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<
     proposed_imports.sort_by_key(|import| {
         Reverse(relevance_score(ctx, import, expected.as_ref(), current_module.as_ref()))
     });
-    let edition = current_module.map(|it| it.krate().edition(ctx.db())).unwrap_or(Edition::CURRENT);
+    let edition =
+        current_module.map(|it| it.krate(ctx.db()).edition(ctx.db())).unwrap_or(Edition::CURRENT);
 
     let group_label = group_label(import_assets.import_candidate());
     for import in proposed_imports {
@@ -316,11 +317,11 @@ fn module_distance_heuristic(db: &dyn HirDatabase, current: &Module, item: &Modu
     let distinct_length = current_path.len() + item_path.len() - 2 * prefix_length;
 
     // cost of importing from another crate
-    let crate_boundary_cost = if current.krate() == item.krate() {
+    let crate_boundary_cost = if current.krate(db) == item.krate(db) {
         0
-    } else if item.krate().origin(db).is_local() {
+    } else if item.krate(db).origin(db).is_local() {
         2
-    } else if item.krate().is_builtin(db) {
+    } else if item.krate(db).is_builtin(db) {
         3
     } else {
         4
diff --git a/crates/ide-assists/src/handlers/convert_bool_to_enum.rs b/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
index 2ad13362378e..1ae5f6491744 100644
--- a/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
+++ b/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
@@ -329,7 +329,7 @@ fn augment_references_with_imports(
 ) -> Vec<FileReferenceWithImport> {
     let mut visited_modules = FxHashSet::default();
 
-    let edition = target_module.krate().edition(ctx.db());
+    let edition = target_module.krate(ctx.db()).edition(ctx.db());
     references
         .into_iter()
         .filter_map(|FileReference { range, name, .. }| {
@@ -345,8 +345,9 @@ fn augment_references_with_imports(
 
                 ImportScope::find_insert_use_container(name.syntax(), &ctx.sema).and_then(
                     |import_scope| {
-                        let cfg =
-                            ctx.config.find_path_config(ctx.sema.is_nightly(target_module.krate()));
+                        let cfg = ctx.config.find_path_config(
+                            ctx.sema.is_nightly(target_module.krate(ctx.sema.db)),
+                        );
                         let path = ref_module
                             .find_use_path(
                                 ctx.sema.db,
diff --git a/crates/ide-assists/src/handlers/convert_for_to_while_let.rs b/crates/ide-assists/src/handlers/convert_for_to_while_let.rs
index 156286d564f2..ef2dc355b8a7 100644
--- a/crates/ide-assists/src/handlers/convert_for_to_while_let.rs
+++ b/crates/ide-assists/src/handlers/convert_for_to_while_let.rs
@@ -150,7 +150,7 @@ fn impls_core_iter(sema: &hir::Semantics<'_, ide_db::RootDatabase>, iterable: &a
 
         let module = sema.scope(iterable.syntax())?.module();
 
-        let krate = module.krate();
+        let krate = module.krate(sema.db);
         let iter_trait = FamousDefs(sema, krate).core_iter_Iterator()?;
         cov_mark::hit!(test_already_impls_iterator);
         Some(it_typ.impls_trait(sema.db, iter_trait, &[]))
diff --git a/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs b/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
index 7d8b763d8b87..6a74d214512f 100644
--- a/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
+++ b/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
@@ -64,7 +64,7 @@ pub(crate) fn convert_from_to_tryfrom(acc: &mut Assists, ctx: &AssistContext<'_>
     let tail_expr = from_fn.body()?.tail_expr()?;
 
     if resolve_target_trait(&ctx.sema, &impl_)?
-        != FamousDefs(&ctx.sema, module.krate()).core_convert_From()?
+        != FamousDefs(&ctx.sema, module.krate(ctx.db())).core_convert_From()?
     {
         return None;
     }
diff --git a/crates/ide-assists/src/handlers/convert_into_to_from.rs b/crates/ide-assists/src/handlers/convert_into_to_from.rs
index 8f02d28b8245..e33010242351 100644
--- a/crates/ide-assists/src/handlers/convert_into_to_from.rs
+++ b/crates/ide-assists/src/handlers/convert_into_to_from.rs
@@ -39,11 +39,11 @@ pub(crate) fn convert_into_to_from(acc: &mut Assists, ctx: &AssistContext<'_>) -
     let module = ctx.sema.scope(impl_.syntax())?.module();
 
     let trait_ = resolve_target_trait(&ctx.sema, &impl_)?;
-    if trait_ != FamousDefs(&ctx.sema, module.krate()).core_convert_Into()? {
+    if trait_ != FamousDefs(&ctx.sema, module.krate(ctx.db())).core_convert_Into()? {
         return None;
     }
 
-    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));
+    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate(ctx.sema.db)));
 
     let src_type_path = {
         let src_type_path = src_type.syntax().descendants().find_map(ast::Path::cast)?;
@@ -53,7 +53,7 @@ pub(crate) fn convert_into_to_from(acc: &mut Assists, ctx: &AssistContext<'_>) -
         };
         mod_path_to_ast(
             &module.find_path(ctx.db(), src_type_def, cfg)?,
-            module.krate().edition(ctx.db()),
+            module.krate(ctx.db()).edition(ctx.db()),
         )
     };
 
diff --git a/crates/ide-assists/src/handlers/convert_iter_for_each_to_for.rs b/crates/ide-assists/src/handlers/convert_iter_for_each_to_for.rs
index c8a244b2136d..0c0458468df8 100644
--- a/crates/ide-assists/src/handlers/convert_iter_for_each_to_for.rs
+++ b/crates/ide-assists/src/handlers/convert_iter_for_each_to_for.rs
@@ -186,7 +186,7 @@ fn impls_core_iter(sema: &hir::Semantics<'_, ide_db::RootDatabase>, iterable: &a
 
         let module = sema.scope(iterable.syntax())?.module();
 
-        let krate = module.krate();
+        let krate = module.krate(sema.db);
         let iter_trait = FamousDefs(sema, krate).core_iter_Iterator()?;
         cov_mark::hit!(test_already_impls_iterator);
         Some(it_typ.impls_trait(sema.db, iter_trait, &[]))
@@ -214,7 +214,7 @@ fn validate_method_call_expr(
 
     let it_type = sema.type_of_expr(&receiver)?.adjusted();
     let module = sema.scope(receiver.syntax())?.module();
-    let krate = module.krate();
+    let krate = module.krate(ctx.db());
 
     let iter_trait = FamousDefs(sema, krate).core_iter_Iterator()?;
     it_type.impls_trait(sema.db, iter_trait, &[]).then_some((expr, receiver))
diff --git a/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs b/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs
index 9876e14203fe..0e5e6185d054 100644
--- a/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs
+++ b/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs
@@ -199,7 +199,8 @@ fn augment_references_with_imports(
             {
                 visited_modules.insert(ref_module);
 
-                let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(ref_module.krate()));
+                let cfg =
+                    ctx.config.find_path_config(ctx.sema.is_nightly(ref_module.krate(ctx.sema.db)));
                 let import_scope =
                     ImportScope::find_insert_use_container(new_name.syntax(), &ctx.sema);
                 let path = ref_module
@@ -211,7 +212,10 @@ fn augment_references_with_imports(
                     )
                     .map(|mod_path| {
                         make::path_concat(
-                            mod_path_to_ast(&mod_path, target_module.krate().edition(ctx.db())),
+                            mod_path_to_ast(
+                                &mod_path,
+                                target_module.krate(ctx.db()).edition(ctx.db()),
+                            ),
                             make::path_from_text(struct_name),
                         )
                     });
diff --git a/crates/ide-assists/src/handlers/destructure_struct_binding.rs b/crates/ide-assists/src/handlers/destructure_struct_binding.rs
index 46f210804da3..bb5d11221087 100644
--- a/crates/ide-assists/src/handlers/destructure_struct_binding.rs
+++ b/crates/ide-assists/src/handlers/destructure_struct_binding.rs
@@ -88,13 +88,14 @@ fn collect_data(ident_pat: ast::IdentPat, ctx: &AssistContext<'_>) -> Option<Str
     let hir::Adt::Struct(struct_type) = ty.strip_references().as_adt()? else { return None };
 
     let module = ctx.sema.scope(ident_pat.syntax())?.module();
-    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));
+    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate(ctx.db())));
     let struct_def = hir::ModuleDef::from(struct_type);
     let kind = struct_type.kind(ctx.db());
     let struct_def_path = module.find_path(ctx.db(), struct_def, cfg)?;
 
     let is_non_exhaustive = struct_def.attrs(ctx.db())?.is_non_exhaustive();
-    let is_foreign_crate = struct_def.module(ctx.db()).is_some_and(|m| m.krate() != module.krate());
+    let is_foreign_crate =
+        struct_def.module(ctx.db()).is_some_and(|m| m.krate(ctx.db()) != module.krate(ctx.db()));
 
     let fields = struct_type.fields(ctx.db());
     let n_fields = fields.len();
@@ -148,7 +149,7 @@ fn collect_data(ident_pat: ast::IdentPat, ctx: &AssistContext<'_>) -> Option<Str
         names_in_scope,
         need_record_field_name,
         is_ref,
-        edition: module.krate().edition(ctx.db()),
+        edition: module.krate(ctx.db()).edition(ctx.db()),
     })
 }
 
diff --git a/crates/ide-assists/src/handlers/expand_glob_import.rs b/crates/ide-assists/src/handlers/expand_glob_import.rs
index 4b6d0b37854c..7eca4d3f2a09 100644
--- a/crates/ide-assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide-assists/src/handlers/expand_glob_import.rs
@@ -152,8 +152,10 @@ fn build_expanded_import(
         (false, current_module)
     } else {
         match get_export_visibility_kind(&use_item) {
-            VisibilityKind::Pub => (true, current_module.krate().root_module()),
-            VisibilityKind::PubCrate => (false, current_module.krate().root_module()),
+            VisibilityKind::Pub => (true, current_module.krate(ctx.db()).root_module(ctx.db())),
+            VisibilityKind::PubCrate => {
+                (false, current_module.krate(ctx.db()).root_module(ctx.db()))
+            }
             _ => (false, current_module),
         }
     };
@@ -167,7 +169,7 @@ fn build_expanded_import(
     let names_to_import = find_names_to_import(filtered_defs, imported_defs);
     let expanded = make::use_tree_list(names_to_import.iter().map(|n| {
         let path = make::ext::ident_path(
-            &n.display(ctx.db(), current_module.krate().edition(ctx.db())).to_string(),
+            &n.display(ctx.db(), current_module.krate(ctx.db()).edition(ctx.db())).to_string(),
         );
         make::use_tree(path, None, None, false)
     }))
diff --git a/crates/ide-assists/src/handlers/extract_function.rs b/crates/ide-assists/src/handlers/extract_function.rs
index 44d020a1b46c..4b7314be4609 100644
--- a/crates/ide-assists/src/handlers/extract_function.rs
+++ b/crates/ide-assists/src/handlers/extract_function.rs
@@ -206,10 +206,11 @@ pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
             {
                 let scope = builder.make_import_scope_mut(scope);
                 let control_flow_enum =
-                    FamousDefs(&ctx.sema, module.krate()).core_ops_ControlFlow();
+                    FamousDefs(&ctx.sema, module.krate(ctx.db())).core_ops_ControlFlow();
 
                 if let Some(control_flow_enum) = control_flow_enum {
-                    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));
+                    let cfg =
+                        ctx.config.find_path_config(ctx.sema.is_nightly(module.krate(ctx.sema.db)));
                     let mod_path = module.find_use_path(
                         ctx.sema.db,
                         ModuleDef::from(control_flow_enum),
diff --git a/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
index 2cec3296c87e..386652a42292 100644
--- a/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -400,7 +400,8 @@ fn process_references(
             let segment = builder.make_mut(segment);
             let scope_node = builder.make_syntax_mut(scope_node);
             if !visited_modules.contains(&module) {
-                let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));
+                let cfg =
+                    ctx.config.find_path_config(ctx.sema.is_nightly(module.krate(ctx.sema.db)));
                 let mod_path = module.find_use_path(
                     ctx.sema.db,
                     *enum_module_def,
diff --git a/crates/ide-assists/src/handlers/fix_visibility.rs b/crates/ide-assists/src/handlers/fix_visibility.rs
index 55de537debf3..0fd8057a3958 100644
--- a/crates/ide-assists/src/handlers/fix_visibility.rs
+++ b/crates/ide-assists/src/handlers/fix_visibility.rs
@@ -59,7 +59,7 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext<'_>)
 
     let (vis_owner, target, target_file, target_name) = target_data_for_def(ctx.db(), def)?;
 
-    let missing_visibility = if current_module.krate() == target_module.krate() {
+    let missing_visibility = if current_module.krate(ctx.db()) == target_module.krate(ctx.db()) {
         make::visibility_pub_crate()
     } else {
         make::visibility_pub()
@@ -70,7 +70,7 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext<'_>)
         Some(name) => {
             format!(
                 "Change visibility of {} to {missing_visibility}",
-                name.display(ctx.db(), current_module.krate().edition(ctx.db()))
+                name.display(ctx.db(), current_module.krate(ctx.db()).edition(ctx.db()))
             )
         }
     };
diff --git a/crates/ide-assists/src/handlers/generate_default_from_enum_variant.rs b/crates/ide-assists/src/handlers/generate_default_from_enum_variant.rs
index 056edb00b687..b4a17c376ac6 100644
--- a/crates/ide-assists/src/handlers/generate_default_from_enum_variant.rs
+++ b/crates/ide-assists/src/handlers/generate_default_from_enum_variant.rs
@@ -75,7 +75,7 @@ fn existing_default_impl(
 ) -> Option<()> {
     let variant = sema.to_def(variant)?;
     let enum_ = variant.parent_enum(sema.db);
-    let krate = enum_.module(sema.db).krate();
+    let krate = enum_.module(sema.db).krate(sema.db);
 
     let default_trait = FamousDefs(sema, krate).core_default_Default()?;
     let enum_type = enum_.ty(sema.db);
diff --git a/crates/ide-assists/src/handlers/generate_default_from_new.rs b/crates/ide-assists/src/handlers/generate_default_from_new.rs
index 47233fb399d7..48400d436aa6 100644
--- a/crates/ide-assists/src/handlers/generate_default_from_new.rs
+++ b/crates/ide-assists/src/handlers/generate_default_from_new.rs
@@ -137,7 +137,7 @@ fn is_default_implemented(ctx: &AssistContext<'_>, impl_: &Impl) -> bool {
     };
 
     let ty = impl_def.self_ty(db);
-    let krate = impl_def.module(db).krate();
+    let krate = impl_def.module(db).krate(ctx.db());
     let default = FamousDefs(&ctx.sema, krate).core_default_Default();
     let default_trait = match default {
         Some(value) => value,
diff --git a/crates/ide-assists/src/handlers/generate_delegate_methods.rs b/crates/ide-assists/src/handlers/generate_delegate_methods.rs
index b2e791abf72d..c1eb1a74ecde 100644
--- a/crates/ide-assists/src/handlers/generate_delegate_methods.rs
+++ b/crates/ide-assists/src/handlers/generate_delegate_methods.rs
@@ -57,7 +57,7 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
     let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
     let strukt_name = strukt.name()?;
     let current_module = ctx.sema.scope(strukt.syntax())?.module();
-    let current_edition = current_module.krate().edition(ctx.db());
+    let current_edition = current_module.krate(ctx.db()).edition(ctx.db());
 
     let (field_name, field_ty, target) = match ctx.find_node_at_offset::<ast::RecordField>() {
         Some(field) => {
diff --git a/crates/ide-assists/src/handlers/generate_delegate_trait.rs b/crates/ide-assists/src/handlers/generate_delegate_trait.rs
index e87dde5b8e42..a2d49063e69e 100644
--- a/crates/ide-assists/src/handlers/generate_delegate_trait.rs
+++ b/crates/ide-assists/src/handlers/generate_delegate_trait.rs
@@ -124,7 +124,7 @@ impl Field {
         let db = ctx.sema.db;
 
         let module = ctx.sema.file_to_module_def(ctx.vfs_file_id())?;
-        let edition = module.krate().edition(ctx.db());
+        let edition = module.krate(ctx.db()).edition(ctx.db());
 
         let (name, range, ty) = match f {
             Either::Left(f) => {
diff --git a/crates/ide-assists/src/handlers/generate_deref.rs b/crates/ide-assists/src/handlers/generate_deref.rs
index b02e3e435c81..494c87e6d136 100644
--- a/crates/ide-assists/src/handlers/generate_deref.rs
+++ b/crates/ide-assists/src/handlers/generate_deref.rs
@@ -57,8 +57,8 @@ fn generate_record_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
     };
 
     let module = ctx.sema.to_def(&strukt)?.module(ctx.db());
-    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));
-    let trait_ = deref_type_to_generate.to_trait(&ctx.sema, module.krate())?;
+    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate(ctx.db())));
+    let trait_ = deref_type_to_generate.to_trait(&ctx.sema, module.krate(ctx.db()))?;
     let trait_path = module.find_path(ctx.db(), ModuleDef::Trait(trait_), cfg)?;
 
     let field_type = field.ty()?;
@@ -77,7 +77,7 @@ fn generate_record_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
                 field_name.syntax(),
                 deref_type_to_generate,
                 trait_path,
-                module.krate().edition(ctx.db()),
+                module.krate(ctx.db()).edition(ctx.db()),
             )
         },
     )
@@ -99,8 +99,8 @@ fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()
     };
 
     let module = ctx.sema.to_def(&strukt)?.module(ctx.db());
-    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));
-    let trait_ = deref_type_to_generate.to_trait(&ctx.sema, module.krate())?;
+    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate(ctx.sema.db)));
+    let trait_ = deref_type_to_generate.to_trait(&ctx.sema, module.krate(ctx.db()))?;
     let trait_path = module.find_path(ctx.db(), ModuleDef::Trait(trait_), cfg)?;
 
     let field_type = field.ty()?;
@@ -118,7 +118,7 @@ fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()
                 field_list_index,
                 deref_type_to_generate,
                 trait_path,
-                module.krate().edition(ctx.db()),
+                module.krate(ctx.db()).edition(ctx.db()),
             )
         },
     )
@@ -163,7 +163,7 @@ fn existing_deref_impl(
     strukt: &ast::Struct,
 ) -> Option<DerefType> {
     let strukt = sema.to_def(strukt)?;
-    let krate = strukt.module(sema.db).krate();
+    let krate = strukt.module(sema.db).krate(sema.db);
 
     let deref_trait = FamousDefs(sema, krate).core_ops_Deref()?;
     let deref_mut_trait = FamousDefs(sema, krate).core_ops_DerefMut()?;
diff --git a/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs b/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
index 199c85d98d6f..24f271ded80b 100644
--- a/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
@@ -121,7 +121,7 @@ fn existing_from_impl(
 ) -> Option<()> {
     let db = sema.db;
     let variant = sema.to_def(variant)?;
-    let krate = variant.module(db).krate();
+    let krate = variant.module(db).krate(db);
     let from_trait = FamousDefs(sema, krate).core_convert_From()?;
     let interner = DbInterner::new_with(db, krate.base());
     use hir::next_solver::infer::DbInternerInferExt;
diff --git a/crates/ide-assists/src/handlers/generate_function.rs b/crates/ide-assists/src/handlers/generate_function.rs
index a9cf2c1bae1a..bd66c02b4150 100644
--- a/crates/ide-assists/src/handlers/generate_function.rs
+++ b/crates/ide-assists/src/handlers/generate_function.rs
@@ -71,7 +71,7 @@ fn gen_fn(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
         fn_target_info(ctx, path, &call, fn_name)?;
 
     if let Some(m) = target_module
-        && !is_editable_crate(m.krate(), ctx.db())
+        && !is_editable_crate(m.krate(ctx.db()), ctx.db())
     {
         return None;
     }
@@ -143,7 +143,7 @@ fn gen_method(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     let adt = receiver_ty.as_adt()?;
 
     let target_module = adt.module(ctx.sema.db);
-    if !is_editable_crate(target_module.krate(), ctx.db()) {
+    if !is_editable_crate(target_module.krate(ctx.db()), ctx.db()) {
         return None;
     }
 
@@ -241,7 +241,7 @@ impl FunctionBuilder {
     ) -> Option<Self> {
         let target_module =
             target_module.or_else(|| ctx.sema.scope(target.syntax()).map(|it| it.module()))?;
-        let target_edition = target_module.krate().edition(ctx.db());
+        let target_edition = target_module.krate(ctx.db()).edition(ctx.db());
 
         let current_module = ctx.sema.scope(call.syntax())?.module();
         let visibility = calculate_necessary_visibility(current_module, target_module, ctx);
@@ -311,7 +311,7 @@ impl FunctionBuilder {
         target_module: Module,
         target: GeneratedFunctionTarget,
     ) -> Option<Self> {
-        let target_edition = target_module.krate().edition(ctx.db());
+        let target_edition = target_module.krate(ctx.db()).edition(ctx.db());
 
         let current_module = ctx.sema.scope(call.syntax())?.module();
         let visibility = calculate_necessary_visibility(current_module, target_module, ctx);
@@ -546,7 +546,7 @@ fn assoc_fn_target_info(
     let current_module = ctx.sema.scope(call.syntax())?.module();
     let module = adt.module(ctx.sema.db);
     let target_module = if current_module == module { None } else { Some(module) };
-    if current_module.krate() != module.krate() {
+    if current_module.krate(ctx.db()) != module.krate(ctx.db()) {
         return None;
     }
     let (impl_, file) = get_adt_source(ctx, &adt, fn_name)?;
@@ -1149,7 +1149,10 @@ fn fn_arg_type(
             convert_reference_type(ty.strip_references(), ctx.db(), famous_defs)
                 .map(|conversion| {
                     conversion
-                        .convert_type(ctx.db(), target_module.krate().to_display_target(ctx.db()))
+                        .convert_type(
+                            ctx.db(),
+                            target_module.krate(ctx.db()).to_display_target(ctx.db()),
+                        )
                         .to_string()
                 })
                 .or_else(|| ty.display_source_code(ctx.db(), target_module.into(), true).ok())
@@ -1235,7 +1238,7 @@ fn calculate_necessary_visibility(
     let current_module = current_module.nearest_non_block_module(db);
     let target_module = target_module.nearest_non_block_module(db);
 
-    if target_module.krate() != current_module.krate() {
+    if target_module.krate(ctx.db()) != current_module.krate(ctx.db()) {
         Visibility::Pub
     } else if current_module.path_to_root(db).contains(&target_module) {
         Visibility::None
diff --git a/crates/ide-assists/src/handlers/generate_new.rs b/crates/ide-assists/src/handlers/generate_new.rs
index cd968b97105a..4b923ab556b8 100644
--- a/crates/ide-assists/src/handlers/generate_new.rs
+++ b/crates/ide-assists/src/handlers/generate_new.rs
@@ -77,14 +77,16 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
 
                 let item_in_ns = hir::ItemInNs::from(hir::ModuleDef::from(ty.as_adt()?));
 
-                let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(current_module.krate()));
+                let cfg = ctx
+                    .config
+                    .find_path_config(ctx.sema.is_nightly(current_module.krate(ctx.sema.db)));
                 let type_path = current_module.find_path(
                     ctx.sema.db,
                     item_for_path_search(ctx.sema.db, item_in_ns)?,
                     cfg,
                 )?;
 
-                let edition = current_module.krate().edition(ctx.db());
+                let edition = current_module.krate(ctx.db()).edition(ctx.db());
 
                 let expr = use_trivial_constructor(
                     ctx.sema.db,
diff --git a/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs b/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
index bdb42f9c1fae..d3022ceda379 100644
--- a/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
+++ b/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
@@ -178,7 +178,7 @@ fn make_constructors(
     types: &[ast::Type],
 ) -> Vec<Option<ast::Expr>> {
     let (db, sema) = (ctx.db(), &ctx.sema);
-    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));
+    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate(ctx.sema.db)));
     types
         .iter()
         .map(|ty| {
@@ -187,7 +187,7 @@ fn make_constructors(
                 return Some(make::expr_tuple([]).into());
             }
             let item_in_ns = ModuleDef::Adt(ty.as_adt()?).into();
-            let edition = module.krate().edition(db);
+            let edition = module.krate(db).edition(db);
 
             let ty_path = module.find_path(db, item_for_path_search(db, item_in_ns)?, cfg)?;
 
diff --git a/crates/ide-assists/src/handlers/inline_call.rs b/crates/ide-assists/src/handlers/inline_call.rs
index 5367350052cb..fa4f2a78c8b7 100644
--- a/crates/ide-assists/src/handlers/inline_call.rs
+++ b/crates/ide-assists/src/handlers/inline_call.rs
@@ -110,7 +110,7 @@ pub(crate) fn inline_into_callers(acc: &mut Assists, ctx: &AssistContext<'_>) ->
             let mut inline_refs_for_file = |file_id: EditionedFileId, refs: Vec<FileReference>| {
                 let file_id = file_id.file_id(ctx.db());
                 builder.edit_file(file_id);
-                let call_krate = ctx.sema.file_to_module_def(file_id).map(|it| it.krate());
+                let call_krate = ctx.sema.file_to_module_def(file_id).map(|it| it.krate(ctx.db()));
                 let count = refs.len();
                 // The collects are required as we are otherwise iterating while mutating 🙅‍♀️🙅‍♂️
                 let (name_refs, name_refs_use) = split_refs_and_uses(builder, refs, Some);
@@ -196,7 +196,7 @@ pub(crate) fn inline_call(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<
     let name_ref: ast::NameRef = ctx.find_node_at_offset()?;
     let call_info = CallInfo::from_name_ref(
         name_ref.clone(),
-        ctx.sema.file_to_module_def(ctx.vfs_file_id())?.krate().into(),
+        ctx.sema.file_to_module_def(ctx.vfs_file_id())?.krate(ctx.db()).into(),
     )?;
     let (function, label) = match &call_info.node {
         ast::CallableExpr::Call(call) => {
diff --git a/crates/ide-assists/src/handlers/inline_macro.rs b/crates/ide-assists/src/handlers/inline_macro.rs
index b09bef36ae15..280bd7f2ca9a 100644
--- a/crates/ide-assists/src/handlers/inline_macro.rs
+++ b/crates/ide-assists/src/handlers/inline_macro.rs
@@ -38,7 +38,7 @@ use crate::{AssistContext, AssistId, Assists};
 pub(crate) fn inline_macro(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     let unexpanded = ctx.find_node_at_offset::<ast::MacroCall>()?;
     let macro_call = ctx.sema.to_def(&unexpanded)?;
-    let target_crate_id = ctx.sema.file_to_module_def(ctx.vfs_file_id())?.krate().into();
+    let target_crate_id = ctx.sema.file_to_module_def(ctx.vfs_file_id())?.krate(ctx.db()).into();
     let text_range = unexpanded.syntax().text_range();
 
     acc.add(
diff --git a/crates/ide-assists/src/handlers/qualify_method_call.rs b/crates/ide-assists/src/handlers/qualify_method_call.rs
index d8dbefd59e28..495a84d62b07 100644
--- a/crates/ide-assists/src/handlers/qualify_method_call.rs
+++ b/crates/ide-assists/src/handlers/qualify_method_call.rs
@@ -42,10 +42,10 @@ pub(crate) fn qualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>) ->
     let resolved_call = ctx.sema.resolve_method_call(&call)?;
 
     let current_module = ctx.sema.scope(call.syntax())?.module();
-    let current_edition = current_module.krate().edition(ctx.db());
+    let current_edition = current_module.krate(ctx.db()).edition(ctx.db());
     let target_module_def = ModuleDef::from(resolved_call);
     let item_in_ns = ItemInNs::from(target_module_def);
-    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(current_module.krate()));
+    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(current_module.krate(ctx.sema.db)));
     let receiver_path = current_module.find_path(
         ctx.sema.db,
         item_for_path_search(ctx.sema.db, item_in_ns)?,
diff --git a/crates/ide-assists/src/handlers/qualify_path.rs b/crates/ide-assists/src/handlers/qualify_path.rs
index 8834ad97652e..b3cf2969650a 100644
--- a/crates/ide-assists/src/handlers/qualify_path.rs
+++ b/crates/ide-assists/src/handlers/qualify_path.rs
@@ -82,7 +82,7 @@ pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
     proposed_imports.dedup_by(|a, b| a.import_path == b.import_path);
 
     let current_edition =
-        current_module.map(|it| it.krate().edition(ctx.db())).unwrap_or(Edition::CURRENT);
+        current_module.map(|it| it.krate(ctx.db()).edition(ctx.db())).unwrap_or(Edition::CURRENT);
     // prioritize more relevant imports
     proposed_imports.sort_by_key(|import| {
         Reverse(super::auto_import::relevance_score(
diff --git a/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
index 2bf4406cc6a9..11b3fd22faa3 100644
--- a/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -69,7 +69,7 @@ pub(crate) fn replace_derive_with_manual_impl(
     let args = attr.token_tree()?;
 
     let current_module = ctx.sema.scope(adt.syntax())?.module();
-    let current_crate = current_module.krate();
+    let current_crate = current_module.krate(ctx.db());
     let current_edition = current_crate.edition(ctx.db());
     let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(current_crate));
 
@@ -193,7 +193,7 @@ fn impl_def_from_trait(
     let target_scope = sema.scope(annotated_name.syntax())?;
 
     // Keep assoc items of local crates even if they have #[doc(hidden)] attr.
-    let ignore_items = if trait_.module(sema.db).krate().origin(sema.db).is_local() {
+    let ignore_items = if trait_.module(sema.db).krate(sema.db).origin(sema.db).is_local() {
         IgnoreAssocItems::No
     } else {
         IgnoreAssocItems::DocHiddenAttrPresent
diff --git a/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
index e9f0e190d40f..009fc077ce6c 100644
--- a/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
@@ -58,7 +58,7 @@ pub(crate) fn replace_qualified_name_with_use(
     let path_to_qualifier = starts_with_name_ref
         .then(|| {
             let mod_ = ctx.sema.scope(original_path.syntax())?.module();
-            let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(mod_.krate()));
+            let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(mod_.krate(ctx.sema.db)));
             mod_.find_use_path(ctx.sema.db, module, ctx.config.insert_use.prefix_kind, cfg)
         })
         .flatten();
diff --git a/crates/ide-assists/src/handlers/term_search.rs b/crates/ide-assists/src/handlers/term_search.rs
index d64a76eb8b37..849dfa49ddb0 100644
--- a/crates/ide-assists/src/handlers/term_search.rs
+++ b/crates/ide-assists/src/handlers/term_search.rs
@@ -55,7 +55,7 @@ pub(crate) fn term_search(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<
             path.gen_source_code(
                 &scope,
                 &mut formatter,
-                ctx.config.find_path_config(ctx.sema.is_nightly(scope.module().krate())),
+                ctx.config.find_path_config(ctx.sema.is_nightly(scope.module().krate(ctx.sema.db))),
                 scope.krate().to_display_target(ctx.db()),
             )
             .ok()
diff --git a/crates/ide-assists/src/handlers/toggle_async_sugar.rs b/crates/ide-assists/src/handlers/toggle_async_sugar.rs
index fa6fca8150ac..fa6ccb9a5f12 100644
--- a/crates/ide-assists/src/handlers/toggle_async_sugar.rs
+++ b/crates/ide-assists/src/handlers/toggle_async_sugar.rs
@@ -132,7 +132,7 @@ pub(crate) fn desugar_async_into_impl_future(
 
     let scope = ctx.sema.scope(function.syntax())?;
     let module = scope.module();
-    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));
+    let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate(ctx.sema.db)));
     let future_trait = FamousDefs(&ctx.sema, scope.krate()).core_future_Future()?;
     let trait_path = module.find_path(ctx.db(), ModuleDef::Trait(future_trait), cfg)?;
     let edition = scope.krate().edition(ctx.db());
diff --git a/crates/ide-completion/src/completions.rs b/crates/ide-completion/src/completions.rs
index abae3cb36802..b28764f6fc5a 100644
--- a/crates/ide-completion/src/completions.rs
+++ b/crates/ide-completion/src/completions.rs
@@ -190,7 +190,7 @@ impl Completions {
         path_ctx: &PathCompletionCtx<'_>,
     ) {
         ctx.process_all_names(&mut |name, res, doc_aliases| match res {
-            ScopeDef::ModuleDef(hir::ModuleDef::Module(m)) if m.is_crate_root() => {
+            ScopeDef::ModuleDef(hir::ModuleDef::Module(m)) if m.is_crate_root(ctx.db) => {
                 self.add_module(ctx, path_ctx, m, name, doc_aliases);
             }
             _ => (),
diff --git a/crates/ide-completion/src/completions/attribute/derive.rs b/crates/ide-completion/src/completions/attribute/derive.rs
index 267d92b6c090..57ea609a40e0 100644
--- a/crates/ide-completion/src/completions/attribute/derive.rs
+++ b/crates/ide-completion/src/completions/attribute/derive.rs
@@ -56,7 +56,7 @@ pub(crate) fn complete_derive_path(
                     _ => return,
                 };
 
-                match (core, mac.module(ctx.db).krate()) {
+                match (core, mac.module(ctx.db).krate(ctx.db)) {
                     // show derive dependencies for `core`/`std` derives
                     (Some(core), mac_krate) if core == mac_krate => {}
                     _ => return acc.add_macro(ctx, path_ctx, mac, name),
diff --git a/crates/ide-completion/src/completions/attribute/macro_use.rs b/crates/ide-completion/src/completions/attribute/macro_use.rs
index 0641a4f6c3fe..136315c61f58 100644
--- a/crates/ide-completion/src/completions/attribute/macro_use.rs
+++ b/crates/ide-completion/src/completions/attribute/macro_use.rs
@@ -15,7 +15,7 @@ pub(super) fn complete_macro_use(
     let Some(extern_crate) = ctx.sema.to_def(extern_crate) else { return };
     let Some(krate) = extern_crate.resolved_crate(ctx.db) else { return };
 
-    for mod_def in krate.root_module().declarations(ctx.db) {
+    for mod_def in krate.root_module(ctx.db).declarations(ctx.db) {
         if let ModuleDef::Macro(mac) = mod_def {
             let mac_name = mac.name(ctx.db);
             let mac_name = mac_name.as_str();
diff --git a/crates/ide-completion/src/lib.rs b/crates/ide-completion/src/lib.rs
index 6dfa183136bd..31e33db104c7 100644
--- a/crates/ide-completion/src/lib.rs
+++ b/crates/ide-completion/src/lib.rs
@@ -286,7 +286,7 @@ pub fn resolve_completion_edits(
     let scope = ImportScope::find_insert_use_container(position_for_import, &sema)?;
 
     let current_module = sema.scope(position_for_import)?.module();
-    let current_crate = current_module.krate();
+    let current_crate = current_module.krate(db);
     let current_edition = current_crate.edition(db);
     let new_ast = scope.clone_for_update();
     let mut import_insert = TextEdit::builder();
diff --git a/crates/ide-completion/src/render/variant.rs b/crates/ide-completion/src/render/variant.rs
index cfd6340f1eea..ce35ab135f3c 100644
--- a/crates/ide-completion/src/render/variant.rs
+++ b/crates/ide-completion/src/render/variant.rs
@@ -106,7 +106,7 @@ pub(crate) fn visible_fields(
         .collect::<Vec<_>>();
     let has_invisible_field = n_fields - fields.len() > 0;
     let is_foreign_non_exhaustive =
-        item.attrs(ctx.db).is_non_exhaustive() && item.krate(ctx.db) != module.krate();
+        item.attrs(ctx.db).is_non_exhaustive() && item.krate(ctx.db) != module.krate(ctx.db);
     let fields_omitted = has_invisible_field || is_foreign_non_exhaustive;
     Some((fields, fields_omitted))
 }
diff --git a/crates/ide-completion/src/tests/flyimport.rs b/crates/ide-completion/src/tests/flyimport.rs
index 94530bf51d5f..cf86618de69e 100644
--- a/crates/ide-completion/src/tests/flyimport.rs
+++ b/crates/ide-completion/src/tests/flyimport.rs
@@ -780,9 +780,9 @@ fn main() {
 }
 "#,
         expect![[r#"
-            me random_method(…) (use dep::test_mod::TestTrait) fn(&self) DEPRECATED
             fn weird_function() (use dep::test_mod::TestTrait)      fn() DEPRECATED
             ct SPECIAL_CONST (use dep::test_mod::TestTrait)           u8 DEPRECATED
+            me random_method(…) (use dep::test_mod::TestTrait) fn(&self) DEPRECATED
         "#]],
     );
 }
diff --git a/crates/ide-db/src/defs.rs b/crates/ide-db/src/defs.rs
index 9ce85b2bf330..788f9b73fa19 100644
--- a/crates/ide-db/src/defs.rs
+++ b/crates/ide-db/src/defs.rs
@@ -64,9 +64,9 @@ impl Definition {
 
     pub fn krate(&self, db: &RootDatabase) -> Option<Crate> {
         Some(match self {
-            Definition::Module(m) => m.krate(),
+            Definition::Module(m) => m.krate(db),
             &Definition::Crate(it) => it,
-            _ => self.module(db)?.krate(),
+            _ => self.module(db)?.krate(db),
         })
     }
 
@@ -93,7 +93,7 @@ impl Definition {
             Definition::ExternCrateDecl(it) => it.module(db),
             Definition::DeriveHelper(it) => it.derive().module(db),
             Definition::InlineAsmOperand(it) => it.parent(db).module(db),
-            Definition::ToolModule(t) => t.krate().root_module(),
+            Definition::ToolModule(t) => t.krate().root_module(db),
             Definition::BuiltinAttr(_)
             | Definition::BuiltinType(_)
             | Definition::BuiltinLifetime(_)
@@ -374,7 +374,7 @@ pub fn find_std_module(
 ) -> Option<hir::Module> {
     let db = famous_defs.0.db;
     let std_crate = famous_defs.std()?;
-    let std_root_module = std_crate.root_module();
+    let std_root_module = std_crate.root_module(famous_defs.0.db);
     std_root_module.children(db).find(|module| {
         module.name(db).is_some_and(|module| module.display(db, edition).to_string() == name)
     })
diff --git a/crates/ide-db/src/famous_defs.rs b/crates/ide-db/src/famous_defs.rs
index 8eea2b81bab6..f28ce53e91c0 100644
--- a/crates/ide-db/src/famous_defs.rs
+++ b/crates/ide-db/src/famous_defs.rs
@@ -232,7 +232,7 @@ impl FamousDefs<'_, '_> {
             lang_crate => lang_crate,
         };
         let std_crate = self.find_lang_crate(lang_crate)?;
-        let mut module = std_crate.root_module();
+        let mut module = std_crate.root_module(db);
         for segment in path {
             module = module.children(db).find_map(|child| {
                 let name = child.name(db)?;
diff --git a/crates/ide-db/src/helpers.rs b/crates/ide-db/src/helpers.rs
index 1e54058dd16c..08cf1eeed33b 100644
--- a/crates/ide-db/src/helpers.rs
+++ b/crates/ide-db/src/helpers.rs
@@ -80,7 +80,7 @@ pub fn visit_file_defs(
     }
     module.impl_defs(db).into_iter().for_each(|impl_| cb(impl_.into()));
 
-    let is_root = module.is_crate_root();
+    let is_root = module.is_crate_root(db);
     module
         .legacy_macros(db)
         .into_iter()
diff --git a/crates/ide-db/src/imports/import_assets.rs b/crates/ide-db/src/imports/import_assets.rs
index c49ade235043..90e3bb61f44d 100644
--- a/crates/ide-db/src/imports/import_assets.rs
+++ b/crates/ide-db/src/imports/import_assets.rs
@@ -315,7 +315,7 @@ impl<'db> ImportAssets<'db> {
             allow_unstable: sema.is_nightly(scope.krate()),
         };
         let db = sema.db;
-        let krate = self.module_with_candidate.krate();
+        let krate = self.module_with_candidate.krate(sema.db);
         let scope_definitions = self.scope_definitions(sema);
         let mod_path = |item| {
             get_mod_path(
diff --git a/crates/ide-db/src/path_transform.rs b/crates/ide-db/src/path_transform.rs
index bc5958ec5854..48305c20823c 100644
--- a/crates/ide-db/src/path_transform.rs
+++ b/crates/ide-db/src/path_transform.rs
@@ -152,7 +152,7 @@ impl<'a> PathTransform<'a> {
                     db,
                     node,
                     &db.expansion_span_map(file_id),
-                    self.target_scope.module().krate().into(),
+                    self.target_scope.module().krate(db).into(),
                 )
             }
         }
@@ -174,7 +174,7 @@ impl<'a> PathTransform<'a> {
         let mut type_substs: FxHashMap<hir::TypeParam, ast::Type> = Default::default();
         let mut const_substs: FxHashMap<hir::ConstParam, SyntaxNode> = Default::default();
         let mut defaulted_params: Vec<DefaultedParam> = Default::default();
-        let target_edition = target_module.krate().edition(self.source_scope.db);
+        let target_edition = target_module.krate(db).edition(self.source_scope.db);
         self.generic_def
             .into_iter()
             .flat_map(|it| it.type_or_const_params(db))
@@ -219,7 +219,7 @@ impl<'a> PathTransform<'a> {
                 }
                 (Either::Left(k), None) => {
                     if let Some(default) =
-                        k.default(db, target_module.krate().to_display_target(db))
+                        k.default(db, target_module.krate(db).to_display_target(db))
                         && let Some(default) = default.expr()
                     {
                         const_substs.insert(k, default.syntax().clone_for_update());
diff --git a/crates/ide-db/src/rename.rs b/crates/ide-db/src/rename.rs
index a8800c142a22..82eee69f0d25 100644
--- a/crates/ide-db/src/rename.rs
+++ b/crates/ide-db/src/rename.rs
@@ -246,7 +246,7 @@ fn rename_mod(
 ) -> Result<SourceChange> {
     let mut source_change = SourceChange::default();
 
-    if module.is_crate_root() {
+    if module.is_crate_root(sema.db) {
         return Ok(source_change);
     }
 
diff --git a/crates/ide-db/src/search.rs b/crates/ide-db/src/search.rs
index f52b34500792..a48438cfa86f 100644
--- a/crates/ide-db/src/search.rs
+++ b/crates/ide-db/src/search.rs
@@ -294,9 +294,9 @@ impl Definition {
 
         // def is crate root
         if let &Definition::Module(module) = self
-            && module.is_crate_root()
+            && module.is_crate_root(db)
         {
-            return SearchScope::reverse_dependencies(db, module.krate());
+            return SearchScope::reverse_dependencies(db, module.krate(db));
         }
 
         let module = match self.module(db) {
@@ -367,22 +367,22 @@ impl Definition {
             return match macro_def.kind(db) {
                 hir::MacroKind::Declarative => {
                     if macro_def.attrs(db).is_macro_export() {
-                        SearchScope::reverse_dependencies(db, module.krate())
+                        SearchScope::reverse_dependencies(db, module.krate(db))
                     } else {
-                        SearchScope::krate(db, module.krate())
+                        SearchScope::krate(db, module.krate(db))
                     }
                 }
                 hir::MacroKind::AttrBuiltIn
                 | hir::MacroKind::DeriveBuiltIn
                 | hir::MacroKind::DeclarativeBuiltIn => SearchScope::crate_graph(db),
                 hir::MacroKind::Derive | hir::MacroKind::Attr | hir::MacroKind::ProcMacro => {
-                    SearchScope::reverse_dependencies(db, module.krate())
+                    SearchScope::reverse_dependencies(db, module.krate(db))
                 }
             };
         }
 
         if let Definition::DeriveHelper(_) = self {
-            return SearchScope::reverse_dependencies(db, module.krate());
+            return SearchScope::reverse_dependencies(db, module.krate(db));
         }
 
         if let Some(vis) = self.visibility(db) {
@@ -391,7 +391,7 @@ impl Definition {
                     SearchScope::module_and_children(db, module.into())
                 }
                 Visibility::PubCrate(krate) => SearchScope::krate(db, krate.into()),
-                Visibility::Public => SearchScope::reverse_dependencies(db, module.krate()),
+                Visibility::Public => SearchScope::reverse_dependencies(db, module.krate(db)),
             };
         }
 
@@ -907,13 +907,13 @@ impl<'a> FindUsages<'a> {
                 }
             }
             // special case crate modules as these do not have a proper name
-            (_, Definition::Module(module)) if module.is_crate_root() => {
+            (_, Definition::Module(module)) if module.is_crate_root(self.sema.db) => {
                 // FIXME: This assumes the crate name is always equal to its display name when it
                 // really isn't
                 // we should instead look at the dependency edge name and recursively search our way
                 // up the ancestors
                 module
-                    .krate()
+                    .krate(self.sema.db)
                     .display_name(self.sema.db)
                     .map(|crate_name| crate_name.crate_name().symbol().as_str().into())
             }
@@ -1002,7 +1002,7 @@ impl<'a> FindUsages<'a> {
             let scope =
                 search_scope.intersection(&SearchScope::module_and_children(self.sema.db, module));
 
-            let is_crate_root = module.is_crate_root().then(|| Finder::new("crate"));
+            let is_crate_root = module.is_crate_root(self.sema.db).then(|| Finder::new("crate"));
             let finder = &Finder::new("super");
 
             for (text, file_id, search_range) in Self::scope_files(sema.db, &scope) {
diff --git a/crates/ide-db/src/symbol_index.rs b/crates/ide-db/src/symbol_index.rs
index ef67fbf6fe00..c5ead45a20ae 100644
--- a/crates/ide-db/src/symbol_index.rs
+++ b/crates/ide-db/src/symbol_index.rs
@@ -241,7 +241,7 @@ impl SymbolIndex {
                 SymbolIndex::new(SymbolCollector::new_module(
                     db,
                     module,
-                    !module.krate().origin(db).is_local(),
+                    !module.krate(db).origin(db).is_local(),
                 ))
             })
         }
diff --git a/crates/ide-db/src/test_data/test_doc_alias.txt b/crates/ide-db/src/test_data/test_doc_alias.txt
index 427a51055948..c8a9231fa99e 100644
--- a/crates/ide-db/src/test_data/test_doc_alias.txt
+++ b/crates/ide-db/src/test_data/test_doc_alias.txt
@@ -1,12 +1,8 @@
 [
     (
         Module {
-            id: ModuleId {
-                krate: Crate(
-                    Id(2c00),
-                ),
-                block: None,
-                local_id: Idx::<ModuleData>(0),
+            id: ModuleIdLt {
+                [salsa id]: Id(3800),
             },
         },
         [
@@ -16,7 +12,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                3801,
+                                3c01,
                             ),
                         },
                     ),
@@ -50,7 +46,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                3800,
+                                3c00,
                             ),
                         },
                     ),
@@ -84,7 +80,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                3800,
+                                3c00,
                             ),
                         },
                     ),
@@ -118,7 +114,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                3800,
+                                3c00,
                             ),
                         },
                     ),
@@ -152,7 +148,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                3800,
+                                3c00,
                             ),
                         },
                     ),
@@ -186,7 +182,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                3801,
+                                3c01,
                             ),
                         },
                     ),
@@ -220,7 +216,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                3800,
+                                3c00,
                             ),
                         },
                     ),
diff --git a/crates/ide-db/src/test_data/test_symbol_index_collection.txt b/crates/ide-db/src/test_data/test_symbol_index_collection.txt
index cc130194cb05..cc879cf84fc6 100644
--- a/crates/ide-db/src/test_data/test_symbol_index_collection.txt
+++ b/crates/ide-db/src/test_data/test_symbol_index_collection.txt
@@ -1,12 +1,8 @@
 [
     (
         Module {
-            id: ModuleId {
-                krate: Crate(
-                    Id(2c00),
-                ),
-                block: None,
-                local_id: Idx::<ModuleData>(0),
+            id: ModuleIdLt {
+                [salsa id]: Id(3800),
             },
         },
         [
@@ -15,7 +11,7 @@
                 def: Variant(
                     Variant {
                         id: EnumVariantId(
-                            7800,
+                            7c00,
                         ),
                     },
                 ),
@@ -49,7 +45,7 @@
                 def: TypeAlias(
                     TypeAlias {
                         id: TypeAliasId(
-                            6c00,
+                            7000,
                         ),
                     },
                 ),
@@ -81,7 +77,7 @@
                 def: Variant(
                     Variant {
                         id: EnumVariantId(
-                            7801,
+                            7c01,
                         ),
                     },
                 ),
@@ -115,7 +111,7 @@
                 def: Const(
                     Const {
                         id: ConstId(
-                            6400,
+                            6800,
                         ),
                     },
                 ),
@@ -147,7 +143,7 @@
                 def: Const(
                     Const {
                         id: ConstId(
-                            6402,
+                            6802,
                         ),
                     },
                 ),
@@ -180,7 +176,7 @@
                     Enum(
                         Enum {
                             id: EnumId(
-                                5000,
+                                5400,
                             ),
                         },
                     ),
@@ -214,7 +210,7 @@
                     Macro {
                         id: Macro2Id(
                             Macro2Id(
-                                4c00,
+                                5000,
                             ),
                         ),
                     },
@@ -248,7 +244,7 @@
                     Macro {
                         id: Macro2Id(
                             Macro2Id(
-                                4c00,
+                                5000,
                             ),
                         ),
                     },
@@ -281,7 +277,7 @@
                 def: Static(
                     Static {
                         id: StaticId(
-                            6800,
+                            6c00,
                         ),
                     },
                 ),
@@ -314,7 +310,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                4801,
+                                4c01,
                             ),
                         },
                     ),
@@ -348,7 +344,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                4800,
+                                4c00,
                             ),
                         },
                     ),
@@ -356,7 +352,7 @@
                 loc: DeclarationLocation {
                     hir_file_id: MacroFile(
                         MacroCallId(
-                            Id(4000),
+                            Id(4400),
                         ),
                     ),
                     ptr: SyntaxNodePtr {
@@ -382,7 +378,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                4805,
+                                4c05,
                             ),
                         },
                     ),
@@ -418,7 +414,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                4806,
+                                4c06,
                             ),
                         },
                     ),
@@ -454,7 +450,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                4807,
+                                4c07,
                             ),
                         },
                     ),
@@ -488,7 +484,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                4802,
+                                4c02,
                             ),
                         },
                     ),
@@ -521,7 +517,7 @@
                 def: Trait(
                     Trait {
                         id: TraitId(
-                            5c00,
+                            6000,
                         ),
                     },
                 ),
@@ -554,7 +550,7 @@
                     Macro {
                         id: Macro2Id(
                             Macro2Id(
-                                4c00,
+                                5000,
                             ),
                         ),
                     },
@@ -588,7 +584,7 @@
                     Union(
                         Union {
                             id: UnionId(
-                                5400,
+                                5800,
                             ),
                         },
                     ),
@@ -620,12 +616,8 @@
                 name: "a_mod",
                 def: Module(
                     Module {
-                        id: ModuleId {
-                            krate: Crate(
-                                Id(2c00),
-                            ),
-                            block: None,
-                            local_id: Idx::<ModuleData>(1),
+                        id: ModuleIdLt {
+                            [salsa id]: Id(3801),
                         },
                     },
                 ),
@@ -656,12 +648,8 @@
                 name: "b_mod",
                 def: Module(
                     Module {
-                        id: ModuleId {
-                            krate: Crate(
-                                Id(2c00),
-                            ),
-                            block: None,
-                            local_id: Idx::<ModuleData>(2),
+                        id: ModuleIdLt {
+                            [salsa id]: Id(3802),
                         },
                     },
                 ),
@@ -694,7 +682,7 @@
                     Macro {
                         id: MacroRulesId(
                             MacroRulesId(
-                                3c01,
+                                4001,
                             ),
                         ),
                     },
@@ -727,7 +715,7 @@
                 def: Function(
                     Function {
                         id: FunctionId(
-                            6002,
+                            6402,
                         ),
                     },
                 ),
@@ -761,7 +749,7 @@
                 def: Function(
                     Function {
                         id: FunctionId(
-                            6001,
+                            6401,
                         ),
                     },
                 ),
@@ -796,7 +784,7 @@
                     Macro {
                         id: MacroRulesId(
                             MacroRulesId(
-                                3c00,
+                                4000,
                             ),
                         ),
                     },
@@ -829,7 +817,7 @@
                 def: Function(
                     Function {
                         id: FunctionId(
-                            6000,
+                            6400,
                         ),
                     },
                 ),
@@ -862,7 +850,7 @@
                     Macro {
                         id: MacroRulesId(
                             MacroRulesId(
-                                3c01,
+                                4001,
                             ),
                         ),
                     },
@@ -895,7 +883,7 @@
                 def: Function(
                     Function {
                         id: FunctionId(
-                            6003,
+                            6403,
                         ),
                     },
                 ),
@@ -928,12 +916,8 @@
     ),
     (
         Module {
-            id: ModuleId {
-                krate: Crate(
-                    Id(2c00),
-                ),
-                block: None,
-                local_id: Idx::<ModuleData>(1),
+            id: ModuleIdLt {
+                [salsa id]: Id(3801),
             },
         },
         [
@@ -943,7 +927,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                4803,
+                                4c03,
                             ),
                         },
                     ),
@@ -975,12 +959,8 @@
     ),
     (
         Module {
-            id: ModuleId {
-                krate: Crate(
-                    Id(2c00),
-                ),
-                block: None,
-                local_id: Idx::<ModuleData>(2),
+            id: ModuleIdLt {
+                [salsa id]: Id(3802),
             },
         },
         [
@@ -989,7 +969,7 @@
                 def: Trait(
                     Trait {
                         id: TraitId(
-                            5c00,
+                            6000,
                         ),
                     },
                 ),
@@ -1022,7 +1002,7 @@
                     Macro {
                         id: Macro2Id(
                             Macro2Id(
-                                4c00,
+                                5000,
                             ),
                         ),
                     },
@@ -1056,7 +1036,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                4804,
+                                4c04,
                             ),
                         },
                     ),
@@ -1090,7 +1070,7 @@
                     Macro {
                         id: Macro2Id(
                             Macro2Id(
-                                4c00,
+                                5000,
                             ),
                         ),
                     },
@@ -1124,7 +1104,7 @@
                     Struct(
                         Struct {
                             id: StructId(
-                                4804,
+                                4c04,
                             ),
                         },
                     ),
diff --git a/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt b/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt
index 3ab837aa613f..dc512fe1b87a 100644
--- a/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt
+++ b/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt
@@ -5,7 +5,7 @@
             Struct(
                 Struct {
                     id: StructId(
-                        3800,
+                        3c00,
                     ),
                 },
             ),
diff --git a/crates/ide-db/src/test_data/test_symbols_with_imports.txt b/crates/ide-db/src/test_data/test_symbols_with_imports.txt
index a6a808d616a7..0b2522775d4d 100644
--- a/crates/ide-db/src/test_data/test_symbols_with_imports.txt
+++ b/crates/ide-db/src/test_data/test_symbols_with_imports.txt
@@ -5,7 +5,7 @@
             Struct(
                 Struct {
                     id: StructId(
-                        3800,
+                        3c00,
                     ),
                 },
             ),
@@ -39,7 +39,7 @@
             Struct(
                 Struct {
                     id: StructId(
-                        3800,
+                        3c00,
                     ),
                 },
             ),
diff --git a/crates/ide-db/src/traits.rs b/crates/ide-db/src/traits.rs
index 7b9fdb1e1cf3..7200e7fbe5ae 100644
--- a/crates/ide-db/src/traits.rs
+++ b/crates/ide-db/src/traits.rs
@@ -34,7 +34,7 @@ pub fn get_missing_assoc_items(
     // may share the same name as a function or constant.
     let mut impl_fns_consts = FxHashSet::default();
     let mut impl_type = FxHashSet::default();
-    let edition = imp.module(sema.db).krate().edition(sema.db);
+    let edition = imp.module(sema.db).krate(sema.db).edition(sema.db);
 
     for item in imp.items(sema.db) {
         match item {
diff --git a/crates/ide-diagnostics/src/handlers/missing_fields.rs b/crates/ide-diagnostics/src/handlers/missing_fields.rs
index ab7256d63c40..2a251382d465 100644
--- a/crates/ide-diagnostics/src/handlers/missing_fields.rs
+++ b/crates/ide-diagnostics/src/handlers/missing_fields.rs
@@ -221,8 +221,8 @@ fn get_default_constructor(
     let krate = ctx
         .sema
         .file_to_module_def(d.file.original_file(ctx.sema.db).file_id(ctx.sema.db))?
-        .krate();
-    let module = krate.root_module();
+        .krate(ctx.sema.db);
+    let module = krate.root_module(ctx.sema.db);
 
     // Look for a ::new() associated function
     let has_new_func = ty
diff --git a/crates/ide-diagnostics/src/handlers/private_field.rs b/crates/ide-diagnostics/src/handlers/private_field.rs
index 23f046007592..90c27bdcef79 100644
--- a/crates/ide-diagnostics/src/handlers/private_field.rs
+++ b/crates/ide-diagnostics/src/handlers/private_field.rs
@@ -37,7 +37,7 @@ pub(crate) fn field_is_private_fixes(
     fix_range: TextRange,
 ) -> Option<Vec<Assist>> {
     let def_crate = private_field.krate(sema.db);
-    let usage_crate = sema.file_to_module_def(usage_file_id.file_id(sema.db))?.krate();
+    let usage_crate = sema.file_to_module_def(usage_file_id.file_id(sema.db))?.krate(sema.db);
     let mut visibility_text = if usage_crate == def_crate { "pub(crate) " } else { "pub " };
 
     let source = private_field.source(sema.db)?;
diff --git a/crates/ide-diagnostics/src/handlers/trait_impl_redundant_assoc_item.rs b/crates/ide-diagnostics/src/handlers/trait_impl_redundant_assoc_item.rs
index fc2648efb407..cb3aac3717f8 100644
--- a/crates/ide-diagnostics/src/handlers/trait_impl_redundant_assoc_item.rs
+++ b/crates/ide-diagnostics/src/handlers/trait_impl_redundant_assoc_item.rs
@@ -83,7 +83,7 @@ fn quickfix_for_redundant_assoc_item(
         let root = db.parse_or_expand(d.file_id);
         // don't modify trait def in outer crate
         let current_crate = ctx.sema.scope(&d.impl_.syntax_node_ptr().to_node(&root))?.krate();
-        let trait_def_crate = d.trait_.module(db).krate();
+        let trait_def_crate = d.trait_.module(db).krate(db);
         if trait_def_crate != current_crate {
             return None;
         }
diff --git a/crates/ide-diagnostics/src/handlers/unlinked_file.rs b/crates/ide-diagnostics/src/handlers/unlinked_file.rs
index 3a6e480f55ed..1283a11700e1 100644
--- a/crates/ide-diagnostics/src/handlers/unlinked_file.rs
+++ b/crates/ide-diagnostics/src/handlers/unlinked_file.rs
@@ -3,7 +3,7 @@
 use std::iter;
 
 use hir::crate_def_map;
-use hir::{DefMap, InFile, ModuleSource};
+use hir::{InFile, ModuleSource};
 use ide_db::base_db::RootQueryDb;
 use ide_db::text_edit::TextEdit;
 use ide_db::{
@@ -106,7 +106,7 @@ fn fixes(
         // FIXME: This shouldnt need to access the crate def map directly
         let crate_def_map = crate_def_map(ctx.sema.db, krate);
 
-        let root_module = &crate_def_map[DefMap::ROOT];
+        let root_module = &crate_def_map[crate_def_map.root_module_id()];
         let Some(root_file_id) = root_module.origin.file_id() else { continue };
         let Some(crate_root_path) = source_root.path_for_file(&root_file_id.file_id(ctx.sema.db))
         else {
diff --git a/crates/ide-diagnostics/src/handlers/unresolved_field.rs b/crates/ide-diagnostics/src/handlers/unresolved_field.rs
index 358e0c43c2a9..59ec259adf36 100644
--- a/crates/ide-diagnostics/src/handlers/unresolved_field.rs
+++ b/crates/ide-diagnostics/src/handlers/unresolved_field.rs
@@ -83,7 +83,7 @@ fn field_fix(ctx: &DiagnosticsContext<'_>, d: &hir::UnresolvedField<'_>) -> Opti
         make::ty("()")
     };
 
-    if !is_editable_crate(target_module.krate(), ctx.sema.db)
+    if !is_editable_crate(target_module.krate(ctx.sema.db), ctx.sema.db)
         || SyntaxKind::from_keyword(field_name, ctx.edition).is_some()
     {
         return None;
diff --git a/crates/ide-diagnostics/src/lib.rs b/crates/ide-diagnostics/src/lib.rs
index c7827f13f409..fe04bd175c96 100644
--- a/crates/ide-diagnostics/src/lib.rs
+++ b/crates/ide-diagnostics/src/lib.rs
@@ -342,12 +342,12 @@ pub fn semantic_diagnostics(
     let module = sema.file_to_module_def(file_id);
 
     let is_nightly = matches!(
-        module.and_then(|m| db.toolchain_channel(m.krate().into())),
+        module.and_then(|m| db.toolchain_channel(m.krate(db).into())),
         Some(ReleaseChannel::Nightly) | None
     );
 
     let krate = match module {
-        Some(module) => module.krate(),
+        Some(module) => module.krate(db),
         None => {
             match db.all_crates().last() {
                 Some(last) => (*last).into(),
diff --git a/crates/ide/src/expand_macro.rs b/crates/ide/src/expand_macro.rs
index 9d38a860a08d..d43f13b79dfc 100644
--- a/crates/ide/src/expand_macro.rs
+++ b/crates/ide/src/expand_macro.rs
@@ -28,7 +28,7 @@ pub(crate) fn expand_macro(db: &RootDatabase, position: FilePosition) -> Option<
     let sema = Semantics::new(db);
     let file_id = sema.attach_first_edition(position.file_id);
     let file = sema.parse(file_id);
-    let krate = sema.file_to_module_def(file_id.file_id(db))?.krate().into();
+    let krate = sema.file_to_module_def(file_id.file_id(db))?.krate(db).into();
 
     let tok = pick_best_token(file.syntax().token_at_offset(position.offset), |kind| match kind {
         SyntaxKind::IDENT => 1,
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index e1db370d4462..b00aa4d0ca67 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -139,7 +139,7 @@ pub(crate) fn goto_definition(
             if let Definition::ExternCrateDecl(crate_def) = def {
                 return crate_def
                     .resolved_crate(db)
-                    .map(|it| it.root_module().to_nav(sema.db))
+                    .map(|it| it.root_module(db).to_nav(db))
                     .into_iter()
                     .flatten()
                     .collect();
@@ -262,7 +262,7 @@ fn try_lookup_macro_def_in_macro_use(
     let extern_crate = sema.to_def(&extern_crate)?;
     let krate = extern_crate.resolved_crate(sema.db)?;
 
-    for mod_def in krate.root_module().declarations(sema.db) {
+    for mod_def in krate.root_module(sema.db).declarations(sema.db) {
         if let ModuleDef::Macro(mac) = mod_def
             && mac.name(sema.db).as_str() == token.text()
             && let Some(nav) = mac.try_to_nav(sema)
diff --git a/crates/ide/src/goto_implementation.rs b/crates/ide/src/goto_implementation.rs
index a29da4f25803..4bf9b82cc877 100644
--- a/crates/ide/src/goto_implementation.rs
+++ b/crates/ide/src/goto_implementation.rs
@@ -384,7 +384,7 @@ trait Bar {}
 
 fn test() {
     #[derive(Copy)]
-   // ^^^^^^^^^^^^
+          // ^^^^
     struct Foo$0;
 
     impl Foo {}
diff --git a/crates/ide/src/hover/render.rs b/crates/ide/src/hover/render.rs
index a8929859bc87..9dc72a87af16 100644
--- a/crates/ide/src/hover/render.rs
+++ b/crates/ide/src/hover/render.rs
@@ -464,7 +464,7 @@ pub(super) fn path(
     item_name: Option<String>,
     edition: Edition,
 ) -> String {
-    let crate_name = module.krate().display_name(db).as_ref().map(|it| it.to_string());
+    let crate_name = module.krate(db).display_name(db).as_ref().map(|it| it.to_string());
     let module_path = module
         .path_to_root(db)
         .into_iter()
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 260da900f402..03674978d53d 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -811,7 +811,7 @@ fn hint_iterator<'db>(
 ) -> Option<(hir::Trait, hir::TypeAlias, hir::Type<'db>)> {
     let db = sema.db;
     let strukt = ty.strip_references().as_adt()?;
-    let krate = strukt.module(db).krate();
+    let krate = strukt.module(db).krate(db);
     if krate != famous_defs.core()? {
         return None;
     }
diff --git a/crates/ide/src/interpret.rs b/crates/ide/src/interpret.rs
index 05cd145033bf..791da00bb695 100644
--- a/crates/ide/src/interpret.rs
+++ b/crates/ide/src/interpret.rs
@@ -45,7 +45,7 @@ fn find_and_interpret(db: &RootDatabase, position: FilePosition) -> Option<(Dura
             None => format!("file://{path} range {text_range:?}"),
         }
     };
-    let display_target = def.module(db).krate().to_display_target(db);
+    let display_target = def.module(db).krate(db).to_display_target(db);
     let start_time = Instant::now();
     let res = match def {
         DefWithBody::Function(it) => it.eval(db, span_formatter),
diff --git a/crates/ide/src/moniker.rs b/crates/ide/src/moniker.rs
index 4aa9eb98a1e1..1c1389ca7a15 100644
--- a/crates/ide/src/moniker.rs
+++ b/crates/ide/src/moniker.rs
@@ -284,10 +284,10 @@ fn def_to_non_local_moniker(
     from_crate: Crate,
 ) -> Option<Moniker> {
     let module = match definition {
-        Definition::Module(module) if module.is_crate_root() => module,
+        Definition::Module(module) if module.is_crate_root(db) => module,
         _ => definition.module(db)?,
     };
-    let krate = module.krate();
+    let krate = module.krate(db);
     let edition = krate.edition(db);
 
     // Add descriptors for this definition and every enclosing definition.
@@ -321,7 +321,7 @@ fn def_to_non_local_moniker(
                     });
                 } else {
                     match def {
-                        Definition::Module(module) if module.is_crate_root() => {
+                        Definition::Module(module) if module.is_crate_root(db) => {
                             // only include `crate` namespace by itself because we prefer
                             // `rust-analyzer cargo foo . bar/` over `rust-analyzer cargo foo . crate/bar/`
                             if reverse_description.is_empty() {
@@ -389,7 +389,8 @@ fn display<'db, T: HirDisplay<'db>>(db: &'db RootDatabase, module: hir::Module,
         Ok(result) => result,
         // Fallback on display variant that always succeeds
         Err(_) => {
-            let fallback_result = it.display(db, module.krate().to_display_target(db)).to_string();
+            let fallback_result =
+                it.display(db, module.krate(db).to_display_target(db)).to_string();
             tracing::error!(
                 display = %fallback_result, "`display_source_code` failed; falling back to using display"
             );
diff --git a/crates/ide/src/navigation_target.rs b/crates/ide/src/navigation_target.rs
index 4c4d57f0f40c..67472507f66e 100644
--- a/crates/ide/src/navigation_target.rs
+++ b/crates/ide/src/navigation_target.rs
@@ -160,7 +160,7 @@ impl NavigationTarget {
                         );
                         res.docs = module.docs(db).map(Documentation::into_owned);
                         res.description = Some(
-                            module.display(db, module.krate().to_display_target(db)).to_string(),
+                            module.display(db, module.krate(db).to_display_target(db)).to_string(),
                         );
                         res
                     },
@@ -468,7 +468,7 @@ impl ToNav for hir::Module {
 
 impl ToNav for hir::Crate {
     fn to_nav(&self, db: &RootDatabase) -> UpmappingResult<NavigationTarget> {
-        self.root_module().to_nav(db)
+        self.root_module(db).to_nav(db)
     }
 }
 
@@ -511,7 +511,7 @@ impl TryToNav for hir::ExternCrateDecl {
         let focus = value
             .rename()
             .map_or_else(|| value.name_ref().map(Either::Left), |it| it.name().map(Either::Right));
-        let krate = self.module(db).krate();
+        let krate = self.module(db).krate(db);
 
         Some(orig_range_with_focus(db, file_id, value.syntax(), focus).map(
             |(FileRange { file_id, range: full_range }, focus_range)| {
@@ -539,7 +539,7 @@ impl TryToNav for hir::Field {
     ) -> Option<UpmappingResult<NavigationTarget>> {
         let db = sema.db;
         let src = self.source(db)?;
-        let krate = self.parent_def(db).module(db).krate();
+        let krate = self.parent_def(db).module(db).krate(db);
 
         let field_source = match &src.value {
             FieldSource::Named(it) => {
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 9e17ab2bab75..a61be93ea968 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -372,7 +372,7 @@ pub(crate) fn runnable_mod(
         .rev()
         .filter_map(|module| {
             module.name(sema.db).map(|mod_name| {
-                mod_name.display(sema.db, module.krate().edition(sema.db)).to_string()
+                mod_name.display(sema.db, module.krate(sema.db).edition(sema.db)).to_string()
             })
         })
         .join("::");
@@ -401,7 +401,7 @@ pub(crate) fn runnable_impl(
     sema: &Semantics<'_, RootDatabase>,
     def: &hir::Impl,
 ) -> Option<Runnable> {
-    let display_target = def.module(sema.db).krate().to_display_target(sema.db);
+    let display_target = def.module(sema.db).krate(sema.db).to_display_target(sema.db);
     let edition = display_target.edition;
     let attrs = def.attrs(sema.db);
     if !has_runnable_doc_test(sema.db, &attrs) {
@@ -466,7 +466,7 @@ fn runnable_mod_outline_definition(
         .rev()
         .filter_map(|module| {
             module.name(sema.db).map(|mod_name| {
-                mod_name.display(sema.db, module.krate().edition(sema.db)).to_string()
+                mod_name.display(sema.db, module.krate(sema.db).edition(sema.db)).to_string()
             })
         })
         .join("::");
diff --git a/crates/ide/src/static_index.rs b/crates/ide/src/static_index.rs
index f3cda9156bbb..30e8d62ea210 100644
--- a/crates/ide/src/static_index.rs
+++ b/crates/ide/src/static_index.rs
@@ -102,7 +102,7 @@ pub struct StaticIndexedFile {
 
 fn all_modules(db: &dyn HirDatabase) -> Vec<Module> {
     let mut worklist: Vec<_> =
-        Crate::all(db).into_iter().map(|krate| krate.root_module()).collect();
+        Crate::all(db).into_iter().map(|krate| krate.root_module(db)).collect();
     let mut modules = Vec::new();
 
     while let Some(module) = worklist.pop() {
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 8937f8249c84..044fd3f5ac9a 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -501,7 +501,7 @@ pub(super) fn highlight_def(
         ),
         Definition::Module(module) => {
             let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Module));
-            if module.is_crate_root() {
+            if module.is_crate_root(db) {
                 h |= HlMod::CrateRoot;
             }
 
@@ -747,7 +747,7 @@ fn highlight_method_call(
         h |= HlMod::Trait;
     }
 
-    let def_crate = func.module(sema.db).krate();
+    let def_crate = func.module(sema.db).krate(sema.db);
     let is_from_other_crate = krate.as_ref().map_or(false, |krate| def_crate != *krate);
     let is_from_builtin_crate = def_crate.is_builtin(sema.db);
     let is_public = func.visibility(sema.db) == hir::Visibility::Public;
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_block_mod_items.html b/crates/ide/src/syntax_highlighting/test_data/highlight_block_mod_items.html
index e3daeef84109..982e89dfab69 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_block_mod_items.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_block_mod_items.html
@@ -54,7 +54,7 @@
         <span class="macro public">foo</span><span class="macro_bang">!</span><span class="parenthesis">(</span><span class="struct declaration macro public">Bar</span><span class="parenthesis">)</span><span class="semicolon">;</span>
         <span class="keyword">fn</span> <span class="function declaration">func</span><span class="parenthesis">(</span><span class="punctuation">_</span><span class="colon">:</span> <span class="module">y</span><span class="operator">::</span><span class="struct public">Bar</span><span class="parenthesis">)</span> <span class="brace">{</span>
             <span class="keyword">mod</span> <span class="module declaration">inner</span> <span class="brace">{</span>
-                <span class="keyword">struct</span> <span class="struct declaration">Innerest</span><span class="angle">&lt;</span><span class="keyword const">const</span> <span class="const_param const declaration">C</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="angle">&gt;</span> <span class="brace">{</span> <span class="field declaration">field</span><span class="colon">:</span> <span class="bracket">[</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span> <span class="brace">{</span><span class="const_param const">C</span><span class="brace">}</span><span class="bracket">]</span> <span class="brace">}</span>
+                <span class="keyword">struct</span> <span class="struct declaration">Innerest</span><span class="angle">&lt;</span><span class="keyword const">const</span> <span class="const_param const declaration">C</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="angle">&gt;</span> <span class="brace">{</span> <span class="field declaration">field</span><span class="colon">:</span> <span class="bracket">[</span><span class="builtin_type">u32</span><span class="semicolon">;</span> <span class="brace">{</span><span class="const_param const">C</span><span class="brace">}</span><span class="bracket">]</span><span class="comma">,</span> <span class="field declaration">field2</span><span class="colon">:</span> <span class="punctuation">&</span><span class="struct">Innerest</span> <span class="brace">}</span>
             <span class="brace">}</span>
         <span class="brace">}</span>
     <span class="brace">}</span>
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index b7510e3abaea..89a5e434f90c 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -1183,7 +1183,7 @@ fn main() {
         foo!(Bar);
         fn func(_: y::Bar) {
             mod inner {
-                struct Innerest<const C: usize> { field: [(); {C}] }
+                struct Innerest<const C: usize> { field: [u32; {C}], field2: &Innerest }
             }
         }
     }
diff --git a/crates/ide/src/test_explorer.rs b/crates/ide/src/test_explorer.rs
index bd60ffe55912..4792566f5f5b 100644
--- a/crates/ide/src/test_explorer.rs
+++ b/crates/ide/src/test_explorer.rs
@@ -135,11 +135,11 @@ fn find_module_id_and_test_parents(
     module: Module,
 ) -> Option<(Vec<TestItem>, String)> {
     let Some(parent) = module.parent(sema.db) else {
-        let name = module.krate().display_name(sema.db)?.to_string();
+        let name = module.krate(sema.db).display_name(sema.db)?.to_string();
         return Some((
             vec![TestItem {
                 id: name.clone(),
-                kind: TestItemKind::Crate(module.krate().into()),
+                kind: TestItemKind::Crate(module.krate(sema.db).into()),
                 label: name.clone(),
                 parent: None,
                 file: None,
@@ -181,7 +181,7 @@ pub(crate) fn discover_tests_in_crate(
     let kind = TestItemKind::Crate(crate_id);
     let crate_test_id = crate_test_id.to_string();
     let crate_id: Crate = crate_id.into();
-    let module = crate_id.root_module();
+    let module = crate_id.root_module(db);
     let mut r = vec![TestItem {
         id: crate_test_id.clone(),
         kind,
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index bd3f05977ef0..f39ab1301f8f 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -206,7 +206,7 @@ impl flags::AnalysisStats {
         let mut visited_modules = FxHashSet::default();
         let mut visit_queue = Vec::new();
         for &krate in &krates {
-            let module = krate.root_module();
+            let module = krate.root_module(db);
             let file_id = module.definition_source_file_id(db);
             let file_id = file_id.original_file(db);
 
@@ -769,7 +769,7 @@ impl flags::AnalysisStats {
         for &body_id in bodies {
             let name = body_id.name(db).unwrap_or_else(Name::missing);
             let module = body_id.module(db);
-            let display_target = module.krate().to_display_target(db);
+            let display_target = module.krate(db).to_display_target(db);
             if let Some(only_name) = self.only.as_deref()
                 && name.display(db, Edition::LATEST).to_string() != only_name
                 && full_name(db, body_id, module) != only_name
@@ -1290,7 +1290,7 @@ impl flags::AnalysisStats {
 
 fn full_name(db: &RootDatabase, body_id: DefWithBody, module: hir::Module) -> String {
     module
-        .krate()
+        .krate(db)
         .display_name(db)
         .map(|it| it.canonical_name().as_str().to_owned())
         .into_iter()
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index 82590c8e707f..776069f155f0 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -68,8 +68,12 @@ impl flags::Diagnostics {
             if !visited_files.contains(&file_id) {
                 let message = format!("processing {}", _vfs.file_path(file_id.file_id(db)));
                 bar.set_message(move || message.clone());
-                let crate_name =
-                    module.krate().display_name(db).as_deref().unwrap_or(&sym::unknown).to_owned();
+                let crate_name = module
+                    .krate(db)
+                    .display_name(db)
+                    .as_deref()
+                    .unwrap_or(&sym::unknown)
+                    .to_owned();
                 for diagnostic in analysis
                     .full_diagnostics(
                         &DiagnosticsConfig::test_sample(),
@@ -122,7 +126,7 @@ impl flags::Diagnostics {
 
 fn all_modules(db: &dyn HirDatabase) -> Vec<Module> {
     let mut worklist: Vec<_> =
-        Crate::all(db).into_iter().map(|krate| krate.root_module()).collect();
+        Crate::all(db).into_iter().map(|krate| krate.root_module(db)).collect();
     let mut modules = Vec::new();
 
     while let Some(module) = worklist.pop() {
diff --git a/crates/rust-analyzer/src/cli/run_tests.rs b/crates/rust-analyzer/src/cli/run_tests.rs
index 60b33f0a3086..82ace8c8b315 100644
--- a/crates/rust-analyzer/src/cli/run_tests.rs
+++ b/crates/rust-analyzer/src/cli/run_tests.rs
@@ -78,7 +78,7 @@ fn all_modules(db: &dyn HirDatabase) -> Vec<Module> {
     let mut worklist: Vec<_> = Crate::all(db)
         .into_iter()
         .filter(|x| x.origin(db).is_local())
-        .map(|krate| krate.root_module())
+        .map(|krate| krate.root_module(db))
         .collect();
     let mut modules = Vec::new();
 
diff --git a/crates/rust-analyzer/src/cli/unresolved_references.rs b/crates/rust-analyzer/src/cli/unresolved_references.rs
index a400f86778f4..294add682d01 100644
--- a/crates/rust-analyzer/src/cli/unresolved_references.rs
+++ b/crates/rust-analyzer/src/cli/unresolved_references.rs
@@ -64,8 +64,12 @@ impl flags::UnresolvedReferences {
             let file_id = module.definition_source_file_id(db).original_file(db);
             let file_id = file_id.file_id(db);
             if !visited_files.contains(&file_id) {
-                let crate_name =
-                    module.krate().display_name(db).as_deref().unwrap_or(&sym::unknown).to_owned();
+                let crate_name = module
+                    .krate(db)
+                    .display_name(db)
+                    .as_deref()
+                    .unwrap_or(&sym::unknown)
+                    .to_owned();
                 let file_path = vfs.file_path(file_id);
                 eprintln!("processing crate: {crate_name}, module: {file_path}",);
 
@@ -93,7 +97,7 @@ impl flags::UnresolvedReferences {
 
 fn all_modules(db: &dyn HirDatabase) -> Vec<Module> {
     let mut worklist: Vec<_> =
-        Crate::all(db).into_iter().map(|krate| krate.root_module()).collect();
+        Crate::all(db).into_iter().map(|krate| krate.root_module(db)).collect();
     let mut modules = Vec::new();
 
     while let Some(module) = worklist.pop() {