MIR type-checking ICE ("is not a subtype of") from lifetime parameter in scope of AnonConst.

[eddyb]

This example was found in #70452 (where it does not require #![feature(const_generics)], the only reason I have it here is to get around #43408) (playground):

#![feature(const_generics)]

const HASH_LEN: usize = 20;
struct Hash([u8; HASH_LEN]);

pub fn foo<'a>() -> &'a () {
    Hash([0; HASH_LEN]);
    &()
}

The ICE is:

error: internal compiler error:
    broken MIR in DefId(0:8 ~ playground[8116]::foo[0]) (Hash(move _2,)):
        [u8; _] is not a subtype of [u8; 20]: NoSolution

The ICE goes away when the lifetime parameter ('a) is removed, or when replaced with a type parameter, so my guess is that the MIR type-checker triggers an attempt at normalization (otherwise it would also ICE with a type parameter) but has lifetime inference variables in the Substs of the ConstKind::Unevaluated, and that prevents the normalization.

It really shouldn't, I thought we both erased lifetimes and fell back on fully polymorphic evaluation (which should also succeed here), if there are any inference variables.

[eddyb]

My guess was that this check isn't looking at the param_env (can ParamEnvs coming from MIR typeck contain lifetime inference variables?):

rust/src/librustc_middle/ty/sty.rs

Lines 2422 to 2430 in 49dc2f9

	// HACK(eddyb) when substs contain e.g. inference variables,
	// attempt using identity substs instead, that will succeed
	// when the expression doesn't depend on any parameters.
	// FIXME(eddyb, skinny121) pass `InferCtxt` into here when it's available, so that
	// we can call `infcx.const_eval_resolve` which handles inference variables.
	if substs.has_local_value() {
	let identity_substs = InternalSubsts::identity_for_item(tcx, did);
	// The `ParamEnv` needs to match the `identity_substs`.
	let identity_param_env = tcx.param_env(did);

which could cause this to fail, since the identity fallback wasn't used (which would've worked):

rust/src/librustc_middle/ty/sty.rs

Lines 2406 to 2409 in 49dc2f9

	// Avoid querying `tcx.const_eval(...)` with any e.g. inference vars.
	if param_env_and_substs.has_local_value() {
	return None;
	}

I added a param_env check and erased lifetimes at the same time, but it didn't fix the test.

So maybe the MIR type-checker isn't normalizing, after all?

[eddyb]

Using -Z verbose we get this:

[u8; Const { ty: usize, val: Unevaluated(
    DefId(0:10 ~ issue_70773_mir_typeck_lt_norm[317d]::foo[0]::{{constant}}[0]),
    ['_#12r],
    None,
) }]
    is not a subtype of
[u8; Const { ty: usize, val: Value(Scalar(0x0000000000000014)) }]

So it's indeed a lifetime inference variable in the substs of an Unevaluated constant.

But because of canonical queries, it seems to turn into ReLateBound(DebruijnIndex(0), BrAnon(0)), which is not erased (since it's late-bound), and makes it all the way to const_eval_raw. Which should be working, I don't understand what goes wrong.

Wait, how does that not get turned into an inference variable inside the canonical query to get erased by ty::Const::eval still?! Something is off here.

[eddyb]

I'm going in circles, and the fact that I used HASH_LEN in both places isn't helping.

It's the type of the [0; HASH_LEN] passed to the Rvalue::Aggregate, that's never attempted to be normalized, not the field of Hash. So it's just another "missing normalization" bug.

[eddyb]

Looks like calls are also affected (playground):

#![feature(const_generics)]

const HASH_LEN: usize = 20;
fn init_hash(_: &mut [u8; HASH_LEN]) {}

pub fn foo<'a>() -> &'a () {
    init_hash(&mut [0; HASH_LEN]);
    &()
}

This was found in rand (see #70452 (comment)), although I wish it was before a 3-day Crater run.