Add name resolution query for block expressions

3 files changed, 108 insertions, 17 deletions

diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 61da56340..cd68efbe6 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -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: DefMap) -> DefMap {
+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: DefMap) -> DefMap
         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()
 }
@@ -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 {
@@ -1470,7 +1506,6 @@ impl ModCollector<'_, '_> {
 mod tests {
     use crate::{db::DefDatabase, test_db::TestDB};
     use base_db::{fixture::WithFixture, SourceDatabase};
-    use la_arena::Arena;
 
     use super::*;
 
@@ -1489,6 +1524,7 @@ mod tests {
             exports_proc_macros: false,
             from_glob_import: Default::default(),
         };
+        collector.seed_with_top_level();
         collector.collect();
         collector.def_map
     }
@@ -1497,20 +1533,8 @@ mod tests {
         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());
-            DefMap {
-                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/tests.rs b/crates/hir_def/src/nameres/tests.rs
index 723481c36..73e3a4702 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -4,11 +4,13 @@ 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};
@@ -19,12 +21,30 @@ fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
     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..996704308
--- /dev/null
+++ b/crates/hir_def/src/nameres/tests/block.rs
@@ -0,0 +1,47 @@
+use super::*;
+
+#[test]
+fn inner_item_smoke() {
+    check_at(
+        r#"
+//- /lib.rs
+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#"
+//- /lib.rs
+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
+        "#]],
+    );
+}