1 files changed, 48 insertions, 39 deletions

diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 5e2a711b8..de08e2737 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -1,8 +1,9 @@
 //! An algorithm to find a path to refer to a certain item.
 
+use std::iter;
+
 use hir_expand::name::{known, AsName, Name};
 use rustc_hash::FxHashSet;
-use test_utils::mark;
 
 use crate::nameres::DefMap;
 use crate::{
@@ -95,7 +96,7 @@ fn find_path_inner(
     item: ItemInNs,
     from: ModuleId,
     max_len: usize,
-    prefixed: Option<PrefixKind>,
+    mut prefixed: Option<PrefixKind>,
 ) -> Option<ModPath> {
     if max_len == 0 {
         return None;
@@ -114,8 +115,9 @@ fn find_path_inner(
     }
 
     // - if the item is the crate root, return `crate`
-    let root = def_map.module_id(def_map.root());
+    let root = def_map.crate_root(db);
     if item == ItemInNs::Types(ModuleDefId::ModuleId(root)) && def_map.block_id().is_none() {
+        // FIXME: the `block_id()` check should be unnecessary, but affects the result
         return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
     }
 
@@ -165,7 +167,7 @@ fn find_path_inner(
 
     // - otherwise, look for modules containing (reexporting) it and import it from one of those
 
-    let crate_root = def_map.module_id(def_map.root());
+    let crate_root = def_map.crate_root(db);
     let crate_attrs = db.attrs(crate_root.into());
     let prefer_no_std = crate_attrs.by_key("no_std").exists();
     let mut best_path = None;
@@ -212,7 +214,7 @@ fn find_path_inner(
                     best_path_len - 1,
                     prefixed,
                 )?;
-                mark::hit!(partially_imported);
+                cov_mark::hit!(partially_imported);
                 path.push_segment(info.path.segments.last().unwrap().clone());
                 Some(path)
             })
@@ -228,12 +230,16 @@ fn find_path_inner(
         }
     }
 
-    if let Some(mut prefix) = prefixed.map(PrefixKind::prefix) {
-        if matches!(prefix, PathKind::Crate | PathKind::Super(0)) && def_map.block_id().is_some() {
-            // Inner items cannot be referred to via `crate::` or `self::` paths.
-            prefix = PathKind::Plain;
+    // If the item is declared inside a block expression, don't use a prefix, as we don't handle
+    // that correctly (FIXME).
+    if let Some(item_module) = item.as_module_def_id().and_then(|did| did.module(db)) {
+        if item_module.def_map(db).block_id().is_some() && prefixed.is_some() {
+            cov_mark::hit!(prefixed_in_block_expression);
+            prefixed = Some(PrefixKind::Plain);
         }
+    }
 
+    if let Some(prefix) = prefixed.map(PrefixKind::prefix) {
         best_path.or_else(|| {
             scope_name.map(|scope_name| ModPath::from_segments(prefix, vec![scope_name]))
         })
@@ -245,18 +251,18 @@ fn find_path_inner(
 fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -> ModPath {
     if old_path.starts_with_std() && new_path.can_start_with_std() {
         if prefer_no_std {
-            mark::hit!(prefer_no_std_paths);
+            cov_mark::hit!(prefer_no_std_paths);
             new_path
         } else {
-            mark::hit!(prefer_std_paths);
+            cov_mark::hit!(prefer_std_paths);
             old_path
         }
     } else if new_path.starts_with_std() && old_path.can_start_with_std() {
         if prefer_no_std {
-            mark::hit!(prefer_no_std_paths);
+            cov_mark::hit!(prefer_no_std_paths);
             old_path
         } else {
-            mark::hit!(prefer_std_paths);
+            cov_mark::hit!(prefer_std_paths);
             new_path
         }
     } else if new_path.len() < old_path.len() {
@@ -285,12 +291,12 @@ fn find_local_import_locations(
     let data = &def_map[from.local_id];
     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(def_map.module_id(p));
-        parent = def_map[p].parent;
+    for ancestor in iter::successors(from.containing_module(db), |m| m.containing_module(db)) {
+        worklist.push(ancestor);
     }
 
+    let def_map = def_map.crate_root(db).def_map(db);
+
     let mut seen: FxHashSet<_> = FxHashSet::default();
 
     let mut locations = Vec::new();
@@ -301,7 +307,14 @@ fn find_local_import_locations(
 
         let ext_def_map;
         let data = if module.krate == from.krate {
-            &def_map[module.local_id]
+            if module.block.is_some() {
+                // Re-query the block's DefMap
+                ext_def_map = module.def_map(db);
+                &ext_def_map[module.local_id]
+            } else {
+                // Reuse the root DefMap
+                &def_map[module.local_id]
+            }
         } else {
             // The crate might reexport a module defined in another crate.
             ext_def_map = module.def_map(db);
@@ -350,7 +363,6 @@ mod tests {
     use base_db::fixture::WithFixture;
     use hir_expand::hygiene::Hygiene;
     use syntax::ast::AstNode;
-    use test_utils::mark;
 
     use crate::test_db::TestDB;
 
@@ -508,7 +520,7 @@ mod tests {
 
     #[test]
     fn partially_imported() {
-        mark::check!(partially_imported);
+        cov_mark::check!(partially_imported);
         // Tests that short paths are used even for external items, when parts of the path are
         // already in scope.
         let code = r#"
@@ -672,7 +684,7 @@ mod tests {
 
     #[test]
     fn prefer_std_paths_over_alloc() {
-        mark::check!(prefer_std_paths);
+        cov_mark::check!(prefer_std_paths);
         let code = r#"
         //- /main.rs crate:main deps:alloc,std
         $0
@@ -698,7 +710,7 @@ mod tests {
 
     #[test]
     fn prefer_core_paths_over_std() {
-        mark::check!(prefer_no_std_paths);
+        cov_mark::check!(prefer_no_std_paths);
         let code = r#"
         //- /main.rs crate:main deps:core,std
         #![no_std]
@@ -828,6 +840,7 @@ mod tests {
 
     #[test]
     fn inner_items_from_inner_module() {
+        cov_mark::check!(prefixed_in_block_expression);
         check_found_path(
             r#"
             fn main() {
@@ -847,26 +860,22 @@ mod tests {
     }
 
     #[test]
-    #[ignore]
-    fn inner_items_from_parent_module() {
-        // FIXME: ItemTree currently associates all inner items with `main`. Luckily, this sort of
-        // code is very rare, so this isn't terrible.
-        // To fix it, we should probably build dedicated `ItemTree`s for inner items, and not store
-        // them in the file's main ItemTree. This would also allow us to stop parsing function
-        // bodies when we only want to compute the crate's main DefMap.
+    fn outer_items_with_inner_items_present() {
         check_found_path(
             r#"
+            mod module {
+                pub struct CompleteMe;
+            }
+
             fn main() {
-                struct Struct {}
-                mod module {
-                    $0
-                }
+                fn inner() {}
+                $0
             }
-        "#,
-            "super::Struct",
-            "super::Struct",
-            "super::Struct",
-            "super::Struct",
-        );
+            "#,
+            "module::CompleteMe",
+            "module::CompleteMe",
+            "crate::module::CompleteMe",
+            "self::module::CompleteMe",
+        )
     }
 }