Strange "Discriminant value outside specified type" with unsigned C-like enums

[Marwes]

This code fails with a compile error when using the smaller unsigned types (u8, u16, u32) as a representation for the enum. For signed types or u64 the same code compiles fine so it seems there is some issue with truncation for unsigned types.

As a workaround it is possible to use an explicit cast (!0 as u8).

#[repr(u8)]
enum Test {
    A = 0,
    B = !0
}

fn main() {
}

error.rs:6:5: 6:11 error: discriminant value outside specified type [E0082]
error.rs:6     B = !0
               ^~~~~~
error.rs:3:8: 3:11 note: discriminant type specified here
error.rs:3 #[repr(u8)]

[Diggsey]

Strange, I thought it would be because it's "0" as opposed to "0u8" and so the compiler was inferring a larger integer type, but even with "!0u8" it still complains, even though typeof(!0u8) == u8, and "!0u8 as u8" works fine.

fn type_of<T>(_: &T) -> &'static str { unsafe { (*std::intrinsics::get_tydesc::<T>()).name } }

fn main() {
    let x = !0u8;
    println!("{}", type_of(&x));
}

[Marwes]

I believe I figured out what is causing this behavior though I don't know how it should be fixed really.

The problem seems to come from the constant evaluator which only deals with 64-bit numbers. !0u8 is basically treated as !0u64 making a number that is to large when the bounds check is done. Might be that the constant evaluator need to take types into account.

[Marwes]

Related #22531

[pnkfelix]

cc #23897

[eefriedman]

This is fixed in nightly.

[steveklabnik]

Confirmed, thanks @eefriedman !