enum discriminants have problems with `const_eval` and truncation

[jld]

static S: i16 = 0x12345678;
enum E { V = S }
fn main() { assert_eq!(S as u64, V as u64); }

Result:

task '<unnamed>' failed at 'assertion failed: `(left == right) && (right == left)` (left: `22136u64`, right: `305419896u64`)', testcase.rs:3`

Currently blocking #9613, because 32-bit std::int::min_value is 0xffffffff7fffffff (if you use all the bits of the const_eval result and not just the low 32) and so the discriminant is auto-sized to u64, meaning that 0x7fffffff does not match any of its variants.

I'm thinking that check_enum_variants needs to do whatever const_eval would do if the expression had an as u64 around it.

[jld]

One possibility: if we can read out the type inferred by check_const_with_ty and truncate based on it, that might be helpful if we want to do something about #8761.

[steveklabnik]

Visiting for triage, the above example no longer compiles:

hello.rs:4:14: 4:15 error: mismatched types: expected `int` but found `i16` (expected int but found i16)
hello.rs:4 enum E { V = S }
                        ^
error: aborting due to previous error

I'm not familiar enough with the details to be able to come up with a newer example.

[steveklabnik]

Triage: wow, I used to be a noob :)

static S: isize = 0x12345678;

enum E { V = S }

fn main() { assert_eq!(S as u64, E::V as u64); }

This now error swith:

hello.rs:3:14: 3:15 error: expected constant: non-constant path in constant expr [E0080]
hello.rs:3 enum E { V = S }
                        ^

So it seems like this is still an issue?

[steveklabnik]

marking as 'typesystem' because it would seem like a const should be usable here.

[jld]

I thought the enum stuff used const_eval, and that ought to work on consts/statics, so I'm not sure why that's failing — might be worth filing as its own bug?

[ftxqxd]

@steveklabnik That example uses a static, which isn’t a valid constant expression. The following is the closest I could get to the original example:

const S: i16 = 0x12345678;

enum E { V = S as isize }

fn main() { assert_eq!(S as u64, E::V as u64); }

And it still panics with the error in the original post (so this is still an issue).

[pnkfelix]

cc #23897

[eefriedman]

This is fixed in nightly.

[eefriedman]

Err, wait, nevermind, wrong bug; sorry about the noise.

[oli-obk]

note that this has a warning now:

<anon>:1:16: 1:26 warning: literal out of range for i16, #[warn(overflowing_literals)] on by default
<anon>:1 const S: i16 = 0x12345678;

[jld]

The warning definitely helps, but here's an interesting variation:

const C1: i32 = 0x12345678;
const C2: isize = C1 as i16 as isize;
enum E { V = C2 }
fn main() { assert_eq!(C2 as u64, E::V as u64); }

No warnings on stable or nightly, but still panics.

[pmarcelll]

I cannot reproduce the panic on nightly.