wip: add test

Author: bvanjoi

compiler/rustc_resolve/src/ident.rs

@@ -17,9 +17,9 @@ use crate::late::{ConstantHasGenerics, NoConstantGenericsReason, PathSource, Rib
 use crate::macros::{MacroRulesScope, sub_namespace_match};
 use crate::{
     AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingKey, Determinacy, Finalize,
-    ImportKind, LexicalScopeBinding, Module, ModuleKind, ModuleOrUniformRoot, NameBinding,
-    NameBindingKind, ParentScope, PathResult, PrivacyError, Res, ResolutionError, Resolver, Scope,
-    ScopeSet, Segment, Used, Weak, errors,
+    ImportKind, LexicalScopeBinding, LookaheadItemInBlock, Module, ModuleKind, ModuleOrUniformRoot,
+    NameBinding, NameBindingKind, ParentScope, PathResult, PrivacyError, Res, ResolutionError,
+    Resolver, Scope, ScopeSet, Segment, Used, Weak, errors,
 };
 
 #[derive(Copy, Clone)]
@@ -327,14 +327,32 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             module = match rib.kind {
                 RibKind::Module(module) => module,
-                RibKind::MacroDefinition(def) | RibKind::LookAheadMacroDefinition(def)
-                    if def == self.macro_def(ident.span.ctxt()) =>
-                {
+                RibKind::MacroDefinition(def) if def == self.macro_def(ident.span.ctxt()) => {
                     // If an invocation of this macro created `ident`, give up on `ident`
                     // and switch to `ident`'s source from the macro definition.
                     ident.span.remove_mark();
                     continue;
                 }
+                RibKind::BlockItem { block, resolving } => {
+                    tracing::debug!("------- try resolving {ident:#?} in {ns:#?}");
+                    tracing::debug!("-----resolving in block rib: {block:#?}");
+                    tracing::debug!(
+                        "-----bindings in block rib: {:#?}",
+                        self.lookahead_items_in_block[&block]
+                    );
+                    tracing::debug!("-----resolving: {resolving:#?}",);
+                    match self.lookahead_items_in_block.get(&block).and_then(|b| b.get(&resolving))
+                    {
+                        Some(LookaheadItemInBlock::Binding { name }) => {
+                            tracing::debug!("-----found binding in block rib: {name:#?}")
+                        }
+                        Some(LookaheadItemInBlock::MacroDef { name }) => {
+                            tracing::debug!("-----found macro def in block rib: {name:#?}")
+                        }
+                        _ => {}
+                    }
+                    continue;
+                }
                 _ => continue,
             };
 
@@ -1149,10 +1167,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 for rib in ribs {
                     match rib.kind {
                         RibKind::Normal
+                        | RibKind::BlockItem { .. }
                         | RibKind::FnOrCoroutine
                         | RibKind::Module(..)
                         | RibKind::MacroDefinition(..)
-                        | RibKind::LookAheadMacroDefinition(..)
                         | RibKind::ForwardGenericParamBan(_) => {
                             // Nothing to do. Continue.
                         }
@@ -1242,10 +1260,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 for rib in ribs {
                     let (has_generic_params, def_kind) = match rib.kind {
                         RibKind::Normal
+                        | RibKind::BlockItem { .. }
                         | RibKind::FnOrCoroutine
                         | RibKind::Module(..)
                         | RibKind::MacroDefinition(..)
-                        | RibKind::LookAheadMacroDefinition(..)
                         | RibKind::InlineAsmSym
                         | RibKind::AssocItem
                         | RibKind::ForwardGenericParamBan(_) => {
@@ -1336,10 +1354,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 for rib in ribs {
                     let (has_generic_params, def_kind) = match rib.kind {
                         RibKind::Normal
+                        | RibKind::BlockItem { .. }
                         | RibKind::FnOrCoroutine
                         | RibKind::Module(..)
                         | RibKind::MacroDefinition(..)
-                        | RibKind::LookAheadMacroDefinition(..)
                         | RibKind::InlineAsmSym
                         | RibKind::AssocItem
                         | RibKind::ForwardGenericParamBan(_) => continue,

compiler/rustc_resolve/src/late.rs

@@ -40,9 +40,9 @@ use thin_vec::ThinVec;
 use tracing::{debug, instrument, trace};
 
 use crate::{
-    BindingError, BindingKey, Finalize, LexicalScopeBinding, Module, ModuleOrUniformRoot,
-    NameBinding, ParentScope, PathResult, ResolutionError, Resolver, Segment, TyCtxt, UseError,
-    Used, errors, path_names_to_string, rustdoc,
+    BindingError, BindingKey, Finalize, LexicalScopeBinding, LookaheadItemInBlock, Module,
+    ModuleOrUniformRoot, NameBinding, ParentScope, PathResult, ResolutionError, Resolver, Segment,
+    TyCtxt, UseError, Used, errors, path_names_to_string, rustdoc,
 };
 
 mod diagnostics;
@@ -193,6 +193,26 @@ pub(crate) enum RibKind<'ra> {
     /// No restriction needs to be applied.
     Normal,
 
+    /// During resolving an item in a block, we had records all bindings defined
+    /// in this local scope, for these features:
+    ///
+    /// - Forward reference detection:
+    ///
+    /// ```ignore (illustrative)
+    /// let a = b;  // displays '`b` is defined at <span>' instead of ''b' not found'
+    /// let b = 42;
+    /// ```
+    ///
+    /// - Correctly resolves the hoisting bindings within macro expand:
+    ///
+    /// ```ignore (illustrative)
+    /// let f = || -> i16 { 42 };
+    /// let a: i16 = m!();              // use the local `f` rather than throw an error
+    /// macro_rules! m {() => ( f() )}
+    /// use m;
+    /// ```
+    BlockItem { block: NodeId, resolving: NodeId },
+
     /// We passed through an impl or trait and are now in one of its
     /// methods or associated types. Allow references to ty params that impl or trait
     /// binds. Disallow any other upvars (including other ty params that are
@@ -217,41 +237,6 @@ pub(crate) enum RibKind<'ra> {
     /// We passed through a `macro_rules!` statement
     MacroDefinition(DefId),
 
-    /// Collects `macro_rules!` statements prior to resolution.
-    /// For example:
-    ///
-    /// ```ignore (illustrative)
-    /// let f = || -> i16 { 42 };       // <1>
-    /// let a: i16 = m!();              // <2>
-    /// macro_rules! m {() => ( f() )}  // <3>
-    /// use m;                          // <4>
-    /// ```
-    ///
-    /// We record `<1>` when resolving the value of `<2>` (the expansion
-    /// result of `<3>`), enabling the system to recognize that `<1>` is
-    /// referenced in `<3>`.
-    ///
-    /// ### Why Not Use `MacroDefinition` Directly?
-    ///
-    /// This prevents edge cases like:
-    ///
-    /// ```ignore (illustrative)
-    /// fn f() {
-    ///     let x = 0;              // <1>
-    ///     macro_rules! foo {
-    ///         () => {
-    ///             assert_eq!(x, 0);
-    ///         }
-    ///     }
-    ///     let x = 1;              // <2>
-    ///     foo!();
-    /// }
-    /// ```
-    ///
-    /// Using `MacroDefinition` would incorrectly record both `<1>` and `<2>` as
-    /// potential resolutions for `x` within the macro, leading to assertion failed.
-    LookAheadMacroDefinition(DefId),
-
     /// All bindings in this rib are generic parameters that can't be used
     /// from the default of a generic parameter because they're not declared
     /// before said generic parameter. Also see the `visit_generics` override.
@@ -278,11 +263,11 @@ impl RibKind<'_> {
     pub(crate) fn contains_params(&self) -> bool {
         match self {
             RibKind::Normal
+            | RibKind::BlockItem { .. }
             | RibKind::FnOrCoroutine
             | RibKind::ConstantItem(..)
             | RibKind::Module(_)
             | RibKind::MacroDefinition(_)
-            | RibKind::LookAheadMacroDefinition(_)
             | RibKind::InlineAsmSym => false,
             RibKind::ConstParamTy
             | RibKind::AssocItem
@@ -294,9 +279,7 @@ impl RibKind<'_> {
     /// This rib forbids referring to labels defined in upwards ribs.
     fn is_label_barrier(self) -> bool {
         match self {
-            RibKind::Normal
-            | RibKind::MacroDefinition(..)
-            | RibKind::LookAheadMacroDefinition(..) => false,
+            RibKind::Normal | RibKind::BlockItem { .. } | RibKind::MacroDefinition(..) => false,
 
             RibKind::AssocItem
             | RibKind::FnOrCoroutine
@@ -3818,21 +3801,16 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
     /// Apply the bindings from a pattern to the innermost rib of the current scope.
     fn apply_pattern_bindings(&mut self, mut pat_bindings: PatternBindings) {
+        let rib_bindings = self.innermost_rib_bindings(ValueNS);
         let Some((_, pat_bindings)) = pat_bindings.pop() else {
             bug!("tried applying nonexistent bindings from pattern");
         };
-        for rib in self.ribs[ValueNS].iter_mut().rev() {
-            let stop = !matches!(rib.kind, RibKind::LookAheadMacroDefinition(_));
-            if rib.bindings.is_empty() {
-                // Often, such as for match arms, the bindings are introduced into a new rib.
-                // In this case, we can move the bindings over directly.
-                rib.bindings = pat_bindings.clone();
-            } else {
-                rib.bindings.extend(pat_bindings.clone());
-            }
-            if stop {
-                break;
-            }
+        if rib_bindings.is_empty() {
+            // Often, such as for match arms, the bindings are introduced into a new rib.
+            // In this case, we can move the bindings over directly.
+            *rib_bindings = pat_bindings;
+        } else {
+            rib_bindings.extend(pat_bindings);
         }
     }
 
@@ -3888,9 +3866,20 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     // First try to resolve the identifier as some existing entity,
                     // then fall back to a fresh binding.
                     let has_sub = sub.is_some();
+                    if let Some(RibKind::BlockItem { resolving, .. }) =
+                        self.label_ribs.last_mut().map(|rib| &mut rib.kind)
+                    {
+                        debug_assert_eq!(*resolving, DUMMY_NODE_ID);
+                        *resolving = pat.id;
+                    }
                     let res = self
                         .try_resolve_as_non_binding(pat_src, bmode, ident, has_sub)
                         .unwrap_or_else(|| self.fresh_binding(ident, pat.id, pat_src, bindings));
+                    if let Some(RibKind::BlockItem { resolving, .. }) =
+                        self.label_ribs.last_mut().map(|rib| &mut rib.kind)
+                    {
+                        *resolving = DUMMY_NODE_ID;
+                    }
                     self.r.record_partial_res(pat.id, PartialRes::new(res));
                     self.r.record_pat_span(pat.id, pat.span);
                 }
@@ -4712,15 +4701,6 @@ 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();
-                self.ribs[ValueNS].push(Rib::new(RibKind::LookAheadMacroDefinition(res)));
-            }
-        }
-
         for stmt in &block.stmts {
             if let StmtKind::Item(ref item) = stmt.kind
                 && let ItemKind::MacroDef(..) = item.kind
@@ -4731,14 +4711,22 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 self.label_ribs.push(Rib::new(RibKind::MacroDefinition(res)));
             }
 
+
+            self.with_rib(
+                ValueNS,
+                RibKind::BlockItem { block: block.id, resolving: DUMMY_NODE_ID },
+                |this| {
+                    this.visit_stmt(stmt);
+                },
+            );
+
             self.visit_stmt(stmt);
         }
 
         // Move back up.
         self.parent_scope.module = orig_module;
         for _ in 0..num_macro_definition_ribs {
-            // pop `LookAheadMacroDefinition` and `MacroDefinition`
-            self.ribs[ValueNS].pop();
+            // pop `MacroDefinition`
             self.ribs[ValueNS].pop();
             self.label_ribs.pop();
         }
@@ -5199,6 +5187,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 /// lifetime generic parameters and function parameters.
 struct ItemInfoCollector<'a, 'ra, 'tcx> {
     r: &'a mut Resolver<'ra, 'tcx>,
+    current_block: Option<NodeId>,
 }
 
 impl ItemInfoCollector<'_, '_, '_> {
@@ -5218,6 +5207,26 @@ impl ItemInfoCollector<'_, '_, '_> {
         };
         self.r.delegation_fn_sigs.insert(self.r.local_def_id(id), sig);
     }
+
+    fn collect_fresh_binding(&mut self, binding: NodeId, name: Ident) {
+        let block_id = self.current_block.unwrap();
+        let items = self.r.lookahead_items_in_block.entry(block_id).or_default();
+        items.insert(binding, LookaheadItemInBlock::Binding { name });
+    }
+
+    fn collect_macro_def_in_block(&mut self, block_id: NodeId, node_id: NodeId, name: Symbol) {
+        let items = self.r.lookahead_items_in_block.entry(block_id).or_default();
+        items.insert(node_id, LookaheadItemInBlock::MacroDef { name });
+    }
+
+    fn collect_fresh_binding_in_pat(&mut self, pat: &ast::Pat) {
+        pat.walk(&mut |pat| {
+            if let PatKind::Ident(_, name, _) = &pat.kind {
+                self.collect_fresh_binding(pat.id, *name);
+            }
+            true
+        });
+    }
 }
 
 impl<'ast> Visitor<'ast> for ItemInfoCollector<'_, '_, '_> {
@@ -5255,11 +5264,15 @@ impl<'ast> Visitor<'ast> for ItemInfoCollector<'_, '_, '_> {
                 }
             }
 
+            ItemKind::MacroDef(m, _) => {
+                if let Some(block_id) = self.current_block {
+                    self.collect_macro_def_in_block(block_id, item.id, m.name);
+                }
+            }
             ItemKind::Mod(..)
             | ItemKind::Static(..)
             | ItemKind::Use(..)
             | ItemKind::ExternCrate(..)
-            | ItemKind::MacroDef(..)
             | ItemKind::GlobalAsm(..)
             | ItemKind::MacCall(..)
             | ItemKind::DelegationMac(..) => {}
@@ -5279,11 +5292,22 @@ impl<'ast> Visitor<'ast> for ItemInfoCollector<'_, '_, '_> {
         }
         visit::walk_assoc_item(self, item, ctxt);
     }
+
+    fn visit_local(&mut self, node: &'ast Local) -> Self::Result {
+        self.collect_fresh_binding_in_pat(&node.pat);
+        visit::walk_local(self, node)
+    }
+
+    fn visit_block(&mut self, node: &'ast Block) -> Self::Result {
+        let saved_block_id = self.current_block.replace(node.id);
+        visit::walk_block(self, node);
+        self.current_block = saved_block_id;
+    }
 }
 
 impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     pub(crate) fn late_resolve_crate(&mut self, krate: &Crate) {
-        visit::walk_crate(&mut ItemInfoCollector { r: self }, krate);
+        visit::walk_crate(&mut ItemInfoCollector { r: self, current_block: None }, krate);
         let mut late_resolution_visitor = LateResolutionVisitor::new(self);
         late_resolution_visitor.resolve_doc_links(&krate.attrs, MaybeExported::Ok(CRATE_NODE_ID));
         visit::walk_crate(&mut late_resolution_visitor, krate);

compiler/rustc_resolve/src/lib.rs

@@ -1042,6 +1042,14 @@ pub struct ResolverOutputs {
     pub ast_lowering: ResolverAstLowering,
 }
 
+#[derive(Debug)]
+enum LookaheadItemInBlock {
+    /// such as `let x = 1;`
+    Binding { name: Ident },
+    /// such as `macro_rules! foo { ... }`
+    MacroDef { name: Symbol },
+}
+
 /// The main resolver class.
 ///
 /// This is the visitor that walks the whole crate.
@@ -1106,6 +1114,7 @@ pub struct Resolver<'ra, 'tcx> {
     /// There will be an anonymous module created around `g` with the ID of the
     /// entry block for `f`.
     block_map: NodeMap<Module<'ra>>,
+    lookahead_items_in_block: NodeMap<FxIndexMap<NodeId, LookaheadItemInBlock>>,
     /// 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.
@@ -1629,6 +1638,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             current_crate_outer_attr_insert_span,
             mods_with_parse_errors: Default::default(),
             impl_trait_names: Default::default(),
+            lookahead_items_in_block: Default::default(),
         };
 
         let root_parent_scope = ParentScope::module(graph_root, &resolver);