Rollup merge of rust-lang#113019 - ericmarkmartin:warning-for-guard-non-exhaustion, r=fee1-dead

Dylan-DPC · web-flow · commit e4e1a995dcec · 2023-06-28T18:28:47.000+05:30
add note for non-exhaustive matches with guards Associated issue: rust-lang#92197 When a match statement includes guards on every match arm (and is therefore necessarily non-exhaustive), add a note to the error E0004 diagnostic noting this.
diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
@@ -214,6 +214,9 @@ mir_build_mutation_of_layout_constrained_field_requires_unsafe_unsafe_op_in_unsa
 
 mir_build_non_const_path = runtime values cannot be referenced in patterns
 
+mir_build_non_exhaustive_match_all_arms_guarded =
+    match arms with guards don't count towards exhaustivity
+
 mir_build_non_exhaustive_omitted_pattern = some variants are not matched explicitly
     .help = ensure that all variants are matched explicitly by adding the suggested match arms
     .note = the matched value is of type `{$scrut_ty}` and the `non_exhaustive_omitted_patterns` attribute was found
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
@@ -432,6 +432,10 @@ impl<'a> IntoDiagnostic<'a> for NonExhaustivePatternsTypeNotEmpty<'_, '_, '_> {
     }
 }
 
+#[derive(Subdiagnostic)]
+#[note(mir_build_non_exhaustive_match_all_arms_guarded)]
+pub struct NonExhaustiveMatchAllArmsGuarded;
+
 #[derive(Diagnostic)]
 #[diag(mir_build_static_in_pattern, code = "E0158")]
 pub struct StaticInPattern {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -830,6 +830,11 @@ fn non_exhaustive_match<'p, 'tcx>(
             _ => " 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.subdiagnostic(NonExhaustiveMatchAllArmsGuarded);
+    }
     if let Some((span, sugg)) = suggestion {
         err.span_suggestion_verbose(span, msg, sugg, Applicability::HasPlaceholders);
     } else {
diff --git a/tests/ui/pattern/usefulness/empty-match.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-match.exhaustive_patterns.stderr
@@ -176,14 +176,15 @@ LL |     match_guarded_arm!(0u8);
    |                        ^^^ pattern `_` 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 +             _ => todo!()
    |
 
 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);
    |                        ^^^^^^^^^^^^^^^ pattern `NonEmptyStruct1` not covered
@@ -194,14 +195,15 @@ note: `NonEmptyStruct1` defined here
 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:137:24
+  --> $DIR/empty-match.rs:139:24
    |
 LL |     match_guarded_arm!(NonEmptyStruct2(true));
    |                        ^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyStruct2(_)` not covered
@@ -212,14 +214,15 @@ note: `NonEmptyStruct2` defined here
 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:141:24
+  --> $DIR/empty-match.rs:144:24
    |
 LL |     match_guarded_arm!((NonEmptyUnion1 { foo: () }));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion1 { .. }` not covered
@@ -230,14 +233,15 @@ note: `NonEmptyUnion1` defined here
 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:145:24
+  --> $DIR/empty-match.rs:149:24
    |
 LL |     match_guarded_arm!((NonEmptyUnion2 { foo: () }));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered
@@ -248,14 +252,15 @@ note: `NonEmptyUnion2` defined here
 LL | union 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
    |
 LL ~             _ if false => {},
 LL +             NonEmptyUnion2 { .. } => todo!()
    |
 
 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));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered
@@ -268,14 +273,15 @@ 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:153:24
+  --> $DIR/empty-match.rs:159:24
    |
 LL |     match_guarded_arm!(NonEmptyEnum2::Foo(true));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
@@ -291,14 +297,15 @@ LL |     Foo(bool),
 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:157:24
+  --> $DIR/empty-match.rs:164:24
    |
 LL |     match_guarded_arm!(NonEmptyEnum5::V1);
    |                        ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
@@ -309,6 +316,7 @@ note: `NonEmptyEnum5` defined here
 LL | enum 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
    |
 LL ~             _ if false => {},
diff --git a/tests/ui/pattern/usefulness/empty-match.normal.stderr b/tests/ui/pattern/usefulness/empty-match.normal.stderr
@@ -175,14 +175,15 @@ LL |     match_guarded_arm!(0u8);
    |                        ^^^ pattern `_` 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 +             _ => todo!()
    |
 
 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);
    |                        ^^^^^^^^^^^^^^^ pattern `NonEmptyStruct1` not covered
@@ -193,14 +194,15 @@ note: `NonEmptyStruct1` defined here
 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:137:24
+  --> $DIR/empty-match.rs:139:24
    |
 LL |     match_guarded_arm!(NonEmptyStruct2(true));
    |                        ^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyStruct2(_)` not covered
@@ -211,14 +213,15 @@ note: `NonEmptyStruct2` defined here
 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:141:24
+  --> $DIR/empty-match.rs:144:24
    |
 LL |     match_guarded_arm!((NonEmptyUnion1 { foo: () }));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion1 { .. }` not covered
@@ -229,14 +232,15 @@ note: `NonEmptyUnion1` defined here
 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:145:24
+  --> $DIR/empty-match.rs:149:24
    |
 LL |     match_guarded_arm!((NonEmptyUnion2 { foo: () }));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered
@@ -247,14 +251,15 @@ note: `NonEmptyUnion2` defined here
 LL | union 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
    |
 LL ~             _ if false => {},
 LL +             NonEmptyUnion2 { .. } => todo!()
    |
 
 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));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered
@@ -267,14 +272,15 @@ 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:153:24
+  --> $DIR/empty-match.rs:159:24
    |
 LL |     match_guarded_arm!(NonEmptyEnum2::Foo(true));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
@@ -290,14 +296,15 @@ LL |     Foo(bool),
 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:157:24
+  --> $DIR/empty-match.rs:164:24
    |
 LL |     match_guarded_arm!(NonEmptyEnum5::V1);
    |                        ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
@@ -308,6 +315,7 @@ note: `NonEmptyEnum5` defined here
 LL | enum 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
    |
 LL ~             _ if false => {},
diff --git a/tests/ui/pattern/usefulness/empty-match.rs b/tests/ui/pattern/usefulness/empty-match.rs
@@ -128,34 +128,42 @@ fn main() {
 
     match_guarded_arm!(0u8); //~ ERROR `_` not covered
                              //~| NOTE the matched value is of type
+                             //~| NOTE match arms with guards don't count towards exhaustivity
                              //~| NOTE pattern `_` not covered
                              //~| NOTE in this expansion of match_guarded_arm!
     match_guarded_arm!(NonEmptyStruct1); //~ ERROR `NonEmptyStruct1` not covered
                                          //~| NOTE pattern `NonEmptyStruct1` not covered
                                          //~| 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!
     match_guarded_arm!(NonEmptyStruct2(true)); //~ ERROR `NonEmptyStruct2(_)` not covered
                                                //~| NOTE the matched value is of type
                                                //~| NOTE pattern `NonEmptyStruct2(_)` not covered
+                                               //~| NOTE match arms with guards don't count towards exhaustivity
                                                //~| NOTE in this expansion of match_guarded_arm!
     match_guarded_arm!((NonEmptyUnion1 { foo: () })); //~ ERROR `NonEmptyUnion1 { .. }` not covered
                                                       //~| NOTE the matched value is of type
                                                       //~| NOTE pattern `NonEmptyUnion1 { .. }` not covered
+                                                      //~| NOTE match arms with guards don't count towards exhaustivity
                                                       //~| NOTE in this expansion of match_guarded_arm!
     match_guarded_arm!((NonEmptyUnion2 { foo: () })); //~ ERROR `NonEmptyUnion2 { .. }` not covered
                                                       //~| NOTE the matched value is of type
                                                       //~| NOTE pattern `NonEmptyUnion2 { .. }` not covered
+                                                      //~| NOTE match arms with guards don't count towards exhaustivity
                                                       //~| NOTE in this expansion of match_guarded_arm!
     match_guarded_arm!(NonEmptyEnum1::Foo(true)); //~ ERROR `NonEmptyEnum1::Foo(_)` not covered
                                                   //~| NOTE the matched value is of type
                                                   //~| NOTE pattern `NonEmptyEnum1::Foo(_)` not covered
+                                                  //~| NOTE match arms with guards don't count towards exhaustivity
                                                   //~| NOTE in this expansion of match_guarded_arm!
     match_guarded_arm!(NonEmptyEnum2::Foo(true)); //~ ERROR `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
                                                   //~| NOTE the matched value is of type
                                                   //~| NOTE patterns `NonEmptyEnum2::Foo(_)` and
+                                                  //~| NOTE match arms with guards don't count towards exhaustivity
                                                   //~| 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
                                            //~| NOTE the matched value is of type
                                            //~| NOTE patterns `NonEmptyEnum5::V1`,
+                                           //~| NOTE match arms with guards don't count towards exhaustivity
                                            //~| NOTE in this expansion of match_guarded_arm!
 }
diff --git a/tests/ui/pattern/usefulness/issue-3601.rs b/tests/ui/pattern/usefulness/issue-3601.rs
@@ -1,19 +1,19 @@
 #![feature(box_patterns)]
 
 struct HTMLImageData {
-    image: Option<String>
+    image: Option<String>,
 }
 
 struct ElementData {
-    kind: Box<ElementKind>
+    kind: Box<ElementKind>,
 }
 
 enum ElementKind {
-    HTMLImageElement(HTMLImageData)
+    HTMLImageElement(HTMLImageData),
 }
 
 enum NodeKind {
-    Element(ElementData)
+    Element(ElementData),
 }
 
 struct NodeData {
@@ -27,8 +27,13 @@ fn main() {
 
     // n.b. span could be better
     match n.kind {
-        box NodeKind::Element(ed) => match ed.kind { //~ ERROR non-exhaustive patterns
-            box ElementKind::HTMLImageElement(ref d) if d.image.is_some() => { true }
+        box NodeKind::Element(ed) => match ed.kind {
+            //~^ 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,
         },
     };
 }
diff --git a/tests/ui/pattern/usefulness/issue-3601.stderr b/tests/ui/pattern/usefulness/issue-3601.stderr
@@ -7,10 +7,11 @@ LL |         box NodeKind::Element(ed) => match ed.kind {
 note: `Box<ElementKind>` defined here
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
    = 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
    |
-LL ~             box ElementKind::HTMLImageElement(ref d) if d.image.is_some() => { true },
-LL +             box _ => todo!()
+LL ~             box ElementKind::HTMLImageElement(ref d) if d.image.is_some() => true,
+LL ~             box _ => todo!(),
    |
 
 error: aborting due to previous error
diff --git a/tests/ui/pattern/usefulness/match-non-exhaustive.rs b/tests/ui/pattern/usefulness/match-non-exhaustive.rs
@@ -1,4 +1,5 @@
 fn main() {
     match 0 { 1 => () } //~ ERROR non-exhaustive patterns
     match 0 { 0 if false => () } //~ ERROR non-exhaustive patterns
+    //-| NOTE match arms with guards don't count towards exhaustivity
 }
diff --git a/tests/ui/pattern/usefulness/match-non-exhaustive.stderr b/tests/ui/pattern/usefulness/match-non-exhaustive.stderr
@@ -17,6 +17,7 @@ LL |     match 0 { 0 if false => () }
    |           ^ pattern `_` not covered
    |
    = 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
    |
 LL |     match 0 { 0 if false => (), _ => todo!() }

Original file line number	Diff line number	Diff line change
`@@ -432,6 +432,10 @@ impl<'a> IntoDiagnostic<'a> for NonExhaustivePatternsTypeNotEmpty<'_, '_, '_> {`
`432`	`432`	`}`
`433`	`433`	`}`
`434`	`434`
	`435`	`+#[derive(Subdiagnostic)]`
	`436`	`+#[note(mir_build_non_exhaustive_match_all_arms_guarded)]`
	`437`	`+pub struct NonExhaustiveMatchAllArmsGuarded;`
	`438`	`+`
`435`	`439`	`#[derive(Diagnostic)]`
`436`	`440`	`#[diag(mir_build_static_in_pattern, code = "E0158")]`
`437`	`441`	`pub struct StaticInPattern {`
Original file line number	Diff line number	Diff line change
`@@ -176,14 +176,15 @@ LL \| match_guarded_arm!(0u8);`
`176`	`176`	\| ^^^ pattern `_` not covered
`177`	`177`	`\|`
`178`	`178`	= note: the matched value is of type `u8`
	`179`	`+ = note: match arms with guards don't count towards exhaustivity`
`179`	`180`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`180`	`181`	`\|`
`181`	`182`	`LL ~ _ if false => {},`
`182`	`183`	`LL + _ => todo!()`
`183`	`184`	`\|`
`184`	`185`
`185`	`186`	error[E0004]: non-exhaustive patterns: `NonEmptyStruct1` not covered
`186`		`- --> $DIR/empty-match.rs:133:24`
	`187`	`+ --> $DIR/empty-match.rs:134:24`
`187`	`188`	`\|`
`188`	`189`	`LL \| match_guarded_arm!(NonEmptyStruct1);`
`189`	`190`	\| ^^^^^^^^^^^^^^^ pattern `NonEmptyStruct1` not covered
@@ -194,14 +195,15 @@ note: `NonEmptyStruct1` defined here
`194`	`195`	`LL \| struct NonEmptyStruct1;`
`195`	`196`	`\| ^^^^^^^^^^^^^^^`
`196`	`197`	= note: the matched value is of type `NonEmptyStruct1`
	`198`	`+ = note: match arms with guards don't count towards exhaustivity`
`197`	`199`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`198`	`200`	`\|`
`199`	`201`	`LL ~ _ if false => {},`
`200`	`202`	`LL + NonEmptyStruct1 => todo!()`
`201`	`203`	`\|`
`202`	`204`
`203`	`205`	error[E0004]: non-exhaustive patterns: `NonEmptyStruct2(_)` not covered
`204`		`- --> $DIR/empty-match.rs:137:24`
	`206`	`+ --> $DIR/empty-match.rs:139:24`
`205`	`207`	`\|`
`206`	`208`	`LL \| match_guarded_arm!(NonEmptyStruct2(true));`
`207`	`209`	\| ^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyStruct2(_)` not covered
@@ -212,14 +214,15 @@ note: `NonEmptyStruct2` defined here
`212`	`214`	`LL \| struct NonEmptyStruct2(bool);`
`213`	`215`	`\| ^^^^^^^^^^^^^^^`
`214`	`216`	= note: the matched value is of type `NonEmptyStruct2`
	`217`	`+ = note: match arms with guards don't count towards exhaustivity`
`215`	`218`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`216`	`219`	`\|`
`217`	`220`	`LL ~ _ if false => {},`
`218`	`221`	`LL + NonEmptyStruct2(_) => todo!()`
`219`	`222`	`\|`
`220`	`223`
`221`	`224`	error[E0004]: non-exhaustive patterns: `NonEmptyUnion1 { .. }` not covered
`222`		`- --> $DIR/empty-match.rs:141:24`
	`225`	`+ --> $DIR/empty-match.rs:144:24`
`223`	`226`	`\|`
`224`	`227`	`LL \| match_guarded_arm!((NonEmptyUnion1 { foo: () }));`
`225`	`228`	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion1 { .. }` not covered
@@ -230,14 +233,15 @@ note: `NonEmptyUnion1` defined here
`230`	`233`	`LL \| union NonEmptyUnion1 {`
`231`	`234`	`\| ^^^^^^^^^^^^^^`
`232`	`235`	= note: the matched value is of type `NonEmptyUnion1`
	`236`	`+ = note: match arms with guards don't count towards exhaustivity`
`233`	`237`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`234`	`238`	`\|`
`235`	`239`	`LL ~ _ if false => {},`
`236`	`240`	`LL + NonEmptyUnion1 { .. } => todo!()`
`237`	`241`	`\|`
`238`	`242`
`239`	`243`	error[E0004]: non-exhaustive patterns: `NonEmptyUnion2 { .. }` not covered
`240`		`- --> $DIR/empty-match.rs:145:24`
	`244`	`+ --> $DIR/empty-match.rs:149:24`
`241`	`245`	`\|`
`242`	`246`	`LL \| match_guarded_arm!((NonEmptyUnion2 { foo: () }));`
`243`	`247`	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered
@@ -248,14 +252,15 @@ note: `NonEmptyUnion2` defined here
`248`	`252`	`LL \| union NonEmptyUnion2 {`
`249`	`253`	`\| ^^^^^^^^^^^^^^`
`250`	`254`	= note: the matched value is of type `NonEmptyUnion2`
	`255`	`+ = note: match arms with guards don't count towards exhaustivity`
`251`	`256`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`252`	`257`	`\|`
`253`	`258`	`LL ~ _ if false => {},`
`254`	`259`	`LL + NonEmptyUnion2 { .. } => todo!()`
`255`	`260`	`\|`
`256`	`261`
`257`	`262`	error[E0004]: non-exhaustive patterns: `NonEmptyEnum1::Foo(_)` not covered
`258`		`- --> $DIR/empty-match.rs:149:24`
	`263`	`+ --> $DIR/empty-match.rs:154:24`
`259`	`264`	`\|`
`260`	`265`	`LL \| match_guarded_arm!(NonEmptyEnum1::Foo(true));`
`261`	`266`	\| ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered
`@@ -268,14 +273,15 @@ LL \| enum NonEmptyEnum1 {`
`268`	`273`	`LL \| Foo(bool),`
`269`	`274`	`\| ^^^ not covered`
`270`	`275`	= note: the matched value is of type `NonEmptyEnum1`
	`276`	`+ = note: match arms with guards don't count towards exhaustivity`
`271`	`277`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`272`	`278`	`\|`
`273`	`279`	`LL ~ _ if false => {},`
`274`	`280`	`LL + NonEmptyEnum1::Foo(_) => todo!()`
`275`	`281`	`\|`
`276`	`282`
`277`	`283`	error[E0004]: non-exhaustive patterns: `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
`278`		`- --> $DIR/empty-match.rs:153:24`
	`284`	`+ --> $DIR/empty-match.rs:159:24`
`279`	`285`	`\|`
`280`	`286`	`LL \| match_guarded_arm!(NonEmptyEnum2::Foo(true));`
`281`	`287`	\| ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
`@@ -291,14 +297,15 @@ LL \| Foo(bool),`
`291`	`297`	`LL \| Bar,`
`292`	`298`	`\| ^^^ not covered`
`293`	`299`	= note: the matched value is of type `NonEmptyEnum2`
	`300`	`+ = note: match arms with guards don't count towards exhaustivity`
`294`	`301`	`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`
`295`	`302`	`\|`
`296`	`303`	`LL ~ _ if false => {},`
`297`	`304`	`LL + NonEmptyEnum2::Foo(_) \| NonEmptyEnum2::Bar => todo!()`
`298`	`305`	`\|`
`299`	`306`
`300`	`307`	error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
`301`		`- --> $DIR/empty-match.rs:157:24`
	`308`	`+ --> $DIR/empty-match.rs:164:24`
`302`	`309`	`\|`
`303`	`310`	`LL \| match_guarded_arm!(NonEmptyEnum5::V1);`
`304`	`311`	\| ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
@@ -309,6 +316,7 @@ note: `NonEmptyEnum5` defined here
`309`	`316`	`LL \| enum NonEmptyEnum5 {`
`310`	`317`	`\| ^^^^^^^^^^^^^`
`311`	`318`	= note: the matched value is of type `NonEmptyEnum5`
	`319`	`+ = note: match arms with guards don't count towards exhaustivity`
`312`	`320`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown, or multiple match arms`
`313`	`321`	`\|`
`314`	`322`	`LL ~ _ if false => {},`
Original file line number	Diff line number	Diff line change
`@@ -175,14 +175,15 @@ LL \| match_guarded_arm!(0u8);`
`175`	`175`	\| ^^^ pattern `_` not covered
`176`	`176`	`\|`
`177`	`177`	= note: the matched value is of type `u8`
	`178`	`+ = note: match arms with guards don't count towards exhaustivity`
`178`	`179`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`179`	`180`	`\|`
`180`	`181`	`LL ~ _ if false => {},`
`181`	`182`	`LL + _ => todo!()`
`182`	`183`	`\|`
`183`	`184`
`184`	`185`	error[E0004]: non-exhaustive patterns: `NonEmptyStruct1` not covered
`185`		`- --> $DIR/empty-match.rs:133:24`
	`186`	`+ --> $DIR/empty-match.rs:134:24`
`186`	`187`	`\|`
`187`	`188`	`LL \| match_guarded_arm!(NonEmptyStruct1);`
`188`	`189`	\| ^^^^^^^^^^^^^^^ pattern `NonEmptyStruct1` not covered
@@ -193,14 +194,15 @@ note: `NonEmptyStruct1` defined here
`193`	`194`	`LL \| struct NonEmptyStruct1;`
`194`	`195`	`\| ^^^^^^^^^^^^^^^`
`195`	`196`	= note: the matched value is of type `NonEmptyStruct1`
	`197`	`+ = note: match arms with guards don't count towards exhaustivity`
`196`	`198`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`197`	`199`	`\|`
`198`	`200`	`LL ~ _ if false => {},`
`199`	`201`	`LL + NonEmptyStruct1 => todo!()`
`200`	`202`	`\|`
`201`	`203`
`202`	`204`	error[E0004]: non-exhaustive patterns: `NonEmptyStruct2(_)` not covered
`203`		`- --> $DIR/empty-match.rs:137:24`
	`205`	`+ --> $DIR/empty-match.rs:139:24`
`204`	`206`	`\|`
`205`	`207`	`LL \| match_guarded_arm!(NonEmptyStruct2(true));`
`206`	`208`	\| ^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyStruct2(_)` not covered
@@ -211,14 +213,15 @@ note: `NonEmptyStruct2` defined here
`211`	`213`	`LL \| struct NonEmptyStruct2(bool);`
`212`	`214`	`\| ^^^^^^^^^^^^^^^`
`213`	`215`	= note: the matched value is of type `NonEmptyStruct2`
	`216`	`+ = note: match arms with guards don't count towards exhaustivity`
`214`	`217`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`215`	`218`	`\|`
`216`	`219`	`LL ~ _ if false => {},`
`217`	`220`	`LL + NonEmptyStruct2(_) => todo!()`
`218`	`221`	`\|`
`219`	`222`
`220`	`223`	error[E0004]: non-exhaustive patterns: `NonEmptyUnion1 { .. }` not covered
`221`		`- --> $DIR/empty-match.rs:141:24`
	`224`	`+ --> $DIR/empty-match.rs:144:24`
`222`	`225`	`\|`
`223`	`226`	`LL \| match_guarded_arm!((NonEmptyUnion1 { foo: () }));`
`224`	`227`	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion1 { .. }` not covered
@@ -229,14 +232,15 @@ note: `NonEmptyUnion1` defined here
`229`	`232`	`LL \| union NonEmptyUnion1 {`
`230`	`233`	`\| ^^^^^^^^^^^^^^`
`231`	`234`	= note: the matched value is of type `NonEmptyUnion1`
	`235`	`+ = note: match arms with guards don't count towards exhaustivity`
`232`	`236`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`233`	`237`	`\|`
`234`	`238`	`LL ~ _ if false => {},`
`235`	`239`	`LL + NonEmptyUnion1 { .. } => todo!()`
`236`	`240`	`\|`
`237`	`241`
`238`	`242`	error[E0004]: non-exhaustive patterns: `NonEmptyUnion2 { .. }` not covered
`239`		`- --> $DIR/empty-match.rs:145:24`
	`243`	`+ --> $DIR/empty-match.rs:149:24`
`240`	`244`	`\|`
`241`	`245`	`LL \| match_guarded_arm!((NonEmptyUnion2 { foo: () }));`
`242`	`246`	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyUnion2 { .. }` not covered
@@ -247,14 +251,15 @@ note: `NonEmptyUnion2` defined here
`247`	`251`	`LL \| union NonEmptyUnion2 {`
`248`	`252`	`\| ^^^^^^^^^^^^^^`
`249`	`253`	= note: the matched value is of type `NonEmptyUnion2`
	`254`	`+ = note: match arms with guards don't count towards exhaustivity`
`250`	`255`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`251`	`256`	`\|`
`252`	`257`	`LL ~ _ if false => {},`
`253`	`258`	`LL + NonEmptyUnion2 { .. } => todo!()`
`254`	`259`	`\|`
`255`	`260`
`256`	`261`	error[E0004]: non-exhaustive patterns: `NonEmptyEnum1::Foo(_)` not covered
`257`		`- --> $DIR/empty-match.rs:149:24`
	`262`	`+ --> $DIR/empty-match.rs:154:24`
`258`	`263`	`\|`
`259`	`264`	`LL \| match_guarded_arm!(NonEmptyEnum1::Foo(true));`
`260`	`265`	\| ^^^^^^^^^^^^^^^^^^^^^^^^ pattern `NonEmptyEnum1::Foo(_)` not covered
`@@ -267,14 +272,15 @@ LL \| enum NonEmptyEnum1 {`
`267`	`272`	`LL \| Foo(bool),`
`268`	`273`	`\| ^^^ not covered`
`269`	`274`	= note: the matched value is of type `NonEmptyEnum1`
	`275`	`+ = note: match arms with guards don't count towards exhaustivity`
`270`	`276`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`271`	`277`	`\|`
`272`	`278`	`LL ~ _ if false => {},`
`273`	`279`	`LL + NonEmptyEnum1::Foo(_) => todo!()`
`274`	`280`	`\|`
`275`	`281`
`276`	`282`	error[E0004]: non-exhaustive patterns: `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
`277`		`- --> $DIR/empty-match.rs:153:24`
	`283`	`+ --> $DIR/empty-match.rs:159:24`
`278`	`284`	`\|`
`279`	`285`	`LL \| match_guarded_arm!(NonEmptyEnum2::Foo(true));`
`280`	`286`	\| ^^^^^^^^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum2::Foo(_)` and `NonEmptyEnum2::Bar` not covered
`@@ -290,14 +296,15 @@ LL \| Foo(bool),`
`290`	`296`	`LL \| Bar,`
`291`	`297`	`\| ^^^ not covered`
`292`	`298`	= note: the matched value is of type `NonEmptyEnum2`
	`299`	`+ = note: match arms with guards don't count towards exhaustivity`
`293`	`300`	`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`
`294`	`301`	`\|`
`295`	`302`	`LL ~ _ if false => {},`
`296`	`303`	`LL + NonEmptyEnum2::Foo(_) \| NonEmptyEnum2::Bar => todo!()`
`297`	`304`	`\|`
`298`	`305`
`299`	`306`	error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
`300`		`- --> $DIR/empty-match.rs:157:24`
	`307`	`+ --> $DIR/empty-match.rs:164:24`
`301`	`308`	`\|`
`302`	`309`	`LL \| match_guarded_arm!(NonEmptyEnum5::V1);`
`303`	`310`	\| ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
@@ -308,6 +315,7 @@ note: `NonEmptyEnum5` defined here
`308`	`315`	`LL \| enum NonEmptyEnum5 {`
`309`	`316`	`\| ^^^^^^^^^^^^^`
`310`	`317`	= note: the matched value is of type `NonEmptyEnum5`
	`318`	`+ = note: match arms with guards don't count towards exhaustivity`
`311`	`319`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown, or multiple match arms`
`312`	`320`	`\|`
`313`	`321`	`LL ~ _ if false => {},`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,11 @@ LL \| box NodeKind::Element(ed) => match ed.kind {`
`7`	`7`	note: `Box<ElementKind>` defined here
`8`	`8`	`--> $SRC_DIR/alloc/src/boxed.rs:LL:COL`
`9`	`9`	= note: the matched value is of type `Box<ElementKind>`
	`10`	`+ = note: match arms with guards don't count towards exhaustivity`
`10`	`11`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`11`	`12`	`\|`
`12`		`-LL ~ box ElementKind::HTMLImageElement(ref d) if d.image.is_some() => { true },`
`13`		`-LL + box _ => todo!()`
	`13`	`+LL ~ box ElementKind::HTMLImageElement(ref d) if d.image.is_some() => true,`
	`14`	`+LL ~ box _ => todo!(),`
`14`	`15`	`\|`
`15`	`16`
`16`	`17`	`error: aborting due to previous error`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`fn main() {`
`2`	`2`	`match 0 { 1 => () } //~ ERROR non-exhaustive patterns`
`3`	`3`	`match 0 { 0 if false => () } //~ ERROR non-exhaustive patterns`
	`4`	`+ //-\| NOTE match arms with guards don't count towards exhaustivity`
`4`	`5`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ LL \| match 0 { 0 if false => () }`
`17`	`17`	\| ^ pattern `_` not covered
`18`	`18`	`\|`
`19`	`19`	= note: the matched value is of type `i32`
	`20`	`+ = note: match arms with guards don't count towards exhaustivity`
`20`	`21`	`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
`21`	`22`	`\|`
`22`	`23`	`LL \| match 0 { 0 if false => (), _ => todo!() }`