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

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

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

error[E0004]: non-exhaustive patterns: type `isize` is non-empty
  --> $DIR/empty-match.rs:50:20
   |
LL |     match_no_arms!(0isize);
   |                    ^^^^^^
   |
   = note: the matched value is of type `isize`
   = 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:51:20
   |
LL |     match_no_arms!(NonEmptyStruct1);
   |                    ^^^^^^^^^^^^^^^
   |
note: `NonEmptyStruct1` defined here
  --> $DIR/empty-match.rs:22:12
   |
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:52:20
   |
LL |     match_no_arms!(NonEmptyStruct2(true));
   |                    ^^^^^^^^^^^^^^^^^^^^^
   |
note: `NonEmptyStruct2` defined here
  --> $DIR/empty-match.rs:23:12
   |
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:53:20
   |
LL |     match_no_arms!((NonEmptyUnion1 { foo: () }));
   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: `NonEmptyUnion1` defined here
  --> $DIR/empty-match.rs:24:11
   |
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:54:20
   |
LL |     match_no_arms!((NonEmptyUnion2 { foo: () }));
   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: `NonEmptyUnion2` defined here
  --> $DIR/empty-match.rs:27:11
   |
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:55:20
   |
LL |     match_no_arms!(NonEmptyEnum1::Foo(true));
   |                    ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered
   |
note: `NonEmptyEnum1` defined here
  --> $DIR/empty-match.rs:31:10
   |
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:56:20
   |
LL |     match_no_arms!(NonEmptyEnum2::Foo(true));
   |                    ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
   |
note: `NonEmptyEnum2` defined here
  --> $DIR/empty-match.rs:34:10
   |
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:57: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:38:10
   |
LL |     enum NonEmptyEnum5 {
   |          ^^^^^^^^^^^^^
LL |         V1,
   |         -- not covered
LL |         V2,
   |         -- not covered
LL |         V3,
   |         -- not covered
LL |         V4,
   |         -- not covered
LL |         V5,
   |         -- not covered
   = 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: type `[!; 0]` is non-empty
  --> $DIR/empty-match.rs:58:20
   |
LL |     match_no_arms!(array0_of_empty);
   |                    ^^^^^^^^^^^^^^^
   |
   = note: the matched value is of type `[!; 0]`
   = help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern

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

error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
  --> $DIR/empty-match.rs:61:24
   |
LL |     match_guarded_arm!(0u8);
   |                        ^^^ 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 +                 0_u8..=u8::MAX => todo!()
   |

error[E0004]: non-exhaustive patterns: `i8::MIN..=i8::MAX` not covered
  --> $DIR/empty-match.rs:62:24
   |
LL |     match_guarded_arm!(0i8);
   |                        ^^^ 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 +                 i8::MIN..=i8::MAX => todo!()
   |

error[E0004]: non-exhaustive patterns: `0_usize..` not covered
  --> $DIR/empty-match.rs:63:24
   |
LL |     match_guarded_arm!(0usize);
   |                        ^^^^^^ 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 +                 0_usize.. => todo!()
   |

error[E0004]: non-exhaustive patterns: `_` not covered
  --> $DIR/empty-match.rs:64:24
   |
LL |     match_guarded_arm!(0isize);
   |                        ^^^^^^ pattern `_` not covered
   |
   = note: the matched value is of type `isize`
   = 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!()
   |

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

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

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

error[E0004]: non-exhaustive patterns: `NonEmptyUnion2 { .. }` not covered
  --> $DIR/empty-match.rs:68:24
   |
LL |     match_guarded_arm!((NonEmptyUnion2 { foo: () }));
   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered
   |
note: `NonEmptyUnion2` defined here
  --> $DIR/empty-match.rs:27:11
   |
LL |     union NonEmptyUnion2 {
   |           ^^^^^^^^^^^^^^
   = note: the matched value is of type `NonEmptyUnion2`
   = note: `!` is uninhabited but is not being matched by value, so a wildcard `_` is required
   = 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 +                 NonEmptyUnion2 { .. } => todo!()
   |

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

error[E0004]: non-exhaustive patterns: `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
  --> $DIR/empty-match.rs:70:24
   |
LL |     match_guarded_arm!(NonEmptyEnum2::Foo(true));
   |                        ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
   |
note: `NonEmptyEnum2` defined here
  --> $DIR/empty-match.rs:34:10
   |
LL |     enum NonEmptyEnum2 {
   |          ^^^^^^^^^^^^^
LL |         Foo(bool),
   |         --- not covered
LL |         Bar,
   |         --- not covered
   = note: the matched value is of type `NonEmptyEnum2`
   = 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 +                 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:71:24
   |
LL | ...ded_arm!(NonEmptyEnum5::V1);
   |             ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
   |
note: `NonEmptyEnum5` defined here
  --> $DIR/empty-match.rs:38:10
   |
LL |     enum NonEmptyEnum5 {
   |          ^^^^^^^^^^^^^
LL |         V1,
   |         -- not covered
LL |         V2,
   |         -- not covered
LL |         V3,
   |         -- not covered
LL |         V4,
   |         -- not covered
LL |         V5,
   |         -- not covered
   = note: the matched value is of type `NonEmptyEnum5`
   = 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 as shown, or multiple match arms
   |
LL ~                 _ if false => {},
LL +                 _ => todo!()
   |

error[E0004]: non-exhaustive patterns: `[]` not covered
  --> $DIR/empty-match.rs:72:24
   |
LL |     match_guarded_arm!(array0_of_empty);
   |                        ^^^^^^^^^^^^^^^ pattern `[]` not covered
   |
   = note: the matched value is of type `[!; 0]`
   = 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!()
   |

error[E0004]: non-exhaustive patterns: `[]` not covered
  --> $DIR/empty-match.rs:73:24
   |
LL |     match_guarded_arm!(arrayN_of_empty);
   |                        ^^^^^^^^^^^^^^^ pattern `[]` not covered
   |
   = note: the matched value is of type `[!; N]`
   = 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!()
   |

error: aborting due to 26 previous errors

For more information about this error, try `rustc --explain E0004`.