E0603 is misleading on non-exhaustive enums

[jhpratt]

Given the following code: (no link, as not reproducible in a single file)

Library:

pub enum Foo {
    Alpha,
    #[non_exhaustive]
    Beta,
}

impl Foo {
    pub fn beta() -> Self {
        Self::Beta
    }
}

External user (in this case a test):

use example::Foo;

#[test]
fn demo() {
    assert!(matches!(
        Foo::beta(),
        Foo::Beta
    ));
}

The current output is:

error[E0603]: unit variant `Beta` is private
 --> tests/demo.rs:7:14
  |
7 |         Foo::Beta
  |              ^^^^ private unit variant
  |
note: the unit variant `Beta` is defined here
 --> /home/jhpratt/example/src/lib.rs:4:5
  |
4 |     Beta,
  |     ^^^^

Ideally the output should look like:

error[E0638]: `..` required with variant marked as non-exhaustive
 --> tests/demo.rs:7:9
  |
7 |         Foo::Beta
  |         ^^^^^^^^^
  |
help: add `..` at the end of the field list to ignore all other fields
  |
7 |         Foo::Beta { .. }

Right now, the cause of the error is misleading, as it seems to imply that an enum variant is private (which is impossible). The error message should be updated to match the error provided when there are some fields present, but not the .. as required. The exact wording might vary a bit, but I copied it verbatim here. Given the explanation of E0603, I believe that this is the wrong error code altogether.

@rustbot modify labels to +A-diagnostics +T-compiler +D-confusing +D-incorrect

[1c3t3a]

Ahh looking at the tests for the corresponding RFC, this seems like desired behavior for Unit like enum Variants:

rust/src/test/ui/rfc-2008-non-exhaustive/variant.rs

Lines 7 to 33 in 3a5d45f

	fn main() {
	let variant_struct = NonExhaustiveVariants::Struct { field: 640 };
	//~^ ERROR cannot create non-exhaustive variant
	let variant_tuple = NonExhaustiveVariants::Tuple(640);
	//~^ ERROR tuple variant `Tuple` is private [E0603]
	let variant_unit = NonExhaustiveVariants::Unit;
	//~^ ERROR unit variant `Unit` is private [E0603]
	match variant_struct {
	NonExhaustiveVariants::Unit => "",
	//~^ ERROR unit variant `Unit` is private [E0603]
	NonExhaustiveVariants::Tuple(fe_tpl) => "",
	//~^ ERROR tuple variant `Tuple` is private [E0603]
	NonExhaustiveVariants::Struct { field } => ""
	//~^ ERROR `..` required with variant marked as non-exhaustive
	};
	if let NonExhaustiveVariants::Tuple(fe_tpl) = variant_struct {
	//~^ ERROR tuple variant `Tuple` is private [E0603]
	}
	if let NonExhaustiveVariants::Struct { field } = variant_struct {
	//~^ ERROR `..` required with variant marked as non-exhaustive
	}
	}

But I agree that this behavior is kind of odd. A potential fix would involve not setting the unit variants to private but treating them as a struct-like variants. If this is the desired behavior I would be happy to implement it!

[WaffleLapkin]

Note that the same happens with structs too:

/// ```
/// let lib::Foo = lib::Foo::default();
/// ```
#[non_exhaustive]
#[derive(Default)]
pub struct Foo;

error[E0603]: unit struct `Foo` is private
   --> src/lib.rs:117:20
    |
4   | let lib::Foo = lib::Foo::default();
    |          ^^^ private unit struct
    |
note: the unit struct `Foo` is defined here
   --> path
    |
121 | pub struct Foo;
    | ^^^^^^^^^^^^^^^