4 files changed, 206 insertions, 28 deletions

diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 0cd61698c..adfcf879a 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -31,7 +31,7 @@ use crate::{
     },
     nameres::{
         diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
-        BuiltinShadowMode, CrateDefMap, ModuleData, ModuleOrigin, ResolveMode,
+        BuiltinShadowMode, DefMap, ModuleData, ModuleOrigin, ResolveMode,
     },
     path::{ImportAlias, ModPath, PathKind},
     per_ns::PerNs,
@@ -45,7 +45,11 @@ const GLOB_RECURSION_LIMIT: usize = 100;
 const EXPANSION_DEPTH_LIMIT: usize = 128;
 const FIXED_POINT_LIMIT: usize = 8192;
 
-pub(super) fn collect_defs(db: &dyn DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
+pub(super) fn collect_defs(
+    db: &dyn DefDatabase,
+    mut def_map: DefMap,
+    block: Option<FileAstId<ast::BlockExpr>>,
+) -> DefMap {
     let crate_graph = db.crate_graph();
 
     // populate external prelude
@@ -93,6 +97,14 @@ pub(super) fn collect_defs(db: &dyn DefDatabase, mut def_map: CrateDefMap) -> Cr
         exports_proc_macros: false,
         from_glob_import: Default::default(),
     };
+    match block {
+        Some(block) => {
+            collector.seed_with_inner(block);
+        }
+        None => {
+            collector.seed_with_top_level();
+        }
+    }
     collector.collect();
     collector.finish()
 }
@@ -210,7 +222,7 @@ struct DefData<'a> {
 /// Walks the tree of module recursively
 struct DefCollector<'a> {
     db: &'a dyn DefDatabase,
-    def_map: CrateDefMap,
+    def_map: DefMap,
     glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, Visibility)>>,
     unresolved_imports: Vec<ImportDirective>,
     resolved_imports: Vec<ImportDirective>,
@@ -228,7 +240,7 @@ struct DefCollector<'a> {
 }
 
 impl DefCollector<'_> {
-    fn collect(&mut self) {
+    fn seed_with_top_level(&mut self) {
         let file_id = self.db.crate_graph()[self.def_map.krate].root_file_id;
         let item_tree = self.db.item_tree(file_id.into());
         let module_id = self.def_map.root;
@@ -248,7 +260,31 @@ impl DefCollector<'_> {
             }
             .collect(item_tree.top_level_items());
         }
+    }
+
+    fn seed_with_inner(&mut self, block: FileAstId<ast::BlockExpr>) {
+        let file_id = self.db.crate_graph()[self.def_map.krate].root_file_id;
+        let item_tree = self.db.item_tree(file_id.into());
+        let module_id = self.def_map.root;
+        self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
+        if item_tree
+            .top_level_attrs(self.db, self.def_map.krate)
+            .cfg()
+            .map_or(true, |cfg| self.cfg_options.check(&cfg) != Some(false))
+        {
+            ModCollector {
+                def_collector: &mut *self,
+                macro_depth: 0,
+                module_id,
+                file_id: file_id.into(),
+                item_tree: &item_tree,
+                mod_dir: ModDir::root(),
+            }
+            .collect(item_tree.inner_items_of_block(block));
+        }
+    }
 
+    fn collect(&mut self) {
         // main name resolution fixed-point loop.
         let mut i = 0;
         loop {
@@ -542,7 +578,7 @@ impl DefCollector<'_> {
                     } else if m.krate != self.def_map.krate {
                         mark::hit!(glob_across_crates);
                         // glob import from other crate => we can just import everything once
-                        let item_map = self.db.crate_def_map(m.krate);
+                        let item_map = m.def_map(self.db);
                         let scope = &item_map[m.local_id].scope;
 
                         // Module scoped macros is included
@@ -859,7 +895,7 @@ impl DefCollector<'_> {
         .collect(item_tree.top_level_items());
     }
 
-    fn finish(mut self) -> CrateDefMap {
+    fn finish(mut self) -> DefMap {
         // Emit diagnostics for all remaining unexpanded macros.
 
         for directive in &self.unexpanded_macros {
@@ -1470,11 +1506,10 @@ impl ModCollector<'_, '_> {
 mod tests {
     use crate::{db::DefDatabase, test_db::TestDB};
     use base_db::{fixture::WithFixture, SourceDatabase};
-    use la_arena::Arena;
 
     use super::*;
 
-    fn do_collect_defs(db: &dyn DefDatabase, def_map: CrateDefMap) -> CrateDefMap {
+    fn do_collect_defs(db: &dyn DefDatabase, def_map: DefMap) -> DefMap {
         let mut collector = DefCollector {
             db,
             def_map,
@@ -1489,28 +1524,17 @@ mod tests {
             exports_proc_macros: false,
             from_glob_import: Default::default(),
         };
+        collector.seed_with_top_level();
         collector.collect();
         collector.def_map
     }
 
-    fn do_resolve(code: &str) -> CrateDefMap {
+    fn do_resolve(code: &str) -> DefMap {
         let (db, _file_id) = TestDB::with_single_file(&code);
         let krate = db.test_crate();
 
-        let def_map = {
-            let edition = db.crate_graph()[krate].edition;
-            let mut modules: Arena<ModuleData> = Arena::default();
-            let root = modules.alloc(ModuleData::default());
-            CrateDefMap {
-                krate,
-                edition,
-                extern_prelude: FxHashMap::default(),
-                prelude: None,
-                root,
-                modules,
-                diagnostics: Vec::new(),
-            }
-        };
+        let edition = db.crate_graph()[krate].edition;
+        let def_map = DefMap::empty(krate, edition);
         do_collect_defs(&db, def_map)
     }
 
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index 88e10574e..82528b792 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -19,7 +19,7 @@ use test_utils::mark;
 use crate::{
     db::DefDatabase,
     item_scope::BUILTIN_SCOPE,
-    nameres::{BuiltinShadowMode, CrateDefMap},
+    nameres::{BuiltinShadowMode, DefMap},
     path::{ModPath, PathKind},
     per_ns::PerNs,
     visibility::{RawVisibility, Visibility},
@@ -61,7 +61,7 @@ impl ResolvePathResult {
     }
 }
 
-impl CrateDefMap {
+impl DefMap {
     pub(super) fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
         self.extern_prelude
             .get(name)
@@ -104,6 +104,43 @@ impl CrateDefMap {
         path: &ModPath,
         shadow: BuiltinShadowMode,
     ) -> ResolvePathResult {
+        let mut result = ResolvePathResult::empty(ReachedFixedPoint::No);
+        result.segment_index = Some(usize::max_value());
+
+        let mut current_map = self;
+        loop {
+            let new = current_map.resolve_path_fp_with_macro_single(
+                db,
+                mode,
+                original_module,
+                path,
+                shadow,
+            );
+
+            // Merge `new` into `result`.
+            result.resolved_def = result.resolved_def.or(new.resolved_def);
+            if result.reached_fixedpoint == ReachedFixedPoint::No {
+                result.reached_fixedpoint = new.reached_fixedpoint;
+            }
+            // FIXME: this doesn't seem right; what if the different namespace resolutions come from different crates?
+            result.krate = result.krate.or(new.krate);
+            result.segment_index = result.segment_index.min(new.segment_index);
+
+            match &current_map.parent {
+                Some(map) => current_map = map,
+                None => return result,
+            }
+        }
+    }
+
+    pub(super) fn resolve_path_fp_with_macro_single(
+        &self,
+        db: &dyn DefDatabase,
+        mode: ResolveMode,
+        original_module: LocalModuleId,
+        path: &ModPath,
+        shadow: BuiltinShadowMode,
+    ) -> ResolvePathResult {
         let mut segments = path.segments.iter().enumerate();
         let mut curr_per_ns: PerNs = match path.kind {
             PathKind::DollarCrate(krate) => {
@@ -206,7 +243,7 @@ impl CrateDefMap {
                             kind: PathKind::Super(0),
                         };
                         log::debug!("resolving {:?} in other crate", path);
-                        let defp_map = db.crate_def_map(module.krate);
+                        let defp_map = module.def_map(db);
                         let (def, s) = defp_map.resolve_path(db, module.local_id, &path, shadow);
                         return ResolvePathResult::with(
                             def,
@@ -319,7 +356,7 @@ impl CrateDefMap {
                 self
             } else {
                 // Extend lifetime
-                keep = db.crate_def_map(prelude.krate);
+                keep = prelude.def_map(db);
                 &keep
             };
             def_map[prelude.local_id].scope.get(name)
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index c459fa66d..73e3a4702 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -4,27 +4,47 @@ mod macros;
 mod mod_resolution;
 mod diagnostics;
 mod primitives;
+mod block;
 
 use std::sync::Arc;
 
 use base_db::{fixture::WithFixture, SourceDatabase};
 use expect_test::{expect, Expect};
+use hir_expand::db::AstDatabase;
 use test_utils::mark;
 
 use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
 
-fn compute_crate_def_map(ra_fixture: &str) -> Arc<CrateDefMap> {
+fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
     let db = TestDB::with_files(ra_fixture);
     let krate = db.crate_graph().iter().next().unwrap();
     db.crate_def_map(krate)
 }
 
+fn compute_block_def_map(ra_fixture: &str) -> Arc<DefMap> {
+    let (db, position) = TestDB::with_position(ra_fixture);
+    let module = db.module_for_file(position.file_id);
+    let ast_map = db.ast_id_map(position.file_id.into());
+    let ast = db.parse(position.file_id);
+    let block: ast::BlockExpr =
+        syntax::algo::find_node_at_offset(&ast.syntax_node(), position.offset).unwrap();
+    let block_id = ast_map.ast_id(&block);
+
+    db.block_def_map(module.krate, InFile::new(position.file_id.into(), block_id))
+}
+
 fn check(ra_fixture: &str, expect: Expect) {
     let def_map = compute_crate_def_map(ra_fixture);
     let actual = def_map.dump();
     expect.assert_eq(&actual);
 }
 
+fn check_at(ra_fixture: &str, expect: Expect) {
+    let def_map = compute_block_def_map(ra_fixture);
+    let actual = def_map.dump();
+    expect.assert_eq(&actual);
+}
+
 #[test]
 fn crate_def_map_smoke_test() {
     check(
diff --git a/crates/hir_def/src/nameres/tests/block.rs b/crates/hir_def/src/nameres/tests/block.rs
new file mode 100644
index 000000000..01d6326a7
--- /dev/null
+++ b/crates/hir_def/src/nameres/tests/block.rs
@@ -0,0 +1,97 @@
+use super::*;
+
+#[test]
+fn inner_item_smoke() {
+    check_at(
+        r#"
+struct inner {}
+fn outer() {
+    $0
+    fn inner() {}
+}
+"#,
+        expect![[r#"
+            block scope
+            inner: v
+            crate
+            inner: t
+            outer: v
+        "#]],
+    );
+}
+
+#[test]
+fn use_from_crate() {
+    check_at(
+        r#"
+struct Struct;
+fn outer() {
+    use Struct;
+    use crate::Struct as CrateStruct;
+    use self::Struct as SelfStruct;
+    $0
+}
+"#,
+        expect![[r#"
+            block scope
+            CrateStruct: t v
+            SelfStruct: t v
+            Struct: t v
+            crate
+            Struct: t v
+            outer: v
+        "#]],
+    );
+}
+
+#[test]
+fn merge_namespaces() {
+    check_at(
+        r#"
+struct name {}
+fn outer() {
+    fn name() {}
+
+    use name as imported; // should import both `name`s
+
+    $0
+}
+"#,
+        expect![[r#"
+            block scope
+            imported: t v
+            name: v
+            crate
+            name: t
+            outer: v
+        "#]],
+    );
+}
+
+#[test]
+fn nested_blocks() {
+    check_at(
+        r#"
+fn outer() {
+    struct inner1 {}
+    fn inner() {
+        use inner1;
+        use outer;
+        fn inner2() {}
+        $0
+    }
+}
+"#,
+        expect![[r#"
+            block scope
+            inner1: t
+            inner2: v
+            outer: v
+            block scope
+            inner: v
+            inner1: t
+            crate
+            outer: v
+        "#]],
+    );
+}