Unrolled build for #152492

Rollup merge of #152492 - biscuitrescue:fix-array-valtree-wf, r=BoxyUwU

mGCA: Enforce WF element types for array valtrees

Fixes #152125

Extends WellFormedness checking for const generics to validate that array element types in ValTrees match the declared element type.

### Problem
Before commit, this would have incorrectly compiled

``` rust
#![feature(adt_const_params, min_generic_const_args)]

use std::marker::ConstParamTy;

#[derive(Eq, PartialEq, ConstParamTy)]
struct Foo;

struct Bar;

fn foo<const N: [Foo; 1]>() {}

fn main() {
    foo::<{ [Bar] }>();
}
```

### Solution
Added a `ty::Array` arm to checking WellFormedness (similar to the existing `ty::Tuple` arm from #150713) which creates `ConstArgHasType` obligations for each array element, ensuring they match the array's declared element type.

I attempted to combine the `Tuple` and `Array` arms into a single arm, but this proved difficult due to pattern matching limitations, and the separate arm is more readable anyway.

### Tests

Added UI test which verifies that the type mismatch is now properly caught, and also returns an appropriate test message

r? @BoxyUwU

Author: rust-timer

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -1122,6 +1122,23 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                                 },
                             ));
                         }
+                        ty::Array(elem_ty, _len) => {
+                            let elem_vals = val.to_branch();
+                            let cause = self.cause(ObligationCauseCode::WellFormed(None));
+
+                            self.out.extend(elem_vals.iter().map(|&elem_val| {
+                                let predicate = ty::PredicateKind::Clause(
+                                    ty::ClauseKind::ConstArgHasType(elem_val, *elem_ty),
+                                );
+                                traits::Obligation::with_depth(
+                                    tcx,
+                                    cause.clone(),
+                                    self.recursion_depth,
+                                    self.param_env,
+                                    predicate,
+                                )
+                            }));
+                        }
                         _ => {}
                     }
                 }

tests/ui/const-generics/mgca/array-const-arg-type-mismatch.rs

@@ -0,0 +1,15 @@
+#![expect(incomplete_features)]
+#![feature(adt_const_params, min_generic_const_args)]
+use std::marker::ConstParamTy;
+
+#[derive(Eq, PartialEq, ConstParamTy)]
+struct Foo;
+
+struct Bar;
+
+fn test<const N: [Foo; 1]>() {}
+
+fn main() {
+    test::<{ [Bar] }>();
+    //~^ ERROR constant `Bar` is not of type `Foo`
+}

tests/ui/const-generics/mgca/array-const-arg-type-mismatch.stderr

@@ -0,0 +1,8 @@
+error: the constant `Bar` is not of type `Foo`
+  --> $DIR/array-const-arg-type-mismatch.rs:13:14
+   |
+LL |     test::<{ [Bar] }>();
+   |              ^^^^^ expected `Foo`, found `Bar`
+
+error: aborting due to 1 previous error
+

tests/ui/const-generics/mgca/array-with-wrong-tuple-type.rs

@@ -0,0 +1,18 @@
+#![feature(adt_const_params, min_generic_const_args, unsized_const_params)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy;
+
+#[derive(Eq, PartialEq, ConstParamTy)]
+struct A;
+
+fn takes_tuple<const N: [(u32, u32); 1]>() {}
+fn takes_nested_tuple<const N: [(u32, (u32, u32)); 1]>() {}
+
+
+fn main() {
+    takes_tuple::<{ [A] }>();
+    //~^ ERROR the constant `A` is not of type `(u32, u32)`
+    takes_nested_tuple::<{ [A] }>();
+    //~^ ERROR the constant `A` is not of type `(u32, (u32, u32))`
+}

tests/ui/const-generics/mgca/array-with-wrong-tuple-type.stderr

@@ -0,0 +1,14 @@
+error: the constant `A` is not of type `(u32, u32)`
+  --> $DIR/array-with-wrong-tuple-type.rs:14:21
+   |
+LL |     takes_tuple::<{ [A] }>();
+   |                     ^^^ expected `(u32, u32)`, found `A`
+
+error: the constant `A` is not of type `(u32, (u32, u32))`
+  --> $DIR/array-with-wrong-tuple-type.rs:16:28
+   |
+LL |     takes_nested_tuple::<{ [A] }>();
+   |                            ^^^ expected `(u32, (u32, u32))`, found `A`
+
+error: aborting due to 2 previous errors
+

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

@@ -0,0 +1,16 @@
+#![feature(min_generic_const_args, adt_const_params, unsized_const_params)]
+#![expect(incomplete_features)]
+
+trait Trait {
+    type const ASSOC: usize;
+}
+
+fn takes_array<const A: [u32; 2]>() {}
+fn takes_tuple_with_array<const A: ([u32; 2], u32)>() {}
+
+fn generic_caller<T: Trait, const N: u32, const N2: u32>() {
+    takes_array::<{ [N, N + 1] }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+    takes_tuple_with_array::<{ ([N, N + 1], N) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+}
+
+fn main() {}

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

@@ -0,0 +1,14 @@
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/array_expr_arg_complex.rs:12:25
+   |
+LL |     takes_array::<{ [N, N + 1] }>();
+   |                         ^^^^^
+
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/array_expr_arg_complex.rs:13:37
+   |
+LL |     takes_tuple_with_array::<{ ([N, N + 1], N) }>();
+   |                                     ^^^^^
+
+error: aborting due to 2 previous errors
+

tests/ui/const-generics/mgca/invalid-array-in-tuple.rs

@@ -0,0 +1,16 @@
+#![feature(adt_const_params, min_generic_const_args, unsized_const_params)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy;
+
+#[derive(Eq, PartialEq, ConstParamTy)]
+struct Foo;
+
+struct Bar;
+
+fn takes_tuple_with_array<const A: ([Foo; 1], u32)>() {}
+
+fn main() {
+    takes_tuple_with_array::<{ ([Bar], 1) }>();
+    //~^ ERROR the constant `Bar` is not of type `Foo`
+}

tests/ui/const-generics/mgca/invalid-array-in-tuple.stderr

@@ -0,0 +1,8 @@
+error: the constant `Bar` is not of type `Foo`
+  --> $DIR/invalid-array-in-tuple.rs:14:32
+   |
+LL |     takes_tuple_with_array::<{ ([Bar], 1) }>();
+   |                                ^^^^^^^^^^ expected `Foo`, found `Bar`
+
+error: aborting due to 1 previous error
+

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

@@ -2,7 +2,6 @@
 #![expect(incomplete_features)]
 
 trait Trait {
-
     type const ASSOC: usize;
 }