bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

add note for non-exhaustive matches with guards

Browse source
This commit is contained in:
Eric Mark Martin 2023-06-22 01:52:31 -04:00
parent 6b46c996e1
commit fbd1e0252f
8 changed files with 60 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

5
compiler/rustc_mir_build/src/thir/pattern/check_match.rs
View file

@ -830,6 +830,11 @@ fn non_exhaustive_match<'p, 'tcx>(
_ => " or multiple match arms", _ => " or multiple match arms",
}, },
); );
let all_arms_have_guards = arms.iter().all(|arm_id| thir[*arm_id].guard.is_some());
if !is_empty_match && all_arms_have_guards {
err.note("match arms with guards don't count towards exhaustivity");
}
if let Some((span, sugg)) = suggestion { if let Some((span, sugg)) = suggestion {
err.span_suggestion_verbose(span, msg, sugg, Applicability::HasPlaceholders); err.span_suggestion_verbose(span, msg, sugg, Applicability::HasPlaceholders);
} else { } else {

22
tests/ui/pattern/usefulness/empty-match.exhaustive_patterns.stderr
View file

@ -176,6 +176,7 @@ LL | match_guarded_arm!(0u8);
| ^^^ pattern `_` not covered | ^^^ pattern `_` not covered
| |
= note: the matched value is of type `u8` = 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 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 ~ _ if false => {},
@ -183,7 +184,7 @@ LL + _ => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyStruct1` not covered error[E0004]: non-exhaustive patterns: `NonEmptyStruct1` not covered
--> $DIR/empty-match.rs:133:24 --> $DIR/empty-match.rs:134:24
| |
LL | match_guarded_arm!(NonEmptyStruct1); LL | match_guarded_arm!(NonEmptyStruct1);
| ^^^^^^^^^^^^^^^ pattern `NonEmptyStruct1` not covered | ^^^^^^^^^^^^^^^ pattern `NonEmptyStruct1` not covered
@ -194,6 +195,7 @@ note: `NonEmptyStruct1` defined here
LL | struct NonEmptyStruct1; LL | struct NonEmptyStruct1;
| ^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^
= note: the matched value is of type `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 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 ~ _ if false => {},
@ -201,7 +203,7 @@ LL + NonEmptyStruct1 => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyStruct2(_)` not covered error[E0004]: non-exhaustive patterns: `NonEmptyStruct2(_)` not covered
--> $DIR/empty-match.rs:137:24 --> $DIR/empty-match.rs:139:24
| |
LL | match_guarded_arm!(NonEmptyStruct2(true)); LL | match_guarded_arm!(NonEmptyStruct2(true));
| ^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyStruct2(_)` not covered | ^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyStruct2(_)` not covered
@ -212,6 +214,7 @@ note: `NonEmptyStruct2` defined here
LL | struct NonEmptyStruct2(bool); LL | struct NonEmptyStruct2(bool);
| ^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^
= note: the matched value is of type `NonEmptyStruct2` = 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 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 ~ _ if false => {},
@ -219,7 +222,7 @@ LL + NonEmptyStruct2(_) => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyUnion1 { .. }` not covered error[E0004]: non-exhaustive patterns: `NonEmptyUnion1 { .. }` not covered
--> $DIR/empty-match.rs:141:24 --> $DIR/empty-match.rs:144:24
| |
LL | match_guarded_arm!((NonEmptyUnion1 { foo: () })); LL | match_guarded_arm!((NonEmptyUnion1 { foo: () }));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion1 { .. }` not covered | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion1 { .. }` not covered
@ -230,6 +233,7 @@ note: `NonEmptyUnion1` defined here
LL | union NonEmptyUnion1 { LL | union NonEmptyUnion1 {
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
= note: the matched value is of type `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 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 ~ _ if false => {},
@ -237,7 +241,7 @@ LL + NonEmptyUnion1 { .. } => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyUnion2 { .. }` not covered error[E0004]: non-exhaustive patterns: `NonEmptyUnion2 { .. }` not covered
--> $DIR/empty-match.rs:145:24 --> $DIR/empty-match.rs:149:24
| |
LL | match_guarded_arm!((NonEmptyUnion2 { foo: () })); LL | match_guarded_arm!((NonEmptyUnion2 { foo: () }));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered
@ -248,6 +252,7 @@ note: `NonEmptyUnion2` defined here
LL | union NonEmptyUnion2 { LL | union NonEmptyUnion2 {
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
= note: the matched value is of type `NonEmptyUnion2` = note: the matched value is of type `NonEmptyUnion2`
= 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 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 ~ _ if false => {},
@ -255,7 +260,7 @@ LL + NonEmptyUnion2 { .. } => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyEnum1::Foo(_)` not covered error[E0004]: non-exhaustive patterns: `NonEmptyEnum1::Foo(_)` not covered
--> $DIR/empty-match.rs:149:24 --> $DIR/empty-match.rs:154:24
| |
LL | match_guarded_arm!(NonEmptyEnum1::Foo(true)); LL | match_guarded_arm!(NonEmptyEnum1::Foo(true));
| ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered | ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered
@ -268,6 +273,7 @@ LL | enum NonEmptyEnum1 {
LL | Foo(bool), LL | Foo(bool),
| ^^^ not covered | ^^^ not covered
= note: the matched value is of type `NonEmptyEnum1` = 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 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 ~ _ if false => {},
@ -275,7 +281,7 @@ LL + NonEmptyEnum1::Foo(_) => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered error[E0004]: non-exhaustive patterns: `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
--> $DIR/empty-match.rs:153:24 --> $DIR/empty-match.rs:159:24
| |
LL | match_guarded_arm!(NonEmptyEnum2::Foo(true)); LL | match_guarded_arm!(NonEmptyEnum2::Foo(true));
| ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered | ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
@ -291,6 +297,7 @@ LL | Foo(bool),
LL | Bar, LL | Bar,
| ^^^ not covered | ^^^ not covered
= note: the matched value is of type `NonEmptyEnum2` = 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 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 ~ _ if false => {},
@ -298,7 +305,7 @@ LL + NonEmptyEnum2::Foo(_) | NonEmptyEnum2::Bar => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
--> $DIR/empty-match.rs:157:24 --> $DIR/empty-match.rs:164:24
| |
LL | match_guarded_arm!(NonEmptyEnum5::V1); LL | match_guarded_arm!(NonEmptyEnum5::V1);
| ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered | ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
@ -309,6 +316,7 @@ note: `NonEmptyEnum5` defined here
LL | enum NonEmptyEnum5 { LL | enum NonEmptyEnum5 {
| ^^^^^^^^^^^^^ | ^^^^^^^^^^^^^
= note: the matched value is of type `NonEmptyEnum5` = 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 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 ~ _ if false => {},

22
tests/ui/pattern/usefulness/empty-match.normal.stderr
View file

@ -175,6 +175,7 @@ LL | match_guarded_arm!(0u8);
| ^^^ pattern `_` not covered | ^^^ pattern `_` not covered
| |
= note: the matched value is of type `u8` = 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 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 ~ _ if false => {},
@ -182,7 +183,7 @@ LL + _ => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyStruct1` not covered error[E0004]: non-exhaustive patterns: `NonEmptyStruct1` not covered
--> $DIR/empty-match.rs:133:24 --> $DIR/empty-match.rs:134:24
| |
LL | match_guarded_arm!(NonEmptyStruct1); LL | match_guarded_arm!(NonEmptyStruct1);
| ^^^^^^^^^^^^^^^ pattern `NonEmptyStruct1` not covered | ^^^^^^^^^^^^^^^ pattern `NonEmptyStruct1` not covered
@ -193,6 +194,7 @@ note: `NonEmptyStruct1` defined here
LL | struct NonEmptyStruct1; LL | struct NonEmptyStruct1;
| ^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^
= note: the matched value is of type `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 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 ~ _ if false => {},
@ -200,7 +202,7 @@ LL + NonEmptyStruct1 => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyStruct2(_)` not covered error[E0004]: non-exhaustive patterns: `NonEmptyStruct2(_)` not covered
--> $DIR/empty-match.rs:137:24 --> $DIR/empty-match.rs:139:24
| |
LL | match_guarded_arm!(NonEmptyStruct2(true)); LL | match_guarded_arm!(NonEmptyStruct2(true));
| ^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyStruct2(_)` not covered | ^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyStruct2(_)` not covered
@ -211,6 +213,7 @@ note: `NonEmptyStruct2` defined here
LL | struct NonEmptyStruct2(bool); LL | struct NonEmptyStruct2(bool);
| ^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^
= note: the matched value is of type `NonEmptyStruct2` = 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 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 ~ _ if false => {},
@ -218,7 +221,7 @@ LL + NonEmptyStruct2(_) => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyUnion1 { .. }` not covered error[E0004]: non-exhaustive patterns: `NonEmptyUnion1 { .. }` not covered
--> $DIR/empty-match.rs:141:24 --> $DIR/empty-match.rs:144:24
| |
LL | match_guarded_arm!((NonEmptyUnion1 { foo: () })); LL | match_guarded_arm!((NonEmptyUnion1 { foo: () }));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion1 { .. }` not covered | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion1 { .. }` not covered
@ -229,6 +232,7 @@ note: `NonEmptyUnion1` defined here
LL | union NonEmptyUnion1 { LL | union NonEmptyUnion1 {
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
= note: the matched value is of type `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 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 ~ _ if false => {},
@ -236,7 +240,7 @@ LL + NonEmptyUnion1 { .. } => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyUnion2 { .. }` not covered error[E0004]: non-exhaustive patterns: `NonEmptyUnion2 { .. }` not covered
--> $DIR/empty-match.rs:145:24 --> $DIR/empty-match.rs:149:24
| |
LL | match_guarded_arm!((NonEmptyUnion2 { foo: () })); LL | match_guarded_arm!((NonEmptyUnion2 { foo: () }));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered
@ -247,6 +251,7 @@ note: `NonEmptyUnion2` defined here
LL | union NonEmptyUnion2 { LL | union NonEmptyUnion2 {
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
= note: the matched value is of type `NonEmptyUnion2` = note: the matched value is of type `NonEmptyUnion2`
= 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 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 ~ _ if false => {},
@ -254,7 +259,7 @@ LL + NonEmptyUnion2 { .. } => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyEnum1::Foo(_)` not covered error[E0004]: non-exhaustive patterns: `NonEmptyEnum1::Foo(_)` not covered
--> $DIR/empty-match.rs:149:24 --> $DIR/empty-match.rs:154:24
| |
LL | match_guarded_arm!(NonEmptyEnum1::Foo(true)); LL | match_guarded_arm!(NonEmptyEnum1::Foo(true));
| ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered | ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered
@ -267,6 +272,7 @@ LL | enum NonEmptyEnum1 {
LL | Foo(bool), LL | Foo(bool),
| ^^^ not covered | ^^^ not covered
= note: the matched value is of type `NonEmptyEnum1` = 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 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 ~ _ if false => {},
@ -274,7 +280,7 @@ LL + NonEmptyEnum1::Foo(_) => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered error[E0004]: non-exhaustive patterns: `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
--> $DIR/empty-match.rs:153:24 --> $DIR/empty-match.rs:159:24
| |
LL | match_guarded_arm!(NonEmptyEnum2::Foo(true)); LL | match_guarded_arm!(NonEmptyEnum2::Foo(true));
| ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered | ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
@ -290,6 +296,7 @@ LL | Foo(bool),
LL | Bar, LL | Bar,
| ^^^ not covered | ^^^ not covered
= note: the matched value is of type `NonEmptyEnum2` = 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 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 ~ _ if false => {},
@ -297,7 +304,7 @@ LL + NonEmptyEnum2::Foo(_) | NonEmptyEnum2::Bar => todo!()
| |
error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
--> $DIR/empty-match.rs:157:24 --> $DIR/empty-match.rs:164:24
| |
LL | match_guarded_arm!(NonEmptyEnum5::V1); LL | match_guarded_arm!(NonEmptyEnum5::V1);
| ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered | ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
@ -308,6 +315,7 @@ note: `NonEmptyEnum5` defined here
LL | enum NonEmptyEnum5 { LL | enum NonEmptyEnum5 {
| ^^^^^^^^^^^^^ | ^^^^^^^^^^^^^
= note: the matched value is of type `NonEmptyEnum5` = 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 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 ~ _ if false => {},

8
tests/ui/pattern/usefulness/empty-match.rs
View file

@ -128,34 +128,42 @@ fn main() {
match_guarded_arm!(0u8); //~ ERROR `_` not covered match_guarded_arm!(0u8); //~ ERROR `_` not covered
//~| NOTE the matched value is of type //~| NOTE the matched value is of type
//~| NOTE match arms with guards don't count towards exhaustivity
//~| NOTE pattern `_` not covered //~| NOTE pattern `_` not covered
//~| NOTE in this expansion of match_guarded_arm! //~| NOTE in this expansion of match_guarded_arm!
match_guarded_arm!(NonEmptyStruct1); //~ ERROR `NonEmptyStruct1` not covered match_guarded_arm!(NonEmptyStruct1); //~ ERROR `NonEmptyStruct1` not covered
//~| NOTE pattern `NonEmptyStruct1` not covered //~| NOTE pattern `NonEmptyStruct1` not covered
//~| NOTE the matched value is of type //~| NOTE the matched value is of type
//~| NOTE match arms with guards don't count towards exhaustivity
//~| NOTE in this expansion of match_guarded_arm! //~| NOTE in this expansion of match_guarded_arm!
match_guarded_arm!(NonEmptyStruct2(true)); //~ ERROR `NonEmptyStruct2(_)` not covered match_guarded_arm!(NonEmptyStruct2(true)); //~ ERROR `NonEmptyStruct2(_)` not covered
//~| NOTE the matched value is of type //~| NOTE the matched value is of type
//~| NOTE pattern `NonEmptyStruct2(_)` not covered //~| NOTE pattern `NonEmptyStruct2(_)` not covered
//~| NOTE match arms with guards don't count towards exhaustivity
//~| NOTE in this expansion of match_guarded_arm! //~| NOTE in this expansion of match_guarded_arm!
match_guarded_arm!((NonEmptyUnion1 { foo: () })); //~ ERROR `NonEmptyUnion1 { .. }` not covered match_guarded_arm!((NonEmptyUnion1 { foo: () })); //~ ERROR `NonEmptyUnion1 { .. }` not covered
//~| NOTE the matched value is of type //~| NOTE the matched value is of type
//~| NOTE pattern `NonEmptyUnion1 { .. }` not covered //~| NOTE pattern `NonEmptyUnion1 { .. }` not covered
//~| NOTE match arms with guards don't count towards exhaustivity
//~| NOTE in this expansion of match_guarded_arm! //~| NOTE in this expansion of match_guarded_arm!
match_guarded_arm!((NonEmptyUnion2 { foo: () })); //~ ERROR `NonEmptyUnion2 { .. }` not covered match_guarded_arm!((NonEmptyUnion2 { foo: () })); //~ ERROR `NonEmptyUnion2 { .. }` not covered
//~| NOTE the matched value is of type //~| NOTE the matched value is of type
//~| NOTE pattern `NonEmptyUnion2 { .. }` not covered //~| NOTE pattern `NonEmptyUnion2 { .. }` not covered
//~| NOTE match arms with guards don't count towards exhaustivity
//~| NOTE in this expansion of match_guarded_arm! //~| NOTE in this expansion of match_guarded_arm!
match_guarded_arm!(NonEmptyEnum1::Foo(true)); //~ ERROR `NonEmptyEnum1::Foo(_)` not covered match_guarded_arm!(NonEmptyEnum1::Foo(true)); //~ ERROR `NonEmptyEnum1::Foo(_)` not covered
//~| NOTE the matched value is of type //~| NOTE the matched value is of type
//~| NOTE pattern `NonEmptyEnum1::Foo(_)` not covered //~| NOTE pattern `NonEmptyEnum1::Foo(_)` not covered
//~| NOTE match arms with guards don't count towards exhaustivity
//~| NOTE in this expansion of match_guarded_arm! //~| NOTE in this expansion of match_guarded_arm!
match_guarded_arm!(NonEmptyEnum2::Foo(true)); //~ ERROR `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered match_guarded_arm!(NonEmptyEnum2::Foo(true)); //~ ERROR `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
//~| NOTE the matched value is of type //~| NOTE the matched value is of type
//~| NOTE patterns `NonEmptyEnum2::Foo(_)` and //~| NOTE patterns `NonEmptyEnum2::Foo(_)` and
//~| NOTE match arms with guards don't count towards exhaustivity
//~| NOTE in this expansion of match_guarded_arm! //~| NOTE in this expansion of match_guarded_arm!
match_guarded_arm!(NonEmptyEnum5::V1); //~ ERROR `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered match_guarded_arm!(NonEmptyEnum5::V1); //~ ERROR `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
//~| NOTE the matched value is of type //~| NOTE the matched value is of type
//~| NOTE patterns `NonEmptyEnum5::V1`, //~| NOTE patterns `NonEmptyEnum5::V1`,
//~| NOTE match arms with guards don't count towards exhaustivity
//~| NOTE in this expansion of match_guarded_arm! //~| NOTE in this expansion of match_guarded_arm!
} }

18
tests/ui/pattern/usefulness/issue-3601.rs
View file

@ -1,19 +1,19 @@
#![feature(box_patterns)] #![feature(box_patterns)]
struct HTMLImageData { struct HTMLImageData {
image: Option<String> image: Option<String>,
} }
struct ElementData { struct ElementData {
kind: Box<ElementKind> kind: Box<ElementKind>,
} }
enum ElementKind { enum ElementKind {
HTMLImageElement(HTMLImageData) HTMLImageElement(HTMLImageData),
} }
enum NodeKind { enum NodeKind {
Element(ElementData) Element(ElementData),
} }
struct NodeData { struct NodeData {
@ -25,10 +25,14 @@ fn main() {
let ed = ElementData { kind: Box::new(ElementKind::HTMLImageElement(id)) }; let ed = ElementData { kind: Box::new(ElementKind::HTMLImageElement(id)) };
let n = NodeData { kind: Box::new(NodeKind::Element(ed)) }; let n = NodeData { kind: Box::new(NodeKind::Element(ed)) };
// n.b. span could be better
match n.kind { match n.kind {
box NodeKind::Element(ed) => match ed.kind { //~ ERROR non-exhaustive patterns box NodeKind::Element(ed) => match ed.kind {
box ElementKind::HTMLImageElement(ref d) if d.image.is_some() => { true } //~^ ERROR non-exhaustive patterns
//~| NOTE the matched value is of type
//~| NOTE match arms with guards don't count towards exhaustivity
//~| NOTE pattern `box _` not covered
//~| NOTE `Box<ElementKind>` defined here
box ElementKind::HTMLImageElement(ref d) if d.image.is_some() => true,
}, },
}; };
} }

7
tests/ui/pattern/usefulness/issue-3601.stderr
View file

@ -1,5 +1,5 @@
error[E0004]: non-exhaustive patterns: `box _` not covered error[E0004]: non-exhaustive patterns: `box _` not covered
--> $DIR/issue-3601.rs:30:44 --> $DIR/issue-3601.rs:29:44
| |
LL | box NodeKind::Element(ed) => match ed.kind { LL | box NodeKind::Element(ed) => match ed.kind {
| ^^^^^^^ pattern `box _` not covered | ^^^^^^^ pattern `box _` not covered
@ -7,10 +7,11 @@ LL | box NodeKind::Element(ed) => match ed.kind {
note: `Box<ElementKind>` defined here note: `Box<ElementKind>` defined here
--> $SRC_DIR/alloc/src/boxed.rs:LL:COL --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
= note: the matched value is of type `Box<ElementKind>` = note: the matched value is of type `Box<ElementKind>`
= 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 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 ~ box ElementKind::HTMLImageElement(ref d) if d.image.is_some() => { true }, LL ~ box ElementKind::HTMLImageElement(ref d) if d.image.is_some() => true,
LL + box _ => todo!() LL ~ box _ => todo!(),
| |
error: aborting due to previous error error: aborting due to previous error

1
tests/ui/pattern/usefulness/match-non-exhaustive.rs
View file

@ -1,4 +1,5 @@
fn main() { fn main() {
match 0 { 1 => () } //~ ERROR non-exhaustive patterns match 0 { 1 => () } //~ ERROR non-exhaustive patterns
match 0 { 0 if false => () } //~ ERROR non-exhaustive patterns match 0 { 0 if false => () } //~ ERROR non-exhaustive patterns
//-| NOTE match arms with guards don't count towards exhaustivity
} }

1
tests/ui/pattern/usefulness/match-non-exhaustive.stderr
View file

@ -17,6 +17,7 @@ LL | match 0 { 0 if false => () }
| ^ pattern `_` not covered | ^ pattern `_` not covered
| |
= note: the matched value is of type `i32` = note: the matched value is of type `i32`
= 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 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 | match 0 { 0 if false => (), _ => todo!() } LL | match 0 { 0 if false => (), _ => todo!() }