2 files changed, 301 insertions, 2 deletions

diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index 2e5d0a01e..da60072ce 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -1,7 +1,10 @@
-use base_db::{fixture::WithFixture, SourceDatabase};
+mod block;
+
+use base_db::{fixture::WithFixture, FilePosition, SourceDatabase};
+use expect_test::Expect;
 use test_utils::mark;
 
-use crate::{test_db::TestDB, ModuleDefId};
+use crate::{test_db::TestDB, BlockId, ModuleDefId};
 
 use super::*;
 
@@ -31,6 +34,115 @@ fn check_diagnostics(ra_fixture: &str) {
     db.check_diagnostics();
 }
 
+fn block_def_map_at(ra_fixture: &str) -> Arc<DefMap> {
+    let (db, position) = crate::test_db::TestDB::with_position(ra_fixture);
+
+    let krate = db.crate_graph().iter().next().unwrap();
+    let def_map = db.crate_def_map(krate);
+
+    let mut block =
+        block_at_pos(&db, &def_map, position).expect("couldn't find enclosing function or block");
+    loop {
+        let def_map = db.block_def_map(block);
+        let new_block = block_at_pos(&db, &def_map, position);
+        match new_block {
+            Some(new_block) => {
+                assert_ne!(block, new_block);
+                block = new_block;
+            }
+            None => {
+                return def_map;
+            }
+        }
+    }
+}
+
+fn block_at_pos(db: &dyn DefDatabase, def_map: &DefMap, position: FilePosition) -> Option<BlockId> {
+    let mut size = None;
+    let mut fn_def = None;
+    for (_, module) in def_map.modules() {
+        let file_id = module.definition_source(db).file_id;
+        if file_id != position.file_id.into() {
+            continue;
+        }
+        let root = db.parse_or_expand(file_id).unwrap();
+        let ast_map = db.ast_id_map(file_id);
+        let item_tree = db.item_tree(file_id);
+        for decl in module.scope.declarations() {
+            if let ModuleDefId::FunctionId(it) = decl {
+                let ast = ast_map.get(item_tree[it.lookup(db).id.value].ast_id).to_node(&root);
+                let range = ast.syntax().text_range();
+
+                // Find the smallest (innermost) function containing the cursor.
+                if !range.contains(position.offset) {
+                    continue;
+                }
+
+                let new_size = match size {
+                    None => range.len(),
+                    Some(size) => {
+                        if range.len() < size {
+                            range.len()
+                        } else {
+                            size
+                        }
+                    }
+                };
+                if size != Some(new_size) {
+                    size = Some(new_size);
+                    fn_def = Some(it);
+                }
+            }
+        }
+    }
+
+    let (body, source_map) = db.body_with_source_map(fn_def?.into());
+
+    // Now find the smallest encompassing block expression in the function body.
+    let mut size = None;
+    let mut block_id = None;
+    for (expr_id, expr) in body.exprs.iter() {
+        if let Expr::Block { id, .. } = expr {
+            if let Ok(ast) = source_map.expr_syntax(expr_id) {
+                if ast.file_id != position.file_id.into() {
+                    continue;
+                }
+
+                let root = db.parse_or_expand(ast.file_id).unwrap();
+                let ast = ast.value.to_node(&root);
+                let range = ast.syntax().text_range();
+
+                if !range.contains(position.offset) {
+                    continue;
+                }
+
+                let new_size = match size {
+                    None => range.len(),
+                    Some(size) => {
+                        if range.len() < size {
+                            range.len()
+                        } else {
+                            size
+                        }
+                    }
+                };
+                if size != Some(new_size) {
+                    size = Some(new_size);
+                    block_id = Some(*id);
+                }
+            }
+        }
+    }
+
+    Some(block_id.expect("can't find block containing cursor"))
+}
+
+fn check_at(ra_fixture: &str, expect: Expect) {
+    let def_map = block_def_map_at(ra_fixture);
+    let actual = def_map.dump();
+    expect.assert_eq(&actual);
+}
+
 #[test]
 fn your_stack_belongs_to_me() {
     mark::check!(your_stack_belongs_to_me);
diff --git a/crates/hir_def/src/body/tests/block.rs b/crates/hir_def/src/body/tests/block.rs
new file mode 100644
index 000000000..6b1ed2555
--- /dev/null
+++ b/crates/hir_def/src/body/tests/block.rs
@@ -0,0 +1,187 @@
+use super::*;
+use expect_test::expect;
+
+#[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
+        "#]],
+    );
+}
+
+#[test]
+fn super_imports() {
+    check_at(
+        r#"
+mod module {
+    fn f() {
+        use super::Struct;
+        $0
+    }
+}
+
+struct Struct {}
+"#,
+        expect![[r#"
+            block scope
+            Struct: t
+            crate
+            Struct: t
+            module: t
+
+            crate::module
+            f: v
+        "#]],
+    );
+}
+
+#[test]
+fn legacy_macro_items() {
+    // Checks that legacy-scoped `macro_rules!` from parent namespaces are resolved and expanded
+    // correctly.
+    check_at(
+        r#"
+macro_rules! hit {
+    () => {
+        struct Hit {}
+    }
+}
+
+fn f() {
+    hit!();
+    $0
+}
+"#,
+        expect![[r#"
+            block scope
+            Hit: t
+            crate
+            f: v
+        "#]],
+    );
+}
+
+#[test]
+fn macro_resolve() {
+    check_at(
+        r#"
+//- /lib.rs crate:lib deps:core
+use core::mark;
+
+fn f() {
+    fn nested() {
+        mark::hit!(Hit);
+        $0
+    }
+}
+//- /core.rs crate:core
+pub mod mark {
+    #[macro_export]
+    macro_rules! _hit {
+        ($name:ident) => {
+            struct $name {}
+        }
+    }
+
+    pub use crate::_hit as hit;
+}
+"#,
+        expect![[r#"
+            block scope
+            Hit: t
+            block scope
+            nested: v
+            crate
+            f: v
+            mark: t
+        "#]],
+    );
+}