rust/tests/ui/pattern/usefulness/empty-match.normal.stderr

error: unreachable pattern
  --> $DIR/empty-match.rs:37:9
   |
LL |         _ => {},
   |         ^
   |
note: the lint level is defined here
  --> $DIR/empty-match.rs:8:9
   |
LL | #![deny(unreachable_patterns)]
   |         ^^^^^^^^^^^^^^^^^^^^

error: unreachable pattern
  --> $DIR/empty-match.rs:40:9
   |
LL |         _ if false => {},
   |         ^

error: unreachable pattern
  --> $DIR/empty-match.rs:47:9
   |
LL |         _ => {},
   |         ^

error: unreachable pattern
  --> $DIR/empty-match.rs:50:9
   |
LL |         _ if false => {},
   |         ^

error[E0005]: refutable pattern in local binding
  --> $DIR/empty-match.rs:55:9
   |
LL |     let None = x;
   |         ^^^^ pattern `Some(_)` 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
   = note: the matched value is of type `Option<SecretlyUninhabitedForeignStruct>`
help: you might want to use `if let` to ignore the variant that isn't matched
   |
LL |     if let None = x { todo!() };
   |     ++              +++++++++++

error: unreachable pattern
  --> $DIR/empty-match.rs:61:9
   |
LL |         _ => {},
   |         ^

error: unreachable pattern
  --> $DIR/empty-match.rs:64:9
   |
LL |         _ if false => {},
   |         ^

error[E0004]: non-exhaustive patterns: type `u8` is non-empty
  --> $DIR/empty-match.rs:82:20
   |
LL |     match_no_arms!(0u8);
   |                    ^^^
   |
   = note: the matched value is of type `u8`
   = help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern

error[E0004]: non-exhaustive patterns: type `NonEmptyStruct1` is non-empty
  --> $DIR/empty-match.rs:83:20
   |
LL |     match_no_arms!(NonEmptyStruct1);
   |                    ^^^^^^^^^^^^^^^
   |
note: `NonEmptyStruct1` defined here
  --> $DIR/empty-match.rs:14:8
   |
LL | struct NonEmptyStruct1;
   |        ^^^^^^^^^^^^^^^
   = note: the matched value is of type `NonEmptyStruct1`
   = help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern

error[E0004]: non-exhaustive patterns: type `NonEmptyStruct2` is non-empty
  --> $DIR/empty-match.rs:84:20
   |
LL |     match_no_arms!(NonEmptyStruct2(true));
   |                    ^^^^^^^^^^^^^^^^^^^^^
   |
note: `NonEmptyStruct2` defined here
  --> $DIR/empty-match.rs:15:8
   |
LL | struct NonEmptyStruct2(bool);
   |        ^^^^^^^^^^^^^^^
   = note: the matched value is of type `NonEmptyStruct2`
   = help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern

error[E0004]: non-exhaustive patterns: type `NonEmptyUnion1` is non-empty
  --> $DIR/empty-match.rs:85:20
   |
LL |     match_no_arms!((NonEmptyUnion1 { foo: () }));
   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: `NonEmptyUnion1` defined here
  --> $DIR/empty-match.rs:16:7
   |
LL | union NonEmptyUnion1 {
   |       ^^^^^^^^^^^^^^
   = note: the matched value is of type `NonEmptyUnion1`
   = help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern

error[E0004]: non-exhaustive patterns: type `NonEmptyUnion2` is non-empty
  --> $DIR/empty-match.rs:86:20
   |
LL |     match_no_arms!((NonEmptyUnion2 { foo: () }));
   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: `NonEmptyUnion2` defined here
  --> $DIR/empty-match.rs:19:7
   |
LL | union NonEmptyUnion2 {
   |       ^^^^^^^^^^^^^^
   = note: the matched value is of type `NonEmptyUnion2`
   = help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern

error[E0004]: non-exhaustive patterns: `NonEmptyEnum1::Foo(_)` not covered
  --> $DIR/empty-match.rs:87:20
   |
LL |     match_no_arms!(NonEmptyEnum1::Foo(true));
   |                    ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered
   |
note: `NonEmptyEnum1` defined here
  --> $DIR/empty-match.rs:24:5
   |
LL | enum NonEmptyEnum1 {
   |      -------------
LL |     Foo(bool),
   |     ^^^ not covered
   = note: the matched value is of type `NonEmptyEnum1`
   = help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern

error[E0004]: non-exhaustive patterns: `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
  --> $DIR/empty-match.rs:88:20
   |
LL |     match_no_arms!(NonEmptyEnum2::Foo(true));
   |                    ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
   |
note: `NonEmptyEnum2` defined here
  --> $DIR/empty-match.rs:27:5
   |
LL | enum NonEmptyEnum2 {
   |      -------------
LL |     Foo(bool),
   |     ^^^ not covered
LL |     Bar,
   |     ^^^ not covered
   = note: the matched value is of type `NonEmptyEnum2`
   = 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: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
  --> $DIR/empty-match.rs:89:20
   |
LL |     match_no_arms!(NonEmptyEnum5::V1);
   |                    ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
   |
note: `NonEmptyEnum5` defined here
  --> $DIR/empty-match.rs:30:6
   |
LL | enum NonEmptyEnum5 {
   |      ^^^^^^^^^^^^^
   = 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
  --> $DIR/empty-match.rs:91:24
   |
LL |     match_guarded_arm!(0u8);
   |                        ^^^ pattern `_` not covered
   |
   = note: the matched value is of type `u8`
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!()
   |

error[E0004]: non-exhaustive patterns: `NonEmptyStruct1` not covered
  --> $DIR/empty-match.rs:92:24
   |
LL |     match_guarded_arm!(NonEmptyStruct1);
   |                        ^^^^^^^^^^^^^^^ pattern `NonEmptyStruct1` not covered
   |
note: `NonEmptyStruct1` defined here
  --> $DIR/empty-match.rs:14:8
   |
LL | struct NonEmptyStruct1;
   |        ^^^^^^^^^^^^^^^
   = note: the matched value is of type `NonEmptyStruct1`
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 +             NonEmptyStruct1 => todo!()
   |

error[E0004]: non-exhaustive patterns: `NonEmptyStruct2(_)` not covered
  --> $DIR/empty-match.rs:93:24
   |
LL |     match_guarded_arm!(NonEmptyStruct2(true));
   |                        ^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyStruct2(_)` not covered
   |
note: `NonEmptyStruct2` defined here
  --> $DIR/empty-match.rs:15:8
   |
LL | struct NonEmptyStruct2(bool);
   |        ^^^^^^^^^^^^^^^
   = note: the matched value is of type `NonEmptyStruct2`
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 +             NonEmptyStruct2(_) => todo!()
   |

error[E0004]: non-exhaustive patterns: `NonEmptyUnion1 { .. }` not covered
  --> $DIR/empty-match.rs:94:24
   |
LL |     match_guarded_arm!((NonEmptyUnion1 { foo: () }));
   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion1 { .. }` not covered
   |
note: `NonEmptyUnion1` defined here
  --> $DIR/empty-match.rs:16:7
   |
LL | union NonEmptyUnion1 {
   |       ^^^^^^^^^^^^^^
   = note: the matched value is of type `NonEmptyUnion1`
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 +             NonEmptyUnion1 { .. } => todo!()
   |

error[E0004]: non-exhaustive patterns: `NonEmptyUnion2 { .. }` not covered
  --> $DIR/empty-match.rs:95:24
   |
LL |     match_guarded_arm!((NonEmptyUnion2 { foo: () }));
   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered
   |
note: `NonEmptyUnion2` defined here
  --> $DIR/empty-match.rs:19:7
   |
LL | union NonEmptyUnion2 {
   |       ^^^^^^^^^^^^^^
   = note: the matched value is of type `NonEmptyUnion2`
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 +             NonEmptyUnion2 { .. } => todo!()
   |

error[E0004]: non-exhaustive patterns: `NonEmptyEnum1::Foo(_)` not covered
  --> $DIR/empty-match.rs:96:24
   |
LL |     match_guarded_arm!(NonEmptyEnum1::Foo(true));
   |                        ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered
   |
note: `NonEmptyEnum1` defined here
  --> $DIR/empty-match.rs:24:5
   |
LL | enum NonEmptyEnum1 {
   |      -------------
LL |     Foo(bool),
   |     ^^^ not covered
   = note: the matched value is of type `NonEmptyEnum1`
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 +             NonEmptyEnum1::Foo(_) => todo!()
   |

error[E0004]: non-exhaustive patterns: `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
  --> $DIR/empty-match.rs:97:24
   |
LL |     match_guarded_arm!(NonEmptyEnum2::Foo(true));
   |                        ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
   |
note: `NonEmptyEnum2` defined here
  --> $DIR/empty-match.rs:27:5
   |
LL | enum NonEmptyEnum2 {
   |      -------------
LL |     Foo(bool),
   |     ^^^ not covered
LL |     Bar,
   |     ^^^ not covered
   = note: the matched value is of type `NonEmptyEnum2`
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 +             NonEmptyEnum2::Foo(_) | NonEmptyEnum2::Bar => todo!()
   |

error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
  --> $DIR/empty-match.rs:98:24
   |
LL |     match_guarded_arm!(NonEmptyEnum5::V1);
   |                        ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
   |
note: `NonEmptyEnum5` defined here
  --> $DIR/empty-match.rs:30:6
   |
LL | enum NonEmptyEnum5 {
   |      ^^^^^^^^^^^^^
   = 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 as shown, or multiple match arms
   |
LL ~             _ if false => {},
LL +             _ => todo!()
   |

error: aborting due to 23 previous errors

Some errors have detailed explanations: E0004, E0005.
For more information about an error, try `rustc --explain E0004`.