6 files changed, 93 insertions, 48 deletions

diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index fe4c3fa28..24ffa6c3a 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -367,7 +367,7 @@ fn inner_attributes(
             // Excerpt from the reference:
             // Block expressions accept outer and inner attributes, but only when they are the outer
             // expression of an expression statement or the final expression of another block expression.
-            ast::BlockExpr(it) => return None,
+            ast::BlockExpr(_it) => return None,
             _ => return None,
         }
     };
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 5e2a711b8..3a98ffbaa 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -1,5 +1,7 @@
 //! 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;
@@ -95,7 +97,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 +116,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 +168,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;
@@ -228,12 +231,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() {
+            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]))
         })
@@ -285,12 +292,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 +308,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);
@@ -828,6 +842,7 @@ mod tests {
 
     #[test]
     fn inner_items_from_inner_module() {
+        mark::check!(prefixed_in_block_expression);
         check_found_path(
             r#"
             fn main() {
@@ -847,26 +862,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",
+        )
     }
 }
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index ee46c3330..4e5daa2ff 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -12,8 +12,8 @@ use stdx::format_to;
 use test_utils::mark;
 
 use crate::{
-    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, HasModule, ImplId,
-    LocalModuleId, Lookup, MacroDefId, ModuleDefId, ModuleId, TraitId,
+    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ImplId,
+    LocalModuleId, MacroDefId, ModuleDefId, ModuleId, TraitId,
 };
 
 #[derive(Copy, Clone)]
@@ -375,19 +375,9 @@ impl ItemInNs {
 
     /// Returns the crate defining this item (or `None` if `self` is built-in).
     pub fn krate(&self, db: &dyn DefDatabase) -> Option<CrateId> {
-        Some(match self {
-            ItemInNs::Types(did) | ItemInNs::Values(did) => match did {
-                ModuleDefId::ModuleId(id) => id.krate,
-                ModuleDefId::FunctionId(id) => id.lookup(db).module(db).krate,
-                ModuleDefId::AdtId(id) => id.module(db).krate,
-                ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container.module(db).krate,
-                ModuleDefId::ConstId(id) => id.lookup(db).container.module(db).krate,
-                ModuleDefId::StaticId(id) => id.lookup(db).container.module(db).krate,
-                ModuleDefId::TraitId(id) => id.lookup(db).container.module(db).krate,
-                ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db).krate,
-                ModuleDefId::BuiltinType(_) => return None,
-            },
-            ItemInNs::Macros(id) => return Some(id.krate),
-        })
+        match self {
+            ItemInNs::Types(did) | ItemInNs::Values(did) => did.module(db).map(|m| m.krate),
+            ItemInNs::Macros(id) => Some(id.krate),
+        }
     }
 }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 6802bc250..4498d94bb 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -97,6 +97,10 @@ impl ModuleId {
     pub fn krate(&self) -> CrateId {
         self.krate
     }
+
+    pub fn containing_module(&self, db: &dyn db::DefDatabase) -> Option<ModuleId> {
+        self.def_map(db).containing_module(self.local_id)
+    }
 }
 
 /// An ID of a module, **local** to a specific crate
@@ -529,6 +533,25 @@ impl HasModule for StaticLoc {
     }
 }
 
+impl ModuleDefId {
+    /// Returns the module containing `self` (or `self`, if `self` is itself a module).
+    ///
+    /// Returns `None` if `self` refers to a primitive type.
+    pub fn module(&self, db: &dyn db::DefDatabase) -> Option<ModuleId> {
+        Some(match self {
+            ModuleDefId::ModuleId(id) => *id,
+            ModuleDefId::FunctionId(id) => id.lookup(db).module(db),
+            ModuleDefId::AdtId(id) => id.module(db),
+            ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container.module(db),
+            ModuleDefId::ConstId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::StaticId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::TraitId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db),
+            ModuleDefId::BuiltinType(_) => return None,
+        })
+    }
+}
+
 impl AttrDefId {
     pub fn krate(&self, db: &dyn db::DefDatabase) -> CrateId {
         match self {
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 6a3456f2e..003d668ca 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -343,6 +343,18 @@ impl DefMap {
         Some(self.block?.parent)
     }
 
+    /// Returns the module containing `local_mod`, either the parent `mod`, or the module containing
+    /// the block, if `self` corresponds to a block expression.
+    pub fn containing_module(&self, local_mod: LocalModuleId) -> Option<ModuleId> {
+        match &self[local_mod].parent {
+            Some(parent) => Some(self.module_id(*parent)),
+            None => match &self.block {
+                Some(block) => Some(block.parent),
+                None => None,
+            },
+        }
+    }
+
     // FIXME: this can use some more human-readable format (ideally, an IR
     // even), as this should be a great debugging aid.
     pub fn dump(&self, db: &dyn DefDatabase) -> String {
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index a469546c1..505493a74 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -101,8 +101,12 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                 break;
             }
             ast::PathSegmentKind::SelfKw => {
-                kind = PathKind::Super(0);
-                break;
+                // don't break out if `self` is the last segment of a path, this mean we got an
+                // use tree like `foo::{self}` which we want to resolve as `foo`
+                if !segments.is_empty() {
+                    kind = PathKind::Super(0);
+                    break;
+                }
             }
             ast::PathSegmentKind::SuperKw => {
                 let nested_super_count = if let PathKind::Super(n) = kind { n } else { 0 };
@@ -117,6 +121,11 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
     segments.reverse();
     generic_args.reverse();
 
+    if segments.is_empty() && kind == PathKind::Plain && type_anchor.is_none() {
+        // plain empty paths don't exist, this means we got a single `self` segment as our path
+        kind = PathKind::Super(0);
+    }
+
     // handle local_inner_macros :
     // Basically, even in rustc it is quite hacky:
     // https://github.com/rust-lang/rust/blob/614f273e9388ddd7804d5cbc80b8865068a3744e/src/librustc_resolve/macros.rs#L456