Prefer "0..MAX not covered" to "_ not covered"

Nadrieril · Nadrieril · commit 9dca6be7b83f · 2024-02-07T23:25:11.000+01:00
diff --git a/compiler/rustc_pattern_analysis/src/usefulness.rs b/compiler/rustc_pattern_analysis/src/usefulness.rs
@@ -1520,11 +1520,9 @@ fn compute_exhaustiveness_and_usefulness<'a, 'p, Cx: TypeCx>(
         split_ctors.push(Constructor::Missing);
     }
 
-    // Decide what constructors to report.
-    let is_integers = matches!(ctors_for_ty, ConstructorSet::Integers { .. });
-    let always_report_all = place.is_scrutinee && !is_integers;
-    // Whether we should report "Enum::A and Enum::C are missing" or "_ is missing".
-    let report_individual_missing_ctors = always_report_all || !all_missing;
+    // Whether we should report "Enum::A and Enum::C are missing" or "_ is missing". At the top
+    // level we prefer to list all constructors.
+    let report_individual_missing_ctors = place.is_scrutinee || !all_missing;
     // Which constructors are considered missing. We ensure that `!missing_ctors.is_empty() =>
     // split_ctors.contains(Missing)`. The converse usually holds except when
     // `!place_validity.is_known_valid()`.
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
@@ -43,18 +43,18 @@ help: you might want to use `if let` to ignore the variant that isn't matched
 LL |     if let None = x { todo!() };
    |     ++              +++++++++++
 
-error[E0004]: non-exhaustive patterns: `_` not covered
+error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
   --> $DIR/empty-match-check-notes.rs:45:11
    |
 LL |     match 0u8 {
-   |           ^^^ pattern `_` not covered
+   |           ^^^ pattern `0_u8..=u8::MAX` not covered
    |
    = note: the matched value is of type `u8`
    = note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         _ if false => {},
-LL +         _ => todo!()
+LL +         0_u8..=u8::MAX => todo!()
    |
 
 error: aborting due to 6 previous errors
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr b/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
@@ -42,18 +42,18 @@ help: you might want to use `if let` to ignore the variant that isn't matched
 LL |     if let None = x { todo!() };
    |     ++              +++++++++++
 
-error[E0004]: non-exhaustive patterns: `_` not covered
+error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
   --> $DIR/empty-match-check-notes.rs:45:11
    |
 LL |     match 0u8 {
-   |           ^^^ pattern `_` not covered
+   |           ^^^ pattern `0_u8..=u8::MAX` not covered
    |
    = note: the matched value is of type `u8`
    = note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         _ if false => {},
-LL +         _ => todo!()
+LL +         0_u8..=u8::MAX => todo!()
    |
 
 error: aborting due to 6 previous errors
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.rs b/tests/ui/pattern/usefulness/empty-match-check-notes.rs
@@ -43,10 +43,10 @@ fn empty_foreign_enum_private(x: Option<empty::SecretlyUninhabitedForeignStruct>
 
 fn main() {
     match 0u8 {
-        //~^ ERROR `_` not covered
+        //~^ ERROR not covered
         //~| NOTE the matched value is of type
         //~| NOTE match arms with guards don't count towards exhaustivity
-        //~| NOTE pattern `_` not covered
+        //~| NOTE not covered
         _ if false => {}
     }
 }
diff --git a/tests/ui/pattern/usefulness/empty-match.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-match.exhaustive_patterns.stderr
@@ -148,46 +148,46 @@ LL |         V5,
    = note: the matched value is of type `NonEmptyEnum5`
    = help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or multiple match arms
 
-error[E0004]: non-exhaustive patterns: `_` not covered
+error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
   --> $DIR/empty-match.rs:58:24
    |
 LL |     match_guarded_arm!(0u8);
-   |                        ^^^ pattern `_` not covered
+   |                        ^^^ pattern `0_u8..=u8::MAX` not covered
    |
    = note: the matched value is of type `u8`
    = note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~                 _ if false => {},
-LL +                 _ => todo!()
+LL +                 0_u8..=u8::MAX => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `_` not covered
+error[E0004]: non-exhaustive patterns: `i8::MIN..=i8::MAX` not covered
   --> $DIR/empty-match.rs:59:24
    |
 LL |     match_guarded_arm!(0i8);
-   |                        ^^^ pattern `_` not covered
+   |                        ^^^ pattern `i8::MIN..=i8::MAX` not covered
    |
    = note: the matched value is of type `i8`
    = note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~                 _ if false => {},
-LL +                 _ => todo!()
+LL +                 i8::MIN..=i8::MAX => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `_` not covered
+error[E0004]: non-exhaustive patterns: `0_usize..` not covered
   --> $DIR/empty-match.rs:60:24
    |
 LL |     match_guarded_arm!(0usize);
-   |                        ^^^^^^ pattern `_` not covered
+   |                        ^^^^^^ pattern `0_usize..` not covered
    |
    = note: the matched value is of type `usize`
    = note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~                 _ if false => {},
-LL +                 _ => todo!()
+LL +                 0_usize.. => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `_` not covered
diff --git a/tests/ui/pattern/usefulness/empty-match.normal.stderr b/tests/ui/pattern/usefulness/empty-match.normal.stderr
@@ -148,46 +148,46 @@ LL |         V5,
    = note: the matched value is of type `NonEmptyEnum5`
    = help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or multiple match arms
 
-error[E0004]: non-exhaustive patterns: `_` not covered
+error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
   --> $DIR/empty-match.rs:58:24
    |
 LL |     match_guarded_arm!(0u8);
-   |                        ^^^ pattern `_` not covered
+   |                        ^^^ pattern `0_u8..=u8::MAX` not covered
    |
    = note: the matched value is of type `u8`
    = note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~                 _ if false => {},
-LL +                 _ => todo!()
+LL +                 0_u8..=u8::MAX => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `_` not covered
+error[E0004]: non-exhaustive patterns: `i8::MIN..=i8::MAX` not covered
   --> $DIR/empty-match.rs:59:24
    |
 LL |     match_guarded_arm!(0i8);
-   |                        ^^^ pattern `_` not covered
+   |                        ^^^ pattern `i8::MIN..=i8::MAX` not covered
    |
    = note: the matched value is of type `i8`
    = note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~                 _ if false => {},
-LL +                 _ => todo!()
+LL +                 i8::MIN..=i8::MAX => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `_` not covered
+error[E0004]: non-exhaustive patterns: `0_usize..` not covered
   --> $DIR/empty-match.rs:60:24
    |
 LL |     match_guarded_arm!(0usize);
-   |                        ^^^^^^ pattern `_` not covered
+   |                        ^^^^^^ pattern `0_usize..` not covered
    |
    = note: the matched value is of type `usize`
    = note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~                 _ if false => {},
-LL +                 _ => todo!()
+LL +                 0_usize.. => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `_` not covered
diff --git a/tests/ui/pattern/usefulness/empty-match.rs b/tests/ui/pattern/usefulness/empty-match.rs
@@ -55,9 +55,9 @@ fn nonempty() {
     match_no_arms!(NonEmptyEnum2::Foo(true)); //~ ERROR `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
     match_no_arms!(NonEmptyEnum5::V1); //~ ERROR `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
 
-    match_guarded_arm!(0u8); //~ ERROR `_` not covered
-    match_guarded_arm!(0i8); //~ ERROR `_` not covered
-    match_guarded_arm!(0usize); //~ ERROR `_` not covered
+    match_guarded_arm!(0u8); //~ ERROR `0_u8..=u8::MAX` not covered
+    match_guarded_arm!(0i8); //~ ERROR `i8::MIN..=i8::MAX` not covered
+    match_guarded_arm!(0usize); //~ ERROR `0_usize..` not covered
     match_guarded_arm!(0isize); //~ ERROR `_` not covered
     match_guarded_arm!(NonEmptyStruct1); //~ ERROR `NonEmptyStruct1` not covered
     match_guarded_arm!(NonEmptyStruct2(true)); //~ ERROR `NonEmptyStruct2(_)` not covered

Original file line number	Diff line number	Diff line change
@@ -43,18 +43,18 @@ help: you might want to use `if let` to ignore the variant that isn't matched
`43`	`43`	`LL \| if let None = x { todo!() };`
`44`	`44`	`\| ++ +++++++++++`
`45`	`45`
`46`		-error[E0004]: non-exhaustive patterns: `_` not covered
	`46`	+error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
`47`	`47`	`--> $DIR/empty-match-check-notes.rs:45:11`
`48`	`48`	`\|`
`49`	`49`	`LL \| match 0u8 {`
`50`		- \| ^^^ pattern `_` not covered
	`50`	+ \| ^^^ pattern `0_u8..=u8::MAX` not covered
`51`	`51`	`\|`
`52`	`52`	= note: the matched value is of type `u8`
`53`	`53`	`= note: match arms with guards don't count towards exhaustivity`
`54`	`54`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`55`	`55`	`\|`
`56`	`56`	`LL ~ _ if false => {},`
`57`		`-LL + _ => todo!()`
	`57`	`+LL + 0_u8..=u8::MAX => todo!()`
`58`	`58`	`\|`
`59`	`59`
`60`	`60`	`error: aborting due to 6 previous errors`
Original file line number	Diff line number	Diff line change
@@ -42,18 +42,18 @@ help: you might want to use `if let` to ignore the variant that isn't matched
`42`	`42`	`LL \| if let None = x { todo!() };`
`43`	`43`	`\| ++ +++++++++++`
`44`	`44`
`45`		-error[E0004]: non-exhaustive patterns: `_` not covered
	`45`	+error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
`46`	`46`	`--> $DIR/empty-match-check-notes.rs:45:11`
`47`	`47`	`\|`
`48`	`48`	`LL \| match 0u8 {`
`49`		- \| ^^^ pattern `_` not covered
	`49`	+ \| ^^^ pattern `0_u8..=u8::MAX` not covered
`50`	`50`	`\|`
`51`	`51`	= note: the matched value is of type `u8`
`52`	`52`	`= note: match arms with guards don't count towards exhaustivity`
`53`	`53`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`54`	`54`	`\|`
`55`	`55`	`LL ~ _ if false => {},`
`56`		`-LL + _ => todo!()`
	`56`	`+LL + 0_u8..=u8::MAX => todo!()`
`57`	`57`	`\|`
`58`	`58`
`59`	`59`	`error: aborting due to 6 previous errors`
Original file line number	Diff line number	Diff line change
`@@ -43,10 +43,10 @@ fn empty_foreign_enum_private(x: Option<empty::SecretlyUninhabitedForeignStruct>`
`43`	`43`
`44`	`44`	`fn main() {`
`45`	`45`	`match 0u8 {`
`46`		- //~^ ERROR `_` not covered
	`46`	`+ //~^ ERROR not covered`
`47`	`47`	`//~\| NOTE the matched value is of type`
`48`	`48`	`//~\| NOTE match arms with guards don't count towards exhaustivity`
`49`		- //~\| NOTE pattern `_` not covered
	`49`	`+ //~\| NOTE not covered`
`50`	`50`	`_ if false => {}`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,46 +148,46 @@ LL \| V5,`
`148`	`148`	= note: the matched value is of type `NonEmptyEnum5`
`149`	`149`	`= help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or multiple match arms`
`150`	`150`
`151`		-error[E0004]: non-exhaustive patterns: `_` not covered
	`151`	+error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
`152`	`152`	`--> $DIR/empty-match.rs:58:24`
`153`	`153`	`\|`
`154`	`154`	`LL \| match_guarded_arm!(0u8);`
`155`		- \| ^^^ pattern `_` not covered
	`155`	+ \| ^^^ pattern `0_u8..=u8::MAX` not covered
`156`	`156`	`\|`
`157`	`157`	= note: the matched value is of type `u8`
`158`	`158`	`= note: match arms with guards don't count towards exhaustivity`
`159`	`159`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`160`	`160`	`\|`
`161`	`161`	`LL ~ _ if false => {},`
`162`		`-LL + _ => todo!()`
	`162`	`+LL + 0_u8..=u8::MAX => todo!()`
`163`	`163`	`\|`
`164`	`164`
`165`		-error[E0004]: non-exhaustive patterns: `_` not covered
	`165`	+error[E0004]: non-exhaustive patterns: `i8::MIN..=i8::MAX` not covered
`166`	`166`	`--> $DIR/empty-match.rs:59:24`
`167`	`167`	`\|`
`168`	`168`	`LL \| match_guarded_arm!(0i8);`
`169`		- \| ^^^ pattern `_` not covered
	`169`	+ \| ^^^ pattern `i8::MIN..=i8::MAX` not covered
`170`	`170`	`\|`
`171`	`171`	= note: the matched value is of type `i8`
`172`	`172`	`= note: match arms with guards don't count towards exhaustivity`
`173`	`173`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`174`	`174`	`\|`
`175`	`175`	`LL ~ _ if false => {},`
`176`		`-LL + _ => todo!()`
	`176`	`+LL + i8::MIN..=i8::MAX => todo!()`
`177`	`177`	`\|`
`178`	`178`
`179`		-error[E0004]: non-exhaustive patterns: `_` not covered
	`179`	+error[E0004]: non-exhaustive patterns: `0_usize..` not covered
`180`	`180`	`--> $DIR/empty-match.rs:60:24`
`181`	`181`	`\|`
`182`	`182`	`LL \| match_guarded_arm!(0usize);`
`183`		- \| ^^^^^^ pattern `_` not covered
	`183`	+ \| ^^^^^^ pattern `0_usize..` not covered
`184`	`184`	`\|`
`185`	`185`	= note: the matched value is of type `usize`
`186`	`186`	`= note: match arms with guards don't count towards exhaustivity`
`187`	`187`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`188`	`188`	`\|`
`189`	`189`	`LL ~ _ if false => {},`
`190`		`-LL + _ => todo!()`
	`190`	`+LL + 0_usize.. => todo!()`
`191`	`191`	`\|`
`192`	`192`
`193`	`193`	error[E0004]: non-exhaustive patterns: `_` not covered