1 files changed, 13 insertions, 24 deletions

diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index db2d125ae..94a1d567d 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -53,12 +53,8 @@ fn check_self_super(def_map: &DefMap, item: ItemInNs, from: ModuleId) -> Option<
         Some(ModPath::from_segments(PathKind::Super(0), Vec::new()))
     } else if let Some(parent_id) = def_map[from.local_id].parent {
         // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
-        if item
-            == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
-                krate: from.krate,
-                local_id: parent_id,
-            }))
-        {
+        let parent_id = def_map.module_id(parent_id);
+        if item == ItemInNs::Types(ModuleDefId::ModuleId(parent_id)) {
             Some(ModPath::from_segments(PathKind::Super(1), Vec::new()))
         } else {
             None
@@ -110,7 +106,7 @@ fn find_path_inner(
     // Base cases:
 
     // - if the item is already in scope, return the name under which it is
-    let def_map = db.crate_def_map(from.krate);
+    let def_map = from.def_map(db);
     let from_scope: &crate::item_scope::ItemScope = &def_map[from.local_id].scope;
     let scope_name =
         if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None };
@@ -120,12 +116,8 @@ fn find_path_inner(
     }
 
     // - if the item is the crate root, return `crate`
-    if item
-        == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
-            krate: from.krate,
-            local_id: def_map.root(),
-        }))
-    {
+    let root = def_map.module_id(def_map.root());
+    if item == ItemInNs::Types(ModuleDefId::ModuleId(root)) {
         return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
     }
 
@@ -145,7 +137,7 @@ fn find_path_inner(
 
     // - if the item is in the prelude, return the name from there
     if let Some(prelude_module) = def_map.prelude() {
-        let prelude_def_map = db.crate_def_map(prelude_module.krate);
+        let prelude_def_map = prelude_module.def_map(db);
         let prelude_scope: &crate::item_scope::ItemScope =
             &prelude_def_map[prelude_module.local_id].scope;
         if let Some((name, vis)) = prelude_scope.name_of(item) {
@@ -175,7 +167,7 @@ fn find_path_inner(
 
     // - otherwise, look for modules containing (reexporting) it and import it from one of those
 
-    let crate_root = ModuleId { local_id: def_map.root(), krate: from.krate };
+    let crate_root = def_map.module_id(def_map.root());
     let crate_attrs = db.attrs(crate_root.into());
     let prefer_no_std = crate_attrs.by_key("no_std").exists();
     let mut best_path = None;
@@ -283,19 +275,16 @@ fn find_local_import_locations(
     // above `from` with any visibility. That means we do not need to descend into private siblings
     // of `from` (and similar).
 
-    let def_map = db.crate_def_map(from.krate);
+    let def_map = from.def_map(db);
 
     // Compute the initial worklist. We start with all direct child modules of `from` as well as all
     // of its (recursive) parent modules.
     let data = &def_map[from.local_id];
-    let mut worklist = data
-        .children
-        .values()
-        .map(|child| ModuleId { krate: from.krate, local_id: *child })
-        .collect::<Vec<_>>();
+    let mut worklist =
+        data.children.values().map(|child| def_map.module_id(*child)).collect::<Vec<_>>();
     let mut parent = data.parent;
     while let Some(p) = parent {
-        worklist.push(ModuleId { krate: from.krate, local_id: p });
+        worklist.push(def_map.module_id(p));
         parent = def_map[p].parent;
     }
 
@@ -312,7 +301,7 @@ fn find_local_import_locations(
             &def_map[module.local_id]
         } else {
             // The crate might reexport a module defined in another crate.
-            ext_def_map = db.crate_def_map(module.krate);
+            ext_def_map = module.def_map(db);
             &ext_def_map[module.local_id]
         };
 
@@ -375,7 +364,7 @@ mod tests {
             parsed_path_file.syntax_node().descendants().find_map(syntax::ast::Path::cast).unwrap();
         let mod_path = ModPath::from_src(ast_path, &Hygiene::new_unhygienic()).unwrap();
 
-        let crate_def_map = db.crate_def_map(module.krate);
+        let crate_def_map = module.def_map(&db);
         let resolved = crate_def_map
             .resolve_path(
                 &db,