#[non_exhaustive] on variant should block cross-crate as casts

[scottmcm]

This currently compiles

// in crate 1
#[repr(u8)]
enum Foo {
    A,
    #[non_exhaustive]
    B,
}

// in crate 2
fn demo(f: Foo) -> u8 {
    f as u8
}

However, that as cast would be an erroneous "non-primitive cast" if the variant ever got any fields, as it's allowed to do by the #[non_exhaustive].

Thus we need to fix the compiler so that the cast is rejected outside the crate that owns Foo.

[Badel2]

Across different crates the code does not compile, the #[non_exhaustive] attribute seems to mark the enum variant as private:

error[E0603]: unit variant `B` is private
 --> src/main.rs:4:19
  |
4 |     let _x = Foo::B as u8;
  |                   ^ private unit variant
  |
note: the unit variant `B` is defined here
 --> /tmp/issue-91161-dep/src/lib.rs:5:5
  |
5 |     B,
  |     ^

[scottmcm]

Confirmed this is a problem: #91281

Nominating for lang to confirm that this should be fixed. Presumably via a forward-compat error at first.

[joshtriplett]

We discussed this in today's @rust-lang/lang meeting, and we agree that this is a bug.

We should fix this if possible. We'll need a crater run to confirm that this won't break things.

[scottmcm]

And a clarification from the meeting:

This should error in the downstream crate, saying something along the lines of "enums with #[non_exhaustive] variants cannot be as cast (outside the crate which defined them)".

I don't know how hard this is; hopefully it should be relatively straight-forward following all the other non_exhaustive logic.

[lambinoo]

@rustbot claim

[pazmank]

I tried the code in the first post and it still compiles with rustc 1.77.2 for thumbv7em-none-eabi target.

[dtolnay]

In all compiler versions since 1.65 (containing #92744) the code at the top of this issue produces the following diagnostic.

error[E0606]: casting `Foo` as `u8` is invalid
 --> crate2.rs:3:5
  |
3 |     f as u8
  |     ^^^^^^^
  |
  = note: cannot cast an enum with a non-exhaustive variant when it's defined in another crate