Introduce hir::ConstArgKind::Struct

BoxyUwU · BoxyUwU · commit db43985ddf0e · 2025-11-20T01:14:24.000Z
diff --git a/compiler/rustc_ast_lowering/src/index.rs b/compiler/rustc_ast_lowering/src/index.rs
@@ -281,6 +281,13 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         });
     }
 
+    fn visit_const_arg_expr_field(&mut self, field: &'hir ConstArgExprField<'hir>) {
+        self.insert(field.span, field.hir_id, Node::ConstArgExprField(field));
+        self.with_parent(field.hir_id, |this| {
+            intravisit::walk_const_arg_expr_field(this, field);
+        })
+    }
+
     fn visit_stmt(&mut self, stmt: &'hir Stmt<'hir>) {
         self.insert(stmt.span, stmt.hir_id, Node::Stmt(stmt));
 
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2383,6 +2383,37 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Path(qpath) }
             }
+            ExprKind::Struct(se) => {
+                let path = self.lower_qpath(
+                    expr.id,
+                    &se.qself,
+                    &se.path,
+                    ParamMode::Explicit,
+                    AllowReturnTypeNotation::No,
+                    ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    None,
+                );
+
+                let fields = self.arena.alloc_from_iter(se.fields.iter().map(|f| {
+                    let hir_id = self.lower_node_id(f.id);
+                    self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField);
+
+                    let expr = if let ExprKind::ConstBlock(anon_const) = &f.expr.kind {
+                        self.lower_anon_const_to_const_arg_direct(anon_const)
+                    } else {
+                        self.lower_expr_to_const_arg_direct(&f.expr)
+                    };
+
+                    &*self.arena.alloc(hir::ConstArgExprField {
+                        hir_id,
+                        field: self.lower_ident(f.ident),
+                        expr: self.arena.alloc(expr),
+                        span: self.lower_span(f.span),
+                    })
+                }));
+
+                ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Struct(path, fields) }
+            }
             ExprKind::Underscore => ConstArg {
                 hir_id: self.lower_node_id(expr.id),
                 kind: hir::ConstArgKind::Infer(expr.span, ()),
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -494,6 +494,7 @@ impl<'hir, Unambig> ConstArg<'hir, Unambig> {
 
     pub fn span(&self) -> Span {
         match self.kind {
+            ConstArgKind::Struct(path, _) => path.span(),
             ConstArgKind::Path(path) => path.span(),
             ConstArgKind::Anon(anon) => anon.span,
             ConstArgKind::Error(span, _) => span,
@@ -513,13 +514,23 @@ pub enum ConstArgKind<'hir, Unambig = ()> {
     /// However, in the future, we'll be using it for all of those.
     Path(QPath<'hir>),
     Anon(&'hir AnonConst),
+    /// Represents construction of struct/struct variants
+    Struct(QPath<'hir>, &'hir [&'hir ConstArgExprField<'hir>]),
     /// Error const
     Error(Span, ErrorGuaranteed),
     /// This variant is not always used to represent inference consts, sometimes
     /// [`GenericArg::Infer`] is used instead.
     Infer(Span, Unambig),
 }
 
+#[derive(Clone, Copy, Debug, HashStable_Generic)]
+pub struct ConstArgExprField<'hir> {
+    pub hir_id: HirId,
+    pub span: Span,
+    pub field: Ident,
+    pub expr: &'hir ConstArg<'hir>,
+}
+
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
 pub struct InferArg {
     #[stable_hasher(ignore)]
@@ -4646,6 +4657,7 @@ pub enum Node<'hir> {
     ConstArg(&'hir ConstArg<'hir>),
     Expr(&'hir Expr<'hir>),
     ExprField(&'hir ExprField<'hir>),
+    ConstArgExprField(&'hir ConstArgExprField<'hir>),
     Stmt(&'hir Stmt<'hir>),
     PathSegment(&'hir PathSegment<'hir>),
     Ty(&'hir Ty<'hir>),
@@ -4705,6 +4717,7 @@ impl<'hir> Node<'hir> {
             Node::AssocItemConstraint(c) => Some(c.ident),
             Node::PatField(f) => Some(f.ident),
             Node::ExprField(f) => Some(f.ident),
+            Node::ConstArgExprField(f) => Some(f.field),
             Node::PreciseCapturingNonLifetimeArg(a) => Some(a.ident),
             Node::Param(..)
             | Node::AnonConst(..)
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -396,6 +396,9 @@ pub trait Visitor<'v>: Sized {
     fn visit_expr_field(&mut self, field: &'v ExprField<'v>) -> Self::Result {
         walk_expr_field(self, field)
     }
+    fn visit_const_arg_expr_field(&mut self, field: &'v ConstArgExprField<'v>) -> Self::Result {
+        walk_const_arg_expr_field(self, field)
+    }
     fn visit_pattern_type_pattern(&mut self, p: &'v TyPat<'v>) -> Self::Result {
         walk_ty_pat(self, p)
     }
@@ -954,6 +957,17 @@ pub fn walk_expr_field<'v, V: Visitor<'v>>(visitor: &mut V, field: &'v ExprField
     try_visit!(visitor.visit_ident(*ident));
     visitor.visit_expr(*expr)
 }
+
+pub fn walk_const_arg_expr_field<'v, V: Visitor<'v>>(
+    visitor: &mut V,
+    field: &'v ConstArgExprField<'v>,
+) -> V::Result {
+    let ConstArgExprField { hir_id, field, expr, span: _ } = field;
+    try_visit!(visitor.visit_id(*hir_id));
+    try_visit!(visitor.visit_ident(*field));
+    visitor.visit_const_arg_unambig(*expr)
+}
+
 /// We track whether an infer var is from a [`Ty`], [`ConstArg`], or [`GenericArg`] so that
 /// HIR visitors overriding [`Visitor::visit_infer`] can determine what kind of infer is being visited
 pub enum InferKind<'hir> {
@@ -1068,7 +1082,17 @@ pub fn walk_const_arg<'v, V: Visitor<'v>>(
 ) -> V::Result {
     let ConstArg { hir_id, kind } = const_arg;
     try_visit!(visitor.visit_id(*hir_id));
+
     match kind {
+        ConstArgKind::Struct(qpath, field_exprs) => {
+            try_visit!(visitor.visit_qpath(qpath, *hir_id, qpath.span()));
+
+            for field_expr in *field_exprs {
+                try_visit!(visitor.visit_const_arg_expr_field(field_expr));
+            }
+
+            V::Result::output()
+        }
         ConstArgKind::Path(qpath) => visitor.visit_qpath(qpath, *hir_id, qpath.span()),
         ConstArgKind::Anon(anon) => visitor.visit_anon_const(*anon),
         ConstArgKind::Error(_, _) => V::Result::output(), // errors and spans are not important
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2263,6 +2263,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 )
                 .unwrap_or_else(|guar| Const::new_error(tcx, guar))
             }
+            hir::ConstArgKind::Struct(..) => {
+                span_bug!(const_arg.span(), "lowering `{:?}` is not yet implemented", const_arg)
+            }
             hir::ConstArgKind::Anon(anon) => self.lower_anon_const(anon),
             hir::ConstArgKind::Infer(span, ()) => self.ct_infer(None, span),
             hir::ConstArgKind::Error(_, e) => ty::Const::new_error(tcx, e),
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -180,6 +180,8 @@ impl<'a> State<'a> {
             Node::ConstArg(a) => self.print_const_arg(a),
             Node::Expr(a) => self.print_expr(a),
             Node::ExprField(a) => self.print_expr_field(a),
+            // FIXME(mgca): proper printing for struct exprs
+            Node::ConstArgExprField(_) => self.word("/* STRUCT EXPR */"),
             Node::Stmt(a) => self.print_stmt(a),
             Node::PathSegment(a) => self.print_path_segment(a),
             Node::Ty(a) => self.print_type(a),
@@ -1140,6 +1142,8 @@ impl<'a> State<'a> {
 
     fn print_const_arg(&mut self, const_arg: &hir::ConstArg<'_>) {
         match &const_arg.kind {
+            // FIXME(mgca): proper printing for struct exprs
+            ConstArgKind::Struct(..) => self.word("/* STRUCT EXPR */"),
             ConstArgKind::Path(qpath) => self.print_qpath(qpath, true),
             ConstArgKind::Anon(anon) => self.print_anon_const(anon),
             ConstArgKind::Error(_, _) => self.word("/*ERROR*/"),
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
@@ -439,6 +439,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             hir::Node::Block(_)
             | hir::Node::Arm(_)
             | hir::Node::ExprField(_)
+            | hir::Node::ConstArgExprField(_)
             | hir::Node::AnonConst(_)
             | hir::Node::ConstBlock(_)
             | hir::Node::ConstArg(_)
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1449,6 +1449,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                     hir::Node::ConstArg(hir::ConstArg { kind, .. }) => match kind {
                         // Skip encoding defs for these as they should not have had a `DefId` created
                         hir::ConstArgKind::Error(..)
+                        | hir::ConstArgKind::Struct(..)
                         | hir::ConstArgKind::Path(..)
                         | hir::ConstArgKind::Infer(..) => true,
                         hir::ConstArgKind::Anon(..) => false,
diff --git a/compiler/rustc_middle/src/arena.rs b/compiler/rustc_middle/src/arena.rs
@@ -92,7 +92,7 @@ macro_rules! arena_types {
             [] name_set: rustc_data_structures::unord::UnordSet<rustc_span::Symbol>,
             [] autodiff_item: rustc_ast::expand::autodiff_attrs::AutoDiffItem,
             [] ordered_name_set: rustc_data_structures::fx::FxIndexSet<rustc_span::Symbol>,
-            [] valtree: rustc_middle::ty::ValTreeKind<'tcx>,
+            [] valtree: rustc_middle::ty::ValTreeKind<rustc_middle::ty::TyCtxt<'tcx>>,
             [] stable_order_of_exportable_impls:
                 rustc_data_structures::fx::FxIndexMap<rustc_hir::def_id::DefId, usize>,
 
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
@@ -740,6 +740,7 @@ impl<'tcx> TyCtxt<'tcx> {
             Node::ConstArg(_) => node_str("const"),
             Node::Expr(_) => node_str("expr"),
             Node::ExprField(_) => node_str("expr field"),
+            Node::ConstArgExprField(_) => node_str("const arg expr field"),
             Node::Stmt(_) => node_str("stmt"),
             Node::PathSegment(_) => node_str("path segment"),
             Node::Ty(_) => node_str("type"),
@@ -1008,6 +1009,7 @@ impl<'tcx> TyCtxt<'tcx> {
             Node::ConstArg(const_arg) => const_arg.span(),
             Node::Expr(expr) => expr.span,
             Node::ExprField(field) => field.span,
+            Node::ConstArgExprField(field) => field.span,
             Node::Stmt(stmt) => stmt.span,
             Node::PathSegment(seg) => {
                 let ident_span = seg.ident.span;
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
@@ -74,6 +74,12 @@ 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);
+        f(self);
+        self.invocation_parent.in_direct_const_arg = orig;
+    }
+
     fn collect_field(&mut self, field: &'a FieldDef, index: Option<usize>) {
         let index = |this: &Self| {
             index.unwrap_or_else(|| {
@@ -357,25 +363,73 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
     }
 
     fn visit_anon_const(&mut self, constant: &'a AnonConst) {
-        let parent = self.create_def(constant.id, None, DefKind::AnonConst, constant.value.span);
-        self.with_parent(parent, |this| visit::walk_anon_const(this, constant));
+        if let MgcaDisambiguation::Direct = constant.mgca_disambiguation
+            && self.resolver.tcx.features().min_generic_const_args()
+        {
+            self.with_direct_const_arg(true, |this| {
+                visit::walk_anon_const(this, constant);
+            });
+        } else {
+            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));
+            })
+        }
     }
 
     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);
+            }
+
+            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 {
             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) => {
-                for attr in &expr.attrs {
-                    visit::walk_attribute(self, attr);
+                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);
+                    }
+                }
+
+                if let Some(qself) = qself {
+                    self.visit_qself(qself);
                 }
-                let def =
-                    self.create_def(constant.id, None, DefKind::InlineConst, constant.value.span);
-                self.with_parent(def, |this| visit::walk_anon_const(this, constant));
+                self.visit_path(path);
+
+                match rest {
+                    StructRest::Base(expr) => self.visit_expr(expr),
+                    _ => (),
+                }
+
                 return;
             }
+            ExprKind::Field(ref init_expr, _) if self.invocation_parent.in_direct_const_arg => {
+                if let ExprKind::ConstBlock(ref constant) = init_expr.kind {
+                    handle_const_block(self, constant, DefKind::AnonConst);
+                    return;
+                } else {
+                    self.invocation_parent.parent_def
+                }
+            }
             _ => self.invocation_parent.parent_def,
         };
 
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -191,13 +191,15 @@ struct InvocationParent {
     parent_def: LocalDefId,
     impl_trait_context: ImplTraitContext,
     in_attr: bool,
+    in_direct_const_arg: bool,
 }
 
 impl InvocationParent {
     const ROOT: Self = Self {
         parent_def: CRATE_DEF_ID,
         impl_trait_context: ImplTraitContext::Existential,
         in_attr: false,
+        in_direct_const_arg: false,
     };
 }
 

Original file line number	Diff line number	Diff line change
`@@ -2263,6 +2263,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {`
`2263`	`2263`	`)`
`2264`	`2264`	`.unwrap_or_else(\|guar\| Const::new_error(tcx, guar))`
`2265`	`2265`	`}`
	`2266`	`+ hir::ConstArgKind::Struct(..) => {`
	`2267`	+ span_bug!(const_arg.span(), "lowering `{:?}` is not yet implemented", const_arg)
	`2268`	`+ }`
`2266`	`2269`	`hir::ConstArgKind::Anon(anon) => self.lower_anon_const(anon),`
`2267`	`2270`	`hir::ConstArgKind::Infer(span, ()) => self.ct_infer(None, span),`
`2268`	`2271`	`hir::ConstArgKind::Error(_, e) => ty::Const::new_error(tcx, e),`