DefCollector stuff

BoxyUwU · BoxyUwU · commit a43257a46a00 · 2025-12-17T23:40:58.000Z
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2424,6 +2424,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField);
 
                     let expr = if let ExprKind::ConstBlock(anon_const) = &f.expr.kind {
+                        let def_id = self.local_def_id(anon_const.id);
+                        let def_kind = self.tcx.def_kind(def_id);
+                        assert_eq!(DefKind::AnonConst, def_kind);
+
                         self.lower_anon_const_to_const_arg_direct(anon_const)
                     } else {
                         self.lower_expr_to_const_arg_direct(&f.expr)
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
@@ -11,16 +11,17 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_middle::span_bug;
 use rustc_span::hygiene::LocalExpnId;
 use rustc_span::{Span, Symbol, sym};
-use tracing::debug;
+use tracing::{debug, instrument};
 
-use crate::{ImplTraitContext, InvocationParent, Resolver};
+use crate::{ConstArgContext, ImplTraitContext, InvocationParent, Resolver};
 
 pub(crate) fn collect_definitions(
     resolver: &mut Resolver<'_, '_>,
     fragment: &AstFragment,
     expansion: LocalExpnId,
 ) {
     let invocation_parent = resolver.invocation_parents[&expansion];
+    debug!("new fragment to visit with invocation_parent: {invocation_parent:?}");
     let mut visitor = DefCollector { resolver, expansion, invocation_parent };
     fragment.visit_with(&mut visitor);
 }
@@ -74,10 +75,10 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
         self.invocation_parent.impl_trait_context = orig_itc;
     }
 
-    fn with_direct_const_arg<F: FnOnce(&mut Self)>(&mut self, is_direct: bool, f: F) {
-        let orig = mem::replace(&mut self.invocation_parent.in_direct_const_arg, is_direct);
+    fn with_const_arg<F: FnOnce(&mut Self)>(&mut self, ctxt: ConstArgContext, f: F) {
+        let orig = mem::replace(&mut self.invocation_parent.const_arg_context, ctxt);
         f(self);
-        self.invocation_parent.in_direct_const_arg = orig;
+        self.invocation_parent.const_arg_context = orig;
     }
 
     fn collect_field(&mut self, field: &'a FieldDef, index: Option<usize>) {
@@ -99,7 +100,10 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
         }
     }
 
+    #[instrument(level = "debug", skip(self))]
     fn visit_macro_invoc(&mut self, id: NodeId) {
+        debug!(?self.invocation_parent);
+
         let id = id.placeholder_to_expn_id();
         let old_parent = self.resolver.invocation_parents.insert(id, self.invocation_parent);
         assert!(old_parent.is_none(), "parent `LocalDefId` is reset for an invocation");
@@ -363,73 +367,84 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
     }
 
     fn visit_anon_const(&mut self, constant: &'a AnonConst) {
-        // `MgcaDisambiguation::Direct` is set even when MGCA is disabled, so
-        // to avoid affecting stable we have to feature gate the not creating
-        // anon consts
-        if let MgcaDisambiguation::Direct = constant.mgca_disambiguation
-            && self.resolver.tcx.features().min_generic_const_args()
-        {
-            self.with_direct_const_arg(true, |this| {
+        match constant.mgca_disambiguation {
+            // `MgcaDisambiguation::Direct` is set even when MGCA is disabled, so
+            // to avoid affecting stable we have to feature gate the not creating
+            // anon consts
+            _ if !self.resolver.tcx.features().min_generic_const_args() => {
+                let parent =
+                    self.create_def(constant.id, None, DefKind::AnonConst, constant.value.span);
+                self.with_parent(parent, |this| visit::walk_anon_const(this, constant));
+            }
+            MgcaDisambiguation::Direct => self.with_const_arg(ConstArgContext::Direct, |this| {
                 visit::walk_anon_const(this, constant);
-            });
-            return;
-        }
-
-        self.with_direct_const_arg(false, |this| {
-            let parent =
-                this.create_def(constant.id, None, DefKind::AnonConst, constant.value.span);
-            this.with_parent(parent, |this| visit::walk_anon_const(this, constant));
-        })
+            }),
+            MgcaDisambiguation::AnonConst => {
+                self.with_const_arg(ConstArgContext::NonDirect, |this| {
+                    let parent =
+                        this.create_def(constant.id, None, DefKind::AnonConst, constant.value.span);
+                    this.with_parent(parent, |this| visit::walk_anon_const(this, constant));
+                })
+            }
+        };
     }
 
+    #[instrument(level = "debug", skip(self))]
     fn visit_expr(&mut self, expr: &'a Expr) {
-        let handle_const_block = |this: &mut Self, constant: &'a AnonConst, def_kind: DefKind| {
-            for attr in &expr.attrs {
-                visit::walk_attribute(this, attr);
-            }
+        debug!(?self.invocation_parent);
 
-            let def = this.create_def(constant.id, None, def_kind, constant.value.span);
-            this.with_direct_const_arg(false, |this| {
-                this.with_parent(def, |this| visit::walk_anon_const(this, constant));
-            });
-        };
-
-        let parent_def = match expr.kind {
+        let parent_def = match &expr.kind {
             ExprKind::MacCall(..) => return self.visit_macro_invoc(expr.id),
             ExprKind::Closure(..) | ExprKind::Gen(..) => {
                 self.create_def(expr.id, None, DefKind::Closure, expr.span)
             }
-            ExprKind::ConstBlock(ref constant) => {
-                handle_const_block(self, constant, DefKind::InlineConst);
-                return;
-            }
-            ExprKind::Struct(ref se) if self.invocation_parent.in_direct_const_arg => {
-                let StructExpr { qself, path, fields, rest } = &**se;
-
-                for init_expr in fields {
-                    if let ExprKind::ConstBlock(ref constant) = init_expr.expr.kind {
-                        handle_const_block(self, constant, DefKind::AnonConst);
-                    } else {
-                        visit::walk_expr_field(self, init_expr);
+            ExprKind::ConstBlock(constant) => {
+                // Under `min_generic_const_args` a `const { }` block sometimes
+                // corresponds to an anon const rather than an inline const.
+                let def_kind = match self.invocation_parent.const_arg_context {
+                    ConstArgContext::Direct => DefKind::AnonConst,
+                    ConstArgContext::NonDirect => DefKind::InlineConst,
+                };
+
+                return self.with_const_arg(ConstArgContext::NonDirect, |this| {
+                    for attr in &expr.attrs {
+                        visit::walk_attribute(this, attr);
                     }
-                }
 
-                if let Some(qself) = qself {
-                    self.visit_qself(qself);
+                    let def = this.create_def(constant.id, None, def_kind, constant.value.span);
+                    this.with_parent(def, |this| visit::walk_anon_const(this, constant));
+                });
+            }
+
+            // Avoid overwriting `const_arg_context` as we may want to treat const blocks
+            // as being anon consts if we are inside a const argument.
+            ExprKind::Struct(_) => return visit::walk_expr(self, expr),
+            // FIXME(mgca): we may want to handle block labels in some manner
+            ExprKind::Block(block, _) if let [stmt] = block.stmts.as_slice() => match stmt.kind {
+                StmtKind::Let(..) | StmtKind::Item(..) | StmtKind::Semi(..) | StmtKind::Empty => {
+                    return self.with_const_arg(ConstArgContext::NonDirect, |this| {
+                        visit::walk_expr(this, expr)
+                    });
                 }
-                self.visit_path(path);
 
-                match rest {
-                    StructRest::Base(expr) => self.visit_expr(expr),
-                    _ => (),
+                // FIXME(mgca): this probably means that mac calls that expand
+                // to semi'd const blocks are handled differently to just writing
+                // out a semi'd const block.
+                StmtKind::Expr(..) | StmtKind::MacCall(..) => {
+                    return visit::walk_expr(self, expr);
                 }
+            },
 
-                return;
+            _ => {
+                return self.with_const_arg(ConstArgContext::NonDirect, |this| {
+                    visit::walk_expr(this, expr)
+                });
             }
-            _ => self.invocation_parent.parent_def,
         };
 
-        self.with_parent(parent_def, |this| visit::walk_expr(this, expr))
+        self.with_const_arg(ConstArgContext::NonDirect, |this| {
+            this.with_parent(parent_def, |this| visit::walk_expr(this, expr))
+        })
     }
 
     fn visit_ty(&mut self, ty: &'a Ty) {
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -187,15 +187,15 @@ struct InvocationParent {
     parent_def: LocalDefId,
     impl_trait_context: ImplTraitContext,
     in_attr: bool,
-    in_direct_const_arg: bool,
+    const_arg_context: ConstArgContext,
 }
 
 impl InvocationParent {
     const ROOT: Self = Self {
         parent_def: CRATE_DEF_ID,
         impl_trait_context: ImplTraitContext::Existential,
         in_attr: false,
-        in_direct_const_arg: false,
+        const_arg_context: ConstArgContext::NonDirect,
     };
 }
 
@@ -206,6 +206,13 @@ enum ImplTraitContext {
     InBinding,
 }
 
+#[derive(Copy, Clone, Debug)]
+enum ConstArgContext {
+    Direct,
+    /// Either inside of an `AnonConst` or not inside a const argument at all.
+    NonDirect,
+}
+
 /// Used for tracking import use types which will be used for redundant import checking.
 ///
 /// ### Used::Scope Example
diff --git a/tests/ui/const-generics/mgca/struct_expr_with_macros.rs b/tests/ui/const-generics/mgca/struct_expr_with_macros.rs
@@ -0,0 +1,31 @@
+//@ check-pass
+
+// Test that the def collector makes `AnonConst`s not `InlineConst`s even
+// when the const block is obscured via macros.
+
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+
+macro_rules! const_block {
+    ($e:expr) => { const { 
+        $e
+    } }
+}
+
+macro_rules! foo_expr {
+    ($e:expr) => { Foo {
+        field: $e,
+    } }
+}
+
+use std::marker::ConstParamTy;
+
+#[derive(PartialEq, Eq, ConstParamTy)]
+struct Foo { field: u32 }
+
+fn foo<const N: Foo>() {}
+
+fn main() {
+    foo::<{ Foo { field: const_block!{ 1 + 1 }} }>();
+    foo::<{ foo_expr! { const_block! { 1 + 1 }} }>();
+}
