Lower hir::ConstArgKind::Struct to a ValTree

Author: BoxyUwU

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2263,15 +2263,117 @@ 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::Struct(qpath, inits) => {
+                self.lower_struct_expr_const_arg(hir_id, qpath, inits, const_arg.span())
             }
             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),
         }
     }
 
+    fn lower_struct_expr_const_arg(
+        &self,
+        hir_id: HirId,
+        qpath: hir::QPath<'tcx>,
+        inits: &'tcx [&'tcx hir::ConstArgExprField<'tcx>],
+        span: Span,
+    ) -> Const<'tcx> {
+        let tcx = self.tcx();
+
+        let non_adt_or_variant_res = || {
+            let e = tcx.dcx().span_err(span, "struct expression with invalid base path");
+            ty::Const::new_error(tcx, e)
+        };
+
+        let (ty, variant_did) = match qpath {
+            hir::QPath::Resolved(maybe_qself, path) => {
+                debug!(?maybe_qself, ?path);
+                let opt_self_ty = maybe_qself.as_ref().map(|qself| self.lower_ty(qself));
+                let ty =
+                    self.lower_resolved_ty_path(opt_self_ty, path, hir_id, PermitVariants::Yes);
+                let variant_did = match path.res {
+                    Res::Def(DefKind::Variant | DefKind::Struct, did) => did,
+                    _ => return non_adt_or_variant_res(),
+                };
+
+                (ty, variant_did)
+            }
+            hir::QPath::TypeRelative(hir_self_ty, segment) => {
+                debug!(?hir_self_ty, ?segment);
+                let self_ty = self.lower_ty(hir_self_ty);
+                let opt_res = self.lower_type_relative_ty_path(
+                    self_ty,
+                    hir_self_ty,
+                    segment,
+                    hir_id,
+                    span,
+                    PermitVariants::Yes,
+                );
+
+                let (ty, _, res_def_id) = match opt_res {
+                    Ok(r @ (_, DefKind::Variant | DefKind::Struct, _)) => r,
+                    Ok(_) => return non_adt_or_variant_res(),
+                    Err(e) => return ty::Const::new_error(tcx, e),
+                };
+
+                (ty, res_def_id)
+            }
+        };
+
+        let ty::Adt(adt_def, adt_args) = ty.kind() else { unreachable!() };
+
+        let variant_def = adt_def.variant_with_id(variant_did);
+        let variant_idx = adt_def.variant_index_with_id(variant_did).as_u32();
+
+        let fields = variant_def
+            .fields
+            .iter()
+            .map(|field_def| {
+                // FIXME(mgca): we aren't really handling privacy or stability at all but we should
+                let mut init_expr =
+                    inits.iter().filter(|init_expr| init_expr.field.name == field_def.name);
+
+                match init_expr.next() {
+                    Some(expr) => {
+                        if let Some(expr) = init_expr.next() {
+                            let e = tcx.dcx().span_err(
+                                expr.span,
+                                format!(
+                                    "struct expression with multiple initialisers for `{}`",
+                                    field_def.name,
+                                ),
+                            );
+                            return ty::Const::new_error(tcx, e);
+                        }
+
+                        self.lower_const_arg(expr.expr, FeedConstTy::Param(field_def.did, adt_args))
+                    }
+                    None => {
+                        let e = tcx.dcx().span_err(
+                            span,
+                            format!(
+                                "struct expression with missing field initialiser for `{}`",
+                                field_def.name
+                            ),
+                        );
+                        ty::Const::new_error(tcx, e)
+                    }
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let opt_discr_const = if adt_def.is_enum() {
+            let valtree = ty::ValTree::from_scalar_int(tcx, variant_idx.into());
+            Some(ty::Const::new_value(tcx, valtree, tcx.types.u32))
+        } else {
+            None
+        };
+
+        let valtree = ty::ValTree::from_branches(tcx, opt_discr_const.into_iter().chain(fields));
+        ty::Const::new_value(tcx, valtree, ty)
+    }
+
     /// Lower a [resolved][hir::QPath::Resolved] path to a (type-level) constant.
     fn lower_resolved_const_path(
         &self,

compiler/rustc_resolve/src/def_collector.rs

@@ -374,7 +374,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             });
             return;
         }
-        
+
         self.with_direct_const_arg(false, |this| {
             let parent =
                 this.create_def(constant.id, None, DefKind::AnonConst, constant.value.span);

tests/ui/const-generics/mgca/adt_expr_arg_simple.rs

@@ -0,0 +1,39 @@
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+
+#[derive(Eq, PartialEq, std::marker::ConstParamTy)]
+enum Option<T> {
+    Some(T),
+    None,
+}
+use Option::Some;
+
+fn foo<const N: Option<u32>>() {}
+
+trait Trait {
+    #[type_const]
+    const ASSOC: usize;
+}
+
+fn bar<T: Trait, const N: u32>() {
+    // the initializer of `_0` is a `N` which is a legal const argument
+    // so this is ok.
+    foo::<{ Some::<u32> { 0: N } }>();
+
+    // this is allowed as mgca supports uses of assoc consts in the
+    // type system. ie `<T as Trait>::ASSOC` is a legal const argument
+    foo::<{ Some::<u32> { 0: <T as Trait>::ASSOC } }>();
+
+    // this on the other hand is not allowed as `N + 1` is not a legal
+    // const argument
+    foo::<{ Some::<u32> { 0: N + 1 } }>();
+    //~^ ERROR: complex const arguments must be placed inside of a `const` block
+
+    // this also is not allowed as generic parameters cannot be used
+    // in anon const const args
+    foo::<{ Some::<u32> { 0: const { N + 1 } } }>();
+    //~^ ERROR: generic parameters may not be used in const operations
+    //~| ERROR: generic parameters may not be used in const operations
+}
+
+fn main() {}

tests/ui/const-generics/mgca/adt_expr_arg_simple.stderr

@@ -0,0 +1,22 @@
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/adt_expr_arg_simple.rs:29:30
+   |
+LL |     foo::<{ Some::<u32> { 0: N + 1 } }>();
+   |                              ^^^^^
+
+error: generic parameters may not be used in const operations
+  --> $DIR/adt_expr_arg_simple.rs:34:38
+   |
+LL |     foo::<{ Some::<u32> { 0: const { N + 1 } } }>();
+   |                                      ^
+
+error: generic parameters may not be used in const operations
+  --> $DIR/adt_expr_arg_simple.rs:34:38
+   |
+LL |     foo::<{ Some::<u32> { 0: const { N + 1 } } }>();
+   |                                      ^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 3 previous errors
+

tests/ui/const-generics/mgca/adt_expr_erroneuous_inits.rs

@@ -0,0 +1,23 @@
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+#![crate_type = "lib"]
+
+#[derive(Eq, PartialEq, std::marker::ConstParamTy)]
+struct Foo<T> { field: T }
+
+fn NonStruct() {}
+
+fn accepts<const N: Foo<u8>>() {}
+
+fn bar() {
+    accepts::<{ Foo::<u8> { }}>();
+    //~^ ERROR: struct expression with missing field initialiser for `field`
+    accepts::<{ Foo::<u8> { field: const { 1 }, field: const { 2} }}>();
+    //~^ ERROR: struct expression with multiple initialisers for `field`
+    accepts::<{ Fooo::<u8> { field: const { 1 } }}>();
+    //~^ ERROR: cannot find struct, variant or union type `Fooo` in this scope
+    //~| ERROR: struct expression with invalid base path
+    accepts::<{ NonStruct { }}>();
+    //~^ ERROR: expected struct, variant or union type, found function `NonStruct`
+    //~| ERROR: struct expression with invalid base path
+}

tests/ui/const-generics/mgca/adt_expr_erroneuous_inits.stderr

@@ -0,0 +1,49 @@
+error[E0422]: cannot find struct, variant or union type `Fooo` in this scope
+  --> $DIR/adt_expr_erroneuous_inits.rs:17:17
+   |
+LL | struct Foo<T> { field: T }
+   | ------------- similarly named struct `Foo` defined here
+...
+LL |     accepts::<{ Fooo::<u8> { field: const { 1 } }}>();
+   |                 ^^^^
+   |
+help: a struct with a similar name exists
+   |
+LL -     accepts::<{ Fooo::<u8> { field: const { 1 } }}>();
+LL +     accepts::<{ Foo::<u8> { field: const { 1 } }}>();
+   |
+
+error[E0574]: expected struct, variant or union type, found function `NonStruct`
+  --> $DIR/adt_expr_erroneuous_inits.rs:20:17
+   |
+LL |     accepts::<{ NonStruct { }}>();
+   |                 ^^^^^^^^^ not a struct, variant or union type
+
+error: struct expression with missing field initialiser for `field`
+  --> $DIR/adt_expr_erroneuous_inits.rs:13:17
+   |
+LL |     accepts::<{ Foo::<u8> { }}>();
+   |                 ^^^^^^^^^
+
+error: struct expression with multiple initialisers for `field`
+  --> $DIR/adt_expr_erroneuous_inits.rs:15:49
+   |
+LL |     accepts::<{ Foo::<u8> { field: const { 1 }, field: const { 2} }}>();
+   |                                                 ^^^^^^^^^^^^^^^^^
+
+error: struct expression with invalid base path
+  --> $DIR/adt_expr_erroneuous_inits.rs:17:17
+   |
+LL |     accepts::<{ Fooo::<u8> { field: const { 1 } }}>();
+   |                 ^^^^^^^^^^
+
+error: struct expression with invalid base path
+  --> $DIR/adt_expr_erroneuous_inits.rs:20:17
+   |
+LL |     accepts::<{ NonStruct { }}>();
+   |                 ^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0422, E0574.
+For more information about an error, try `rustc --explain E0422`.

tests/ui/const-generics/mgca/adt_expr_fields_type_check.rs

@@ -0,0 +1,17 @@
+//@ check-pass
+// This should error
+
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+
+#[derive(Eq, PartialEq, std::marker::ConstParamTy)]
+struct Foo<T> { field: T }
+
+fn accepts<const N: Foo<u8>>() {}
+
+fn bar<const N: bool>() {
+    // `N` is not of type `u8` but we don't actually check this anywhere yet
+    accepts::<{ Foo::<u8> { field: N }}>();
+}
+
+fn main() {}

tests/ui/const-generics/mgca/adt_expr_infers_from_value.rs

@@ -0,0 +1,45 @@
+//@ check-pass
+
+#![feature(
+    generic_const_items,
+    min_generic_const_args,
+    adt_const_params,
+    generic_const_parameter_types,
+    unsized_const_params,
+)]
+#![expect(incomplete_features)]
+
+use std::marker::{PhantomData, ConstParamTy, ConstParamTy_};
+
+#[derive(PartialEq, Eq, ConstParamTy)]
+struct Foo<T> {
+    field: T,
+}
+
+#[type_const]
+const WRAP<T: ConstParamTy_, const N: T>: Foo<T> = { Foo::<T> {
+    field: N,
+} };
+
+fn main() {
+    // What we're trying to accomplish here is winding up with an equality relation
+    // between two `ty::Const` that looks something like:
+    //
+    // ```
+    // Foo<u8> { field: const { 1 + 2 } }
+    // eq
+    // Foo<u8> { field: ?x }
+    // ```
+    //
+    // Note that the `field: _` here means a const argument `_` not a wildcard pattern.
+    // This tests that we are able to infer `?x=3` even though the first `ty::Const`
+    // may be a fully evaluated constant, and the latter is not fully evaluatable due
+    // to inference variables.
+    let _: PC<_, { WRAP::<u8, const { 1 + 1 }> }>
+        =  PC::<_, { Foo::<u8> { field: _ }}>;
+}
+
+// "PhantomConst" helper equivalent to "PhantomData" used for testing equalities
+// of arbitrarily typed const arguments.
+struct PC<T: ConstParamTy_, const N: T> { _0: PhantomData<T> }
+const PC<T: ConstParamTy_, const N: T>: PC<T, N> = PC { _0: PhantomData::<T> };

tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs

@@ -1,9 +1,11 @@
-//@ check-pass
-
 // We allow for literals to implicitly be anon consts still regardless
 // of whether a const block is placed around them or not
+//
+// However, we don't allow so for const arguments in field init positions.
+// This is just harder to implement so we did not do so.
+
 
-#![feature(min_generic_const_args, associated_const_equality)]
+#![feature(min_generic_const_args, adt_const_params, associated_const_equality)]
 #![expect(incomplete_features)]
 
 trait Trait {
@@ -19,4 +21,15 @@ type ArrLen = [(); 1];
 struct Foo<const N: isize>;
 type NormalArg = (Foo<1>, Foo<-1>);
 
+#[derive(Eq, PartialEq, std::marker::ConstParamTy)]
+struct ADT { field: u8 }
+
+fn struct_expr() {
+    fn takes_n<const N: ADT>() {}
+
+    takes_n::<{ ADT { field: 1 } }>();
+    //~^ ERROR: complex const arguments must be placed inside of a `const` block
+    takes_n::<{ ADT { field: const { 1 } } }>();
+}
+
 fn main() {}

tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.stderr

@@ -0,0 +1,8 @@
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/explicit_anon_consts_literals_hack.rs:30:30
+   |
+LL |     takes_n::<{ ADT { field: 1 } }>();
+   |                              ^
+
+error: aborting due to 1 previous error
+