mGCA: Enforce WF element types for array valtrees

[biscuitrescue]

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

#![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

[rustbot]

changes to the core type system

cc @lcnr

[rustbot]

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

[asder8215]

you can also do #![expect(incomplete_features)] instead of the warning here. I personally would go for that route because I don't think the warning should be mentioned in the .stderr file.

[asder8215]

I would also recommend adding test files that check what happens when an array expression contains tuple argument. Kinda like this:

#![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))`
}

One other thing to test would probably be something you add into tuple_exp_arg_complex.rs, which you want to try out what happens when you take a tuple of an array containing const structs. Normally, it should say:

error: complex const arguments must be placed inside of a `const` block
...

^This is if you don't put the const block around the whole tuple. But I think now that you added WF element type check for array valtrees, this should emit an error if there's an invalid array inside tuple?

[biscuitrescue]

Thankyou for the feedback. I'll add the test-cases and update the PR shortly.

As for the question, I'll have to test this to see its behaviour. I believe it should, because the WF check walks through the valtree structure recursively so that when it checks the tuple, it should also check the array elements inside it.
I'll write the test case and verify what error message actually gets produced.

[biscuitrescue]

The WellFormed elems check does catch type errors recursively so invalid array elements inside tuples are also caught.
I have also added the requested tests.