Suggest never pattern instead of `_` for empty types

6 files changed, 97 insertions, 69 deletions

diff --git a/compiler/rustc_pattern_analysis/src/constructor.rs b/compiler/rustc_pattern_analysis/src/constructor.rs
index 66c9e2e1840..b4d32782acf 100644
--- a/compiler/rustc_pattern_analysis/src/constructor.rs
+++ b/compiler/rustc_pattern_analysis/src/constructor.rs
@@ -1048,10 +1048,32 @@ impl<Cx: TypeCx> ConstructorSet<Cx> {
                 // In a `MaybeInvalid` place even an empty pattern may be reachable. We therefore
                 // add a dummy empty constructor here, which will be ignored if the place is
                 // `ValidOnly`.
-                missing_empty.push(NonExhaustive);
+                missing_empty.push(Never);
             }
         }
 
         SplitConstructorSet { present, missing, missing_empty }
     }
+
+    /// Whether this set only contains empty constructors.
+    pub(crate) fn all_empty(&self) -> bool {
+        match self {
+            ConstructorSet::Bool
+            | ConstructorSet::Integers { .. }
+            | ConstructorSet::Ref
+            | ConstructorSet::Union
+            | ConstructorSet::Unlistable => false,
+            ConstructorSet::NoConstructors => true,
+            ConstructorSet::Struct { empty } => *empty,
+            ConstructorSet::Variants { variants, non_exhaustive } => {
+                !*non_exhaustive
+                    && variants
+                        .iter()
+                        .all(|visibility| matches!(visibility, VariantVisibility::Empty))
+            }
+            ConstructorSet::Slice { array_len, subtype_is_empty } => {
+                *subtype_is_empty && matches!(array_len, Some(1..))
+            }
+        }
+    }
 }
diff --git a/compiler/rustc_pattern_analysis/src/pat.rs b/compiler/rustc_pattern_analysis/src/pat.rs
index 3395054b7b3..780a386fe65 100644
--- a/compiler/rustc_pattern_analysis/src/pat.rs
+++ b/compiler/rustc_pattern_analysis/src/pat.rs
@@ -292,18 +292,24 @@ impl<Cx: TypeCx> WitnessPat<Cx> {
     pub(crate) fn new(ctor: Constructor<Cx>, fields: Vec<Self>, ty: Cx::Ty) -> Self {
         Self { ctor, fields, ty }
     }
-    pub(crate) fn wildcard(ty: Cx::Ty) -> Self {
-        Self::new(Wildcard, Vec::new(), ty)
+    /// Create a wildcard pattern for this type. If the type is empty, we create a `!` pattern.
+    pub(crate) fn wildcard(cx: &Cx, ty: Cx::Ty) -> Self {
+        let is_empty = cx.ctors_for_ty(&ty).is_ok_and(|ctors| ctors.all_empty());
+        let ctor = if is_empty { Never } else { Wildcard };
+        Self::new(ctor, Vec::new(), ty)
     }
 
     /// Construct a pattern that matches everything that starts with this constructor.
     /// For example, if `ctor` is a `Constructor::Variant` for `Option::Some`, we get the pattern
     /// `Some(_)`.
     pub(crate) fn wild_from_ctor(cx: &Cx, ctor: Constructor<Cx>, ty: Cx::Ty) -> Self {
+        if matches!(ctor, Wildcard) {
+            return Self::wildcard(cx, ty);
+        }
         let fields = cx
             .ctor_sub_tys(&ctor, &ty)
             .filter(|(_, PrivateUninhabitedField(skip))| !skip)
-            .map(|(ty, _)| Self::wildcard(ty))
+            .map(|(ty, _)| Self::wildcard(cx, ty))
             .collect();
         Self::new(ctor, fields, ty)
     }
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 => {}
     }
 }
diff --git a/tests/ui/rfcs/rfc-0000-never_patterns/check.rs b/tests/ui/rfcs/rfc-0000-never_patterns/check.rs
index b6da0c20e07..0831477e749 100644
--- a/tests/ui/rfcs/rfc-0000-never_patterns/check.rs
+++ b/tests/ui/rfcs/rfc-0000-never_patterns/check.rs
@@ -15,12 +15,12 @@ fn no_arms_or_guards(x: Void) {
         //~^ ERROR a never pattern is always unreachable
         None => {}
     }
-    match None::<Void> { //~ ERROR: `Some(_)` not covered
+    match None::<Void> { //~ ERROR: `Some(!)` not covered
         Some(!) if true,
         //~^ ERROR guard on a never pattern
         None => {}
     }
-    match None::<Void> { //~ ERROR: `Some(_)` not covered
+    match None::<Void> { //~ ERROR: `Some(!)` not covered
         Some(!) if true => {}
         //~^ ERROR a never pattern is always unreachable
         None => {}
diff --git a/tests/ui/rfcs/rfc-0000-never_patterns/check.stderr b/tests/ui/rfcs/rfc-0000-never_patterns/check.stderr
index 5497252890f..82457f8b805 100644
--- a/tests/ui/rfcs/rfc-0000-never_patterns/check.stderr
+++ b/tests/ui/rfcs/rfc-0000-never_patterns/check.stderr
@@ -31,11 +31,11 @@ LL |         Some(never!()) => {}
    |                           this will never be executed
    |                           help: remove this expression
 
-error[E0004]: non-exhaustive patterns: `Some(_)` not covered
+error[E0004]: non-exhaustive patterns: `Some(!)` not covered
   --> $DIR/check.rs:18:11
    |
 LL |     match None::<Void> {
-   |           ^^^^^^^^^^^^ pattern `Some(_)` not covered
+   |           ^^^^^^^^^^^^ pattern `Some(!)` not covered
    |
 note: `Option<Void>` defined here
   --> $SRC_DIR/core/src/option.rs:LL:COL
@@ -46,14 +46,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/check.rs:23:11
    |
 LL |     match None::<Void> {
-   |           ^^^^^^^^^^^^ pattern `Some(_)` not covered
+   |           ^^^^^^^^^^^^ pattern `Some(!)` not covered
    |
 note: `Option<Void>` defined here
   --> $SRC_DIR/core/src/option.rs:LL:COL
@@ -64,7 +64,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: aborting due to 6 previous errors