6 files changed, 109 insertions, 22 deletions

diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 1e5c94660..42d9f0947 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -98,15 +98,17 @@ impl ItemTree {
                     ctx.lower_module_items(&items)
                 },
                 ast::MacroStmts(stmts) => {
-                    ctx.lower_inner_items(stmts.syntax())
+                    // The produced statements can include items, which should be added as top-level
+                    // items.
+                    ctx.lower_macro_stmts(stmts)
                 },
-                // Macros can expand to expressions. We return an empty item tree in this case, but
-                // still need to collect inner items.
                 ast::Expr(e) => {
+                    // Macros can expand to expressions. We return an empty item tree in this case, but
+                    // still need to collect inner items.
                     ctx.lower_inner_items(e.syntax())
                 },
                 _ => {
-                    panic!("cannot create item tree from {:?}", syntax);
+                    panic!("cannot create item tree from {:?} {}", syntax, syntax);
                 },
             }
         };
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 8a71376b9..acc001add 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -61,6 +61,32 @@ impl Ctx {
         self.tree
     }
 
+    pub(super) fn lower_macro_stmts(mut self, stmts: ast::MacroStmts) -> ItemTree {
+        self.tree.top_level = stmts
+            .statements()
+            .filter_map(|stmt| match stmt {
+                ast::Stmt::Item(item) => Some(item),
+                _ => None,
+            })
+            .flat_map(|item| self.lower_mod_item(&item, false))
+            .flat_map(|items| items.0)
+            .collect();
+
+        // Non-items need to have their inner items collected.
+        for stmt in stmts.statements() {
+            match stmt {
+                ast::Stmt::ExprStmt(_) | ast::Stmt::LetStmt(_) => {
+                    self.collect_inner_items(stmt.syntax())
+                }
+                _ => {}
+            }
+        }
+        if let Some(expr) = stmts.expr() {
+            self.collect_inner_items(expr.syntax());
+        }
+        self.tree
+    }
+
     pub(super) fn lower_inner_items(mut self, within: &SyntaxNode) -> ItemTree {
         self.collect_inner_items(within);
         self.tree
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 005b36e02..6169b3bbc 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -199,16 +199,10 @@ impl DefMap {
 
     pub(crate) fn block_def_map_query(db: &dyn DefDatabase, block_id: BlockId) -> Arc<DefMap> {
         let block: BlockLoc = db.lookup_intern_block(block_id);
-        let item_tree = db.item_tree(block.ast_id.file_id);
-        let block_items = item_tree.inner_items_of_block(block.ast_id.value);
-
         let parent = block.module.def_map(db);
 
-        if block_items.is_empty() {
-            // If there are no inner items, nothing new is brought into scope, so we can just return
-            // the parent DefMap. This keeps DefMap parent chains short.
-            return parent;
-        }
+        // FIXME: It would be good to just return the parent map when the block has no items, but
+        // we rely on `def_map.block` in a few places, which is `Some` for the inner `DefMap`.
 
         let block_info =
             BlockInfo { block: block_id, parent, parent_module: block.module.local_id };
@@ -216,7 +210,7 @@ impl DefMap {
         let mut def_map = DefMap::empty(block.module.krate, block_info.parent.edition);
         def_map.block = Some(block_info);
 
-        let def_map = collector::collect_defs(db, def_map, Some(block.ast_id.value));
+        let def_map = collector::collect_defs(db, def_map, Some(block.ast_id));
         Arc::new(def_map)
     }
 
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 761b29c86..ae98fadac 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -48,7 +48,7 @@ const FIXED_POINT_LIMIT: usize = 8192;
 pub(super) fn collect_defs(
     db: &dyn DefDatabase,
     mut def_map: DefMap,
-    block: Option<FileAstId<ast::BlockExpr>>,
+    block: Option<AstId<ast::BlockExpr>>,
 ) -> DefMap {
     let crate_graph = db.crate_graph();
 
@@ -261,11 +261,10 @@ impl DefCollector<'_> {
         }
     }
 
-    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());
+    fn seed_with_inner(&mut self, block: AstId<ast::BlockExpr>) {
+        let item_tree = self.db.item_tree(block.file_id);
         let module_id = self.def_map.root;
-        self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
+        self.def_map.modules[module_id].origin = ModuleOrigin::BlockExpr { block };
         if item_tree
             .top_level_attrs(self.db, self.def_map.krate)
             .cfg()
@@ -275,11 +274,11 @@ impl DefCollector<'_> {
                 def_collector: &mut *self,
                 macro_depth: 0,
                 module_id,
-                file_id: file_id.into(),
+                file_id: block.file_id,
                 item_tree: &item_tree,
                 mod_dir: ModDir::root(),
             }
-            .collect(item_tree.inner_items_of_block(block));
+            .collect(item_tree.inner_items_of_block(block.value));
         }
     }
 
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index 419e465ed..2a0f8ec2b 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -103,7 +103,7 @@ impl DefMap {
         &self,
         db: &dyn DefDatabase,
         mode: ResolveMode,
-        original_module: LocalModuleId,
+        mut original_module: LocalModuleId,
         path: &ModPath,
         shadow: BuiltinShadowMode,
     ) -> ResolvePathResult {
@@ -130,7 +130,10 @@ impl DefMap {
             result.segment_index = result.segment_index.min(new.segment_index);
 
             match &current_map.block {
-                Some(block) => current_map = &block.parent,
+                Some(block) => {
+                    current_map = &block.parent;
+                    original_module = block.parent_module;
+                }
                 None => return result,
             }
         }
diff --git a/crates/hir_def/src/nameres/tests/block.rs b/crates/hir_def/src/nameres/tests/block.rs
index 470ca593e..6cc659513 100644
--- a/crates/hir_def/src/nameres/tests/block.rs
+++ b/crates/hir_def/src/nameres/tests/block.rs
@@ -121,3 +121,66 @@ struct Struct {}
         "#]],
     );
 }
+
+#[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
+        "#]],
+    );
+}