record seen macro def during late resolve

Author: bvanjoi

compiler/rustc_resolve/src/ident.rs

@@ -287,6 +287,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ribs: &[Rib<'ra>],
         ignore_binding: Option<NameBinding<'ra>>,
     ) -> ResolveIdentInBlockRes<'ra> {
+        let mut original_ident = *ident;
+
         fn resolve_ident_in_forward_macro_of_block<'ra>(
             r: &mut Resolver<'ra, '_>,
             expansion: &mut Option<NodeId>, // macro_def_id
@@ -410,20 +412,28 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             return ResolveIdentInBlockRes::DefinedLater { def_site };
         }
 
-        if let Some(module) = block_module
-            && let Ok(binding) = self.cm().resolve_ident_in_module_unadjusted(
+        if let Some(module) = block_module {
+            if let Some(seen_macro_def_list) = self.seen_macro_def_in_block.get(&resolving_block) {
+                for m in seen_macro_def_list.iter().rev() {
+                    if self.macro_def(original_ident.span.ctxt()) == *m {
+                        original_ident.span.remove_mark();
+                    }
+                }
+            }
+
+            if let Ok(binding) = self.cm().resolve_ident_in_module_unadjusted(
                 ModuleOrUniformRoot::Module(module),
-                *ident,
+                original_ident,
                 ns,
                 parent_scope,
                 Shadowing::Unrestricted,
                 finalize.map(|finalize| Finalize { used: Used::Scope, ..finalize }),
                 ignore_binding,
                 None,
-            )
-        {
-            // The ident resolves to an item in a block.
-            return ResolveIdentInBlockRes::Item(binding);
+            ) {
+                // The ident resolves to an item in a block.
+                return ResolveIdentInBlockRes::Item(binding);
+            }
         }
 
         ResolveIdentInBlockRes::NotFound

compiler/rustc_resolve/src/late.rs

@@ -2484,12 +2484,10 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             let rib = &self.label_ribs[i];
 
             if let RibKind::Block { id, .. } = rib.kind
-                && let Some(items) = self.r.lookahead_items_in_block.get(&id)
+                && let Some(seen_macro_def_list) = self.r.seen_macro_def_in_block.get(&id)
             {
-                for (_, item) in items.iter().rev() {
-                    if let LookaheadItemInBlock::MacroDef { def_id, .. } = item
-                        && *def_id == self.r.macro_def(label.span.ctxt())
-                    {
+                for def in seen_macro_def_list.iter().rev() {
+                    if *def == self.r.macro_def(label.span.ctxt()) {
                         // If an invocation of this macro created `ident`, give up on `ident`
                         // and switch to `ident`'s source from the macro definition.
                         label.span.remove_mark();
@@ -4778,6 +4776,14 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
         // Descend into the block.
         for stmt in &block.stmts {
+            if let StmtKind::Item(ref item) = stmt.kind
+                && let ItemKind::MacroDef(..) = item.kind
+            {
+                let res = self.r.local_def_id(item.id).to_def_id();
+                let seen = self.r.seen_macro_def_in_block.entry(block.id).or_default();
+                seen.insert(res);
+            }
+
             self.visit_stmt(stmt);
         }
 

compiler/rustc_resolve/src/lib.rs

@@ -1150,6 +1150,7 @@ pub struct Resolver<'ra, 'tcx> {
     block_map: NodeMap<Module<'ra>>,
     lookahead_items_in_block: NodeMap<FxIndexMap<NodeId, LookaheadItemInBlock>>,
     bindings_of_macro_def: DefIdMap<FxHashMap<Ident, (Module<'ra>, Res, Span)>>,
+    seen_macro_def_in_block: NodeMap<FxIndexSet<DefId>>,
     /// A fake module that contains no definition and no prelude. Used so that
     /// some AST passes can generate identifiers that only resolve to local or
     /// lang items.
@@ -1679,6 +1680,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             impl_trait_names: Default::default(),
             lookahead_items_in_block: Default::default(),
             bindings_of_macro_def: Default::default(),
+            seen_macro_def_in_block: Default::default(),
             ..
         };