Suggest never pattern instead of `_` for empty types

2 files changed, 57 insertions, 57 deletions

diff --git a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
index e429903fc72..70d5b266bda 100644
--- a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
@@ -74,11 +74,11 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
 
-error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(_)` not covered
+error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(!)` not covered
   --> $DIR/empty-types.rs:91:11
    |
 LL |     match res_u32_never {}
-   |           ^^^^^^^^^^^^^ patterns `Ok(_)` and `Err(_)` not covered
+   |           ^^^^^^^^^^^^^ patterns `Ok(_)` and `Err(!)` not covered
    |
 note: `Result<u32, !>` defined here
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -92,15 +92,15 @@ note: `Result<u32, !>` defined here
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~     match res_u32_never {
-LL +         Ok(_) | Err(_) => todo!(),
+LL +         Ok(_) | Err(!) => todo!(),
 LL +     }
    |
 
-error[E0004]: non-exhaustive patterns: `Err(_)` not covered
+error[E0004]: non-exhaustive patterns: `Err(!)` not covered
   --> $DIR/empty-types.rs:93:11
    |
 LL |     match res_u32_never {
-   |           ^^^^^^^^^^^^^ pattern `Err(_)` not covered
+   |           ^^^^^^^^^^^^^ pattern `Err(!)` not covered
    |
 note: `Result<u32, !>` defined here
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -111,7 +111,7 @@ note: `Result<u32, !>` defined here
 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 ~         Ok(_) => {},
-LL +         Err(_) => todo!()
+LL +         Err(!) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
@@ -136,7 +136,7 @@ error[E0005]: refutable pattern in local binding
   --> $DIR/empty-types.rs:106:9
    |
 LL |     let Ok(_x) = res_u32_never;
-   |         ^^^^^^ pattern `Err(_)` not covered
+   |         ^^^^^^ pattern `Err(!)` not covered
    |
    = note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
    = note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
@@ -164,7 +164,7 @@ error[E0005]: refutable pattern in local binding
   --> $DIR/empty-types.rs:112:9
    |
 LL |     let Ok(_x) = &res_u32_never;
-   |         ^^^^^^ pattern `&Err(_)` not covered
+   |         ^^^^^^ pattern `&Err(!)` not covered
    |
    = note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
    = note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
@@ -174,11 +174,11 @@ help: you might want to use `let else` to handle the variant that isn't matched
 LL |     let Ok(_x) = &res_u32_never else { todo!() };
    |                                 ++++++++++++++++
 
-error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(_)` not covered
+error[E0004]: non-exhaustive patterns: `Ok(!)` and `Err(!)` not covered
   --> $DIR/empty-types.rs:116:11
    |
 LL |     match result_never {}
-   |           ^^^^^^^^^^^^ patterns `Ok(_)` and `Err(_)` not covered
+   |           ^^^^^^^^^^^^ patterns `Ok(!)` and `Err(!)` not covered
    |
 note: `Result<!, !>` defined here
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -192,15 +192,15 @@ note: `Result<!, !>` defined here
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~     match result_never {
-LL +         Ok(_) | Err(_) => todo!(),
+LL +         Ok(!) | Err(!) => todo!(),
 LL +     }
    |
 
-error[E0004]: non-exhaustive patterns: `Err(_)` not covered
+error[E0004]: non-exhaustive patterns: `Err(!)` not covered
   --> $DIR/empty-types.rs:121:11
    |
 LL |     match result_never {
-   |           ^^^^^^^^^^^^ pattern `Err(_)` not covered
+   |           ^^^^^^^^^^^^ pattern `Err(!)` not covered
    |
 note: `Result<!, !>` defined here
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -210,7 +210,7 @@ note: `Result<!, !>` defined here
    = note: the matched value is of type `Result<!, !>`
 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 |         Ok(_) => {}, Err(_) => todo!()
+LL |         Ok(_) => {}, Err(!) => todo!()
    |                    +++++++++++++++++++
 
 error: unreachable pattern
@@ -225,11 +225,11 @@ error: unreachable pattern
 LL |             _ if false => {}
    |             ^
 
-error[E0004]: non-exhaustive patterns: `Some(_)` not covered
+error[E0004]: non-exhaustive patterns: `Some(!)` not covered
   --> $DIR/empty-types.rs:146:15
    |
 LL |         match opt_void {
-   |               ^^^^^^^^ pattern `Some(_)` not covered
+   |               ^^^^^^^^ pattern `Some(!)` not covered
    |
 note: `Option<Void>` defined here
   --> $SRC_DIR/core/src/option.rs:LL:COL
@@ -240,14 +240,14 @@ note: `Option<Void>` defined here
 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 ~             None => {},
-LL +             Some(_) => todo!()
+LL +             Some(!) => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `Some(_)` not covered
+error[E0004]: non-exhaustive patterns: `Some(!)` not covered
   --> $DIR/empty-types.rs:165:15
    |
 LL |         match *ref_opt_void {
-   |               ^^^^^^^^^^^^^ pattern `Some(_)` not covered
+   |               ^^^^^^^^^^^^^ pattern `Some(!)` not covered
    |
 note: `Option<Void>` defined here
   --> $SRC_DIR/core/src/option.rs:LL:COL
@@ -258,7 +258,7 @@ note: `Option<Void>` defined here
 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 ~             None => {},
-LL +             Some(_) => todo!()
+LL +             Some(!) => todo!()
    |
 
 error: unreachable pattern
@@ -325,11 +325,11 @@ LL +         _ => todo!(),
 LL ~     }
    |
 
-error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(_)` not covered
+error[E0004]: non-exhaustive patterns: `Ok(!)` and `Err(!)` not covered
   --> $DIR/empty-types.rs:320:11
    |
 LL |     match *x {}
-   |           ^^ patterns `Ok(_)` and `Err(_)` not covered
+   |           ^^ patterns `Ok(!)` and `Err(!)` not covered
    |
 note: `Result<!, !>` defined here
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -343,7 +343,7 @@ note: `Result<!, !>` defined here
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~     match *x {
-LL +         Ok(_) | Err(_) => todo!(),
+LL +         Ok(!) | Err(!) => todo!(),
 LL ~     }
    |
 
@@ -375,44 +375,44 @@ LL +         _ => todo!(),
 LL +     }
    |
 
-error[E0004]: non-exhaustive patterns: `&[_, ..]` not covered
+error[E0004]: non-exhaustive patterns: `&[!, ..]` not covered
   --> $DIR/empty-types.rs:329:11
    |
 LL |     match slice_never {
-   |           ^^^^^^^^^^^ pattern `&[_, ..]` not covered
+   |           ^^^^^^^^^^^ pattern `&[!, ..]` not covered
    |
    = note: the matched value is of type `&[!]`
 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 ~         [] => {},
-LL +         &[_, ..] => todo!()
+LL +         &[!, ..] => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `&[]`, `&[_]` and `&[_, _]` not covered
+error[E0004]: non-exhaustive patterns: `&[]`, `&[!]` and `&[!, !]` not covered
   --> $DIR/empty-types.rs:338:11
    |
 LL |     match slice_never {
-   |           ^^^^^^^^^^^ patterns `&[]`, `&[_]` and `&[_, _]` not covered
+   |           ^^^^^^^^^^^ patterns `&[]`, `&[!]` and `&[!, !]` not covered
    |
    = note: the matched value is of type `&[!]`
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         [_, _, _, ..] => {},
-LL +         &[] | &[_] | &[_, _] => todo!()
+LL +         &[] | &[!] | &[!, !] => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `&[]` and `&[_, ..]` not covered
+error[E0004]: non-exhaustive patterns: `&[]` and `&[!, ..]` not covered
   --> $DIR/empty-types.rs:352:11
    |
 LL |     match slice_never {
-   |           ^^^^^^^^^^^ patterns `&[]` and `&[_, ..]` not covered
+   |           ^^^^^^^^^^^ patterns `&[]` and `&[!, ..]` not covered
    |
    = note: the matched value is of type `&[!]`
    = 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, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         &[..] if false => {},
-LL +         &[] | &[_, ..] => todo!()
+LL +         &[] | &[!, ..] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
@@ -477,11 +477,11 @@ LL ~         [..] if false => {},
 LL +         [] => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `&Some(_)` not covered
+error[E0004]: non-exhaustive patterns: `&Some(!)` not covered
   --> $DIR/empty-types.rs:452:11
    |
 LL |     match ref_opt_never {
-   |           ^^^^^^^^^^^^^ pattern `&Some(_)` not covered
+   |           ^^^^^^^^^^^^^ pattern `&Some(!)` not covered
    |
 note: `Option<!>` defined here
   --> $SRC_DIR/core/src/option.rs:LL:COL
@@ -492,14 +492,14 @@ note: `Option<!>` defined here
 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 ~         &None => {},
-LL +         &Some(_) => todo!()
+LL +         &Some(!) => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `Some(_)` not covered
+error[E0004]: non-exhaustive patterns: `Some(!)` not covered
   --> $DIR/empty-types.rs:493:11
    |
 LL |     match *ref_opt_never {
-   |           ^^^^^^^^^^^^^^ pattern `Some(_)` not covered
+   |           ^^^^^^^^^^^^^^ pattern `Some(!)` not covered
    |
 note: `Option<!>` defined here
   --> $SRC_DIR/core/src/option.rs:LL:COL
@@ -510,14 +510,14 @@ note: `Option<!>` defined here
 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 ~         None => {},
-LL +         Some(_) => todo!()
+LL +         Some(!) => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `Err(_)` not covered
+error[E0004]: non-exhaustive patterns: `Err(!)` not covered
   --> $DIR/empty-types.rs:541:11
    |
 LL |     match *ref_res_never {
-   |           ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
+   |           ^^^^^^^^^^^^^^ pattern `Err(!)` not covered
    |
 note: `Result<!, !>` defined here
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -528,14 +528,14 @@ note: `Result<!, !>` defined here
 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 ~         Ok(_) => {},
-LL +         Err(_) => todo!()
+LL +         Err(!) => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `Err(_)` not covered
+error[E0004]: non-exhaustive patterns: `Err(!)` not covered
   --> $DIR/empty-types.rs:552:11
    |
 LL |     match *ref_res_never {
-   |           ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
+   |           ^^^^^^^^^^^^^^ pattern `Err(!)` not covered
    |
 note: `Result<!, !>` defined here
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -546,7 +546,7 @@ note: `Result<!, !>` defined here
 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 ~         Ok(_a) => {},
-LL +         Err(_) => todo!()
+LL +         Err(!) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
@@ -587,11 +587,11 @@ error: unreachable pattern
 LL |         _x if false => {}
    |         ^^
 
-error[E0004]: non-exhaustive patterns: `&_` not covered
+error[E0004]: non-exhaustive patterns: `&!` not covered
   --> $DIR/empty-types.rs:638:11
    |
 LL |     match ref_never {
-   |           ^^^^^^^^^ pattern `&_` not covered
+   |           ^^^^^^^^^ pattern `&!` not covered
    |
    = note: the matched value is of type `&!`
    = note: references are always considered inhabited
@@ -599,14 +599,14 @@ LL |     match ref_never {
 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 ~         &_a if false => {},
-LL +         &_ => todo!()
+LL +         &! => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
+error[E0004]: non-exhaustive patterns: `Ok(!)` not covered
   --> $DIR/empty-types.rs:654:11
    |
 LL |     match *ref_result_never {
-   |           ^^^^^^^^^^^^^^^^^ pattern `Ok(_)` not covered
+   |           ^^^^^^^^^^^^^^^^^ pattern `Ok(!)` not covered
    |
 note: `Result<!, !>` defined here
   --> $SRC_DIR/core/src/result.rs:LL:COL
@@ -617,14 +617,14 @@ note: `Result<!, !>` defined here
 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 ~         Err(_) => {},
-LL +         Ok(_) => todo!()
+LL +         Ok(!) => todo!()
    |
 
-error[E0004]: non-exhaustive patterns: `Some(_)` not covered
+error[E0004]: non-exhaustive patterns: `Some(!)` not covered
   --> $DIR/empty-types.rs:674:11
    |
 LL |     match *x {
-   |           ^^ pattern `Some(_)` not covered
+   |           ^^ pattern `Some(!)` not covered
    |
 note: `Option<Result<!, !>>` defined here
   --> $SRC_DIR/core/src/option.rs:LL:COL
@@ -635,7 +635,7 @@ note: `Option<Result<!, !>>` defined here
 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 ~         None => {},
-LL +         Some(_) => todo!()
+LL +         Some(!) => todo!()
    |
 
 error: aborting due to 49 previous errors; 1 warning emitted
diff --git a/tests/ui/pattern/usefulness/empty-types.rs b/tests/ui/pattern/usefulness/empty-types.rs
index 2454955f8a5..cc71f67831d 100644
--- a/tests/ui/pattern/usefulness/empty-types.rs
+++ b/tests/ui/pattern/usefulness/empty-types.rs
@@ -338,7 +338,7 @@ fn arrays_and_slices(x: NeverBundle) {
     match slice_never {
         //[normal,min_exh_pats]~^ ERROR `&[]`, `&[_]` and `&[_, _]` not covered
         //[exhaustive_patterns]~^^ ERROR `&[]` not covered
-        //[never_pats]~^^^ ERROR `&[]`, `&[_]` and `&[_, _]` not covered
+        //[never_pats]~^^^ ERROR `&[]`, `&[!]` and `&[!, !]` not covered
         [_, _, _, ..] => {}
     }
     match slice_never {
@@ -352,7 +352,7 @@ fn arrays_and_slices(x: NeverBundle) {
     match slice_never {
         //[normal,min_exh_pats]~^ ERROR `&[]` and `&[_, ..]` not covered
         //[exhaustive_patterns]~^^ ERROR `&[]` not covered
-        //[never_pats]~^^^ ERROR `&[]` and `&[_, ..]` not covered
+        //[never_pats]~^^^ ERROR `&[]` and `&[!, ..]` not covered
         &[..] if false => {}
     }
 
@@ -653,7 +653,7 @@ fn guards_and_validity(x: NeverBundle) {
     }
     match *ref_result_never {
         //[normal,min_exh_pats]~^ ERROR `Ok(_)` not covered
-        //[never_pats]~^^ ERROR `Ok(_)` not covered
+        //[never_pats]~^^ ERROR `Ok(!)` not covered
         // useful, reachable
         Ok(_) if false => {}
         // useful, reachable
@@ -673,7 +673,7 @@ fn diagnostics_subtlety(x: NeverBundle) {
     let x: &Option<Result<!, !>> = &None;
     match *x {
         //[normal,min_exh_pats]~^ ERROR `Some(_)` not covered
-        //[never_pats]~^^ ERROR `Some(_)` not covered
+        //[never_pats]~^^ ERROR `Some(!)` not covered
         None => {}
     }
 }