ICE matching on a non-[u8] const array

[Nadrieril]

This produces an ICE (playground link):

fn main() {
    const CONST: &[(); 1] = &[()];
    match &[()] {
        &[()] => {}
        CONST => {}
    }
}

It points to this assert firing:

rust/src/librustc_mir/hair/pattern/_match.rs

Lines 1739 to 1745 in d801458

	let data: &[u8] = match (const_val_val, &const_val.ty.kind) {
	(ConstValue::ByRef { offset, alloc, .. }, ty::Array(t, n)) => {
	assert_eq!(*t, tcx.types.u8);
	let n = n.eval_usize(tcx, param_env);
	let ptr = Pointer::new(AllocId(0), offset);
	alloc.get_bytes(&tcx, ptr, Size::from_bytes(n)).unwrap()
	}

This assert assumes that if we match on a &[T; n] with a const, then T must be u8. I'm not sure where this assumption comes from (I'd guess byte-array patterns), but it's clearly wrong. Note that this also fails with any other non-u8 type here instead of ().
Note that this does not fail when the arrays are not behind references, or if we use slices instead of arrays.

EDIT: removed unnecessary slice_patterns feature gate

[jonas-schievink]

The feature gate isn't needed to trigger the ICE

[Nadrieril]

Oh, well spotted. And it appears that fails on stable too then

[Mark-Simulacrum]

cc @pnkfelix as it's possible this is related to your structural match work I guess?

[hellow554]

Funny enough: this doesn't ICE

const CONST: [(); 1] = [()];
match &[()] {
    &[()] => {}
    &CONST => {}
}

but instead shows the correct "unreachable" warning

[Centril]

Reduced:

fn main() {
    const CONST: &[(); 0] = &[];
    match &[] {
        &[] => {}
        CONST => {}
    }
}

[pnkfelix]

This assert assumes that if we match on a &[T; n] with a const, then T must be u8

What the heck?!?