From 6e85f467c59e7ae943404a2aee9cc83ee475cf23 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Thu, 21 Nov 2019 18:45:28 +0000 Subject: [PATCH 1/6] Initial implementation of or-pattern usefulness checking --- src/librustc_mir/hair/pattern/_match.rs | 60 +++++++++++++++++++------ src/test/compile-fail/or-patterns.rs | 45 +++++++++++++++++++ 2 files changed, 91 insertions(+), 14 deletions(-) create mode 100644 src/test/compile-fail/or-patterns.rs diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs index 5e7a7f01e7a32..7d3bbbc1ee4fa 100644 --- a/src/librustc_mir/hair/pattern/_match.rs +++ b/src/librustc_mir/hair/pattern/_match.rs @@ -399,6 +399,25 @@ impl<'p, 'tcx> PatStack<'p, 'tcx> { self.0.iter().map(|p| *p) } + // If the first pattern is an or-pattern, expand this pattern. Otherwise, return `None`. + fn expand_or_pat(&self) -> Option>> { + if self.is_empty() { + None + } else if let PatKind::Or { pats } = &*self.head().kind { + Some( + pats.iter() + .map(|pat| { + let mut new_patstack = PatStack::from_pattern(pat); + new_patstack.0.extend_from_slice(&self.0[1..]); + new_patstack + }) + .collect(), + ) + } else { + None + } + } + /// This computes `D(self)`. See top of the file for explanations. fn specialize_wildcard(&self) -> Option { if self.head().is_wildcard() { Some(self.to_tail()) } else { None } @@ -446,8 +465,13 @@ impl<'p, 'tcx> Matrix<'p, 'tcx> { Matrix(vec![]) } + /// Pushes a new row to the matrix. If the row starts with an or-pattern, this expands it. pub fn push(&mut self, row: PatStack<'p, 'tcx>) { - self.0.push(row) + if let Some(rows) = row.expand_or_pat() { + self.0.extend(rows); + } else { + self.0.push(row); + } } /// Iterate over the first component of each row @@ -471,12 +495,10 @@ impl<'p, 'tcx> Matrix<'p, 'tcx> { 'a: 'q, 'p: 'q, { - Matrix( - self.0 - .iter() - .filter_map(|r| r.specialize_constructor(cx, constructor, ctor_wild_subpatterns)) - .collect(), - ) + self.0 + .iter() + .filter_map(|r| r.specialize_constructor(cx, constructor, ctor_wild_subpatterns)) + .collect() } } @@ -528,7 +550,12 @@ impl<'p, 'tcx> FromIterator> for Matrix<'p, 'tcx> { where T: IntoIterator>, { - Matrix(iter.into_iter().collect()) + let mut matrix = Matrix::empty(); + for x in iter { + // Using `push` ensures we correctly expand or-patterns. + matrix.push(x); + } + matrix } } @@ -1601,6 +1628,15 @@ pub fn is_useful<'p, 'a, 'tcx>( assert!(rows.iter().all(|r| r.len() == v.len())); + // If the first pattern is an or-pattern, expand it. + if let Some(vs) = v.expand_or_pat() { + return vs + .into_iter() + .map(|v| is_useful(cx, matrix, &v, witness_preference, hir_id)) + .find(|result| result.is_useful()) + .unwrap_or(NotUseful); + } + let (ty, span) = matrix .heads() .map(|r| (r.ty, r.span)) @@ -1802,9 +1838,7 @@ fn pat_constructor<'tcx>( if slice.is_some() { VarLen(prefix, suffix) } else { FixedLen(prefix + suffix) }; Some(Slice(Slice { array_len, kind })) } - PatKind::Or { .. } => { - bug!("support for or-patterns has not been fully implemented yet."); - } + PatKind::Or { .. } => bug!(), // Should have been expanded earlier on. } } @@ -2410,9 +2444,7 @@ fn specialize_one_pattern<'p, 'a: 'p, 'q: 'p, 'tcx>( _ => span_bug!(pat.span, "unexpected ctor {:?} for slice pat", constructor), }, - PatKind::Or { .. } => { - bug!("support for or-patterns has not been fully implemented yet."); - } + PatKind::Or { .. } => bug!(), // Should have been expanded earlier on. }; debug!("specialize({:#?}, {:#?}) = {:#?}", pat, ctor_wild_subpatterns, result); diff --git a/src/test/compile-fail/or-patterns.rs b/src/test/compile-fail/or-patterns.rs new file mode 100644 index 0000000000000..e1b5dce852d5f --- /dev/null +++ b/src/test/compile-fail/or-patterns.rs @@ -0,0 +1,45 @@ +// should-ice +#![allow(incomplete_features)] +#![feature(or_patterns)] +#![deny(unreachable_patterns)] + +// The ice will get removed once or-patterns are correctly implemented +fn main() { + // We wrap patterns in a tuple because top-level or-patterns are special-cased for now. + match (0u8,) { + (1 | 2,) => {} + //~^ ERROR simplifyable pattern found + // This above is the ICE error message + _ => {} + } + + match (0u8,) { + (1 | 2,) => {} + (1,) => {} //~ ERROR unreachable pattern + _ => {} + } + match (0u8,) { + (1 | 2,) => {} + (2,) => {} //~ ERROR unreachable pattern + _ => {} + } + match (0u8,) { + (1,) => {} + (2,) => {} + (1 | 2,) => {} //~ ERROR unreachable pattern + _ => {} + } + match (0u8,) { + (1 | 1,) => {} // redundancy not detected for now + _ => {} + } + match (0u8, 0u8) { + (1 | 2, 3 | 4) => {} + (1, 2) => {} + (1, 3) => {} //~ ERROR unreachable pattern + (1, 4) => {} //~ ERROR unreachable pattern + (2, 4) => {} //~ ERROR unreachable pattern + (2 | 1, 4) => {} //~ ERROR unreachable pattern + _ => {} + } +} From 0030a777f286bbbd938b9cc4f0b559843fffd37a Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Thu, 21 Nov 2019 19:06:49 +0000 Subject: [PATCH 2/6] Add some more tests --- src/test/compile-fail/or-patterns.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/test/compile-fail/or-patterns.rs b/src/test/compile-fail/or-patterns.rs index e1b5dce852d5f..fb243f2432851 100644 --- a/src/test/compile-fail/or-patterns.rs +++ b/src/test/compile-fail/or-patterns.rs @@ -42,4 +42,15 @@ fn main() { (2 | 1, 4) => {} //~ ERROR unreachable pattern _ => {} } + match (Some(0u8),) { + (None | Some(1 | 2),) => {} + (Some(1),) => {} //~ ERROR unreachable pattern + (None,) => {} //~ ERROR unreachable pattern + (Some(_),) => {} + } + match ((0u8,),) { + ((1 | 2,) | (3 | 4,),) => {}, + ((1..=4,),) => {}, //~ ERROR unreachable pattern + ((_,),) => {}, + } } From b5ec4d11835d16167ee48bb6e3cf7e8347f367e1 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Mon, 25 Nov 2019 18:23:09 +0000 Subject: [PATCH 3/6] Address reviews --- src/librustc_mir/hair/pattern/_match.rs | 6 +++--- src/test/compile-fail/or-patterns.rs | 7 ++++++- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs index 7d3bbbc1ee4fa..2e339b1eb885d 100644 --- a/src/librustc_mir/hair/pattern/_match.rs +++ b/src/librustc_mir/hair/pattern/_match.rs @@ -400,7 +400,7 @@ impl<'p, 'tcx> PatStack<'p, 'tcx> { } // If the first pattern is an or-pattern, expand this pattern. Otherwise, return `None`. - fn expand_or_pat(&self) -> Option>> { + fn expand_or_pat(&self) -> Option> { if self.is_empty() { None } else if let PatKind::Or { pats } = &*self.head().kind { @@ -1838,7 +1838,7 @@ fn pat_constructor<'tcx>( if slice.is_some() { VarLen(prefix, suffix) } else { FixedLen(prefix + suffix) }; Some(Slice(Slice { array_len, kind })) } - PatKind::Or { .. } => bug!(), // Should have been expanded earlier on. + PatKind::Or { .. } => bug!("Or-pattern hould have been expanded earlier on."), } } @@ -2444,7 +2444,7 @@ fn specialize_one_pattern<'p, 'a: 'p, 'q: 'p, 'tcx>( _ => span_bug!(pat.span, "unexpected ctor {:?} for slice pat", constructor), }, - PatKind::Or { .. } => bug!(), // Should have been expanded earlier on. + PatKind::Or { .. } => bug!("Or-pattern hould have been expanded earlier on."), }; debug!("specialize({:#?}, {:#?}) = {:#?}", pat, ctor_wild_subpatterns, result); diff --git a/src/test/compile-fail/or-patterns.rs b/src/test/compile-fail/or-patterns.rs index fb243f2432851..ba8427045e319 100644 --- a/src/test/compile-fail/or-patterns.rs +++ b/src/test/compile-fail/or-patterns.rs @@ -1,6 +1,7 @@ // should-ice -#![allow(incomplete_features)] #![feature(or_patterns)] +#![feature(slice_patterns)] +#![allow(incomplete_features)] #![deny(unreachable_patterns)] // The ice will get removed once or-patterns are correctly implemented @@ -53,4 +54,8 @@ fn main() { ((1..=4,),) => {}, //~ ERROR unreachable pattern ((_,),) => {}, } + match (&[0u8][..],) { + ([] | [0 | 1..=255] | [_, ..],) => {}, + (_,) => {}, //~ ERROR unreachable pattern + } } From cdc844e81f186c62e9368a24e3b8edba1ef6143b Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 26 Nov 2019 14:32:47 +0000 Subject: [PATCH 4/6] Make the ice a fatal error --- src/librustc_mir/build/matches/test.rs | 8 +++++++- src/test/compile-fail/or-patterns.rs | 11 +++++++---- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/src/librustc_mir/build/matches/test.rs b/src/librustc_mir/build/matches/test.rs index 5c2f72c0a061f..f534c2a347cda 100644 --- a/src/librustc_mir/build/matches/test.rs +++ b/src/librustc_mir/build/matches/test.rs @@ -84,10 +84,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { } } + PatKind::Or { .. } => { + self.hir.tcx().sess.span_fatal( + match_pair.pattern.span, + "or-patterns are not fully implemented yet" + ) + } + PatKind::AscribeUserType { .. } | PatKind::Array { .. } | PatKind::Wild | - PatKind::Or { .. } | PatKind::Binding { .. } | PatKind::Leaf { .. } | PatKind::Deref { .. } => { diff --git a/src/test/compile-fail/or-patterns.rs b/src/test/compile-fail/or-patterns.rs index ba8427045e319..118090c9eb291 100644 --- a/src/test/compile-fail/or-patterns.rs +++ b/src/test/compile-fail/or-patterns.rs @@ -1,16 +1,19 @@ -// should-ice #![feature(or_patterns)] #![feature(slice_patterns)] #![allow(incomplete_features)] #![deny(unreachable_patterns)] -// The ice will get removed once or-patterns are correctly implemented fn main() { // We wrap patterns in a tuple because top-level or-patterns are special-cased for now. + + // Get the fatal error out of the way + match (0u8,) { + (0 | _,) => {} + //~^ ERROR or-patterns are not fully implemented yet + } + match (0u8,) { (1 | 2,) => {} - //~^ ERROR simplifyable pattern found - // This above is the ICE error message _ => {} } From 0881750173d714770713f989332464eb5498574e Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 26 Nov 2019 14:53:54 +0000 Subject: [PATCH 5/6] Move tests to ui, split them and add some --- .../exhaustiveness-non-exhaustive.rs | 26 ++++++ .../exhaustiveness-non-exhaustive.stderr | 33 ++++++++ .../ui/or-patterns/exhaustiveness-pass.rs | 40 ++++++++++ .../ui/or-patterns/exhaustiveness-pass.stderr | 8 ++ .../exhaustiveness-unreachable-pattern.rs} | 23 ++---- .../exhaustiveness-unreachable-pattern.stderr | 80 +++++++++++++++++++ 6 files changed, 192 insertions(+), 18 deletions(-) create mode 100644 src/test/ui/or-patterns/exhaustiveness-non-exhaustive.rs create mode 100644 src/test/ui/or-patterns/exhaustiveness-non-exhaustive.stderr create mode 100644 src/test/ui/or-patterns/exhaustiveness-pass.rs create mode 100644 src/test/ui/or-patterns/exhaustiveness-pass.stderr rename src/test/{compile-fail/or-patterns.rs => ui/or-patterns/exhaustiveness-unreachable-pattern.rs} (73%) create mode 100644 src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr diff --git a/src/test/ui/or-patterns/exhaustiveness-non-exhaustive.rs b/src/test/ui/or-patterns/exhaustiveness-non-exhaustive.rs new file mode 100644 index 0000000000000..d7c191bb5a28d --- /dev/null +++ b/src/test/ui/or-patterns/exhaustiveness-non-exhaustive.rs @@ -0,0 +1,26 @@ +#![feature(or_patterns)] +#![feature(slice_patterns)] +#![allow(incomplete_features)] +#![deny(unreachable_patterns)] + +// We wrap patterns in a tuple because top-level or-patterns are special-cased for now. +fn main() { + // Get the fatal error out of the way + match (0u8,) { + (0 | _,) => {} + //~^ ERROR or-patterns are not fully implemented yet + } + + match (0u8, 0u8) { + //~^ ERROR non-exhaustive patterns: `(2u8..=std::u8::MAX, _)` + (0 | 1, 2 | 3) => {} + } + match ((0u8,),) { + //~^ ERROR non-exhaustive patterns: `((4u8..=std::u8::MAX))` + ((0 | 1,) | (2 | 3,),) => {}, + } + match (Some(0u8),) { + //~^ ERROR non-exhaustive patterns: `(Some(2u8..=std::u8::MAX))` + (None | Some(0 | 1),) => {} + } +} diff --git a/src/test/ui/or-patterns/exhaustiveness-non-exhaustive.stderr b/src/test/ui/or-patterns/exhaustiveness-non-exhaustive.stderr new file mode 100644 index 0000000000000..e6aa157d278c8 --- /dev/null +++ b/src/test/ui/or-patterns/exhaustiveness-non-exhaustive.stderr @@ -0,0 +1,33 @@ +error[E0004]: non-exhaustive patterns: `(2u8..=std::u8::MAX, _)` not covered + --> $DIR/exhaustiveness-non-exhaustive.rs:14:11 + | +LL | match (0u8, 0u8) { + | ^^^^^^^^^^ pattern `(2u8..=std::u8::MAX, _)` not covered + | + = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms + +error[E0004]: non-exhaustive patterns: `((4u8..=std::u8::MAX))` not covered + --> $DIR/exhaustiveness-non-exhaustive.rs:18:11 + | +LL | match ((0u8,),) { + | ^^^^^^^^^ pattern `((4u8..=std::u8::MAX))` not covered + | + = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms + +error[E0004]: non-exhaustive patterns: `(Some(2u8..=std::u8::MAX))` not covered + --> $DIR/exhaustiveness-non-exhaustive.rs:22:11 + | +LL | match (Some(0u8),) { + | ^^^^^^^^^^^^ pattern `(Some(2u8..=std::u8::MAX))` not covered + | + = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms + +error: or-patterns are not fully implemented yet + --> $DIR/exhaustiveness-non-exhaustive.rs:10:10 + | +LL | (0 | _,) => {} + | ^^^^^ + +error: aborting due to 4 previous errors + +For more information about this error, try `rustc --explain E0004`. diff --git a/src/test/ui/or-patterns/exhaustiveness-pass.rs b/src/test/ui/or-patterns/exhaustiveness-pass.rs new file mode 100644 index 0000000000000..a29cc7253ad58 --- /dev/null +++ b/src/test/ui/or-patterns/exhaustiveness-pass.rs @@ -0,0 +1,40 @@ +#![feature(or_patterns)] +#![feature(slice_patterns)] +#![allow(incomplete_features)] +#![deny(unreachable_patterns)] + +// We wrap patterns in a tuple because top-level or-patterns are special-cased for now. +fn main() { + // Get the fatal error out of the way + match (0u8,) { + (0 | _,) => {} + //~^ ERROR or-patterns are not fully implemented yet + } + + match (0u8,) { + (1 | 2,) => {} + _ => {} + } + + match (0u8,) { + (1 | 1,) => {} // redundancy not detected for now + _ => {} + } + match (0u8, 0u8) { + (1 | 2, 3 | 4) => {} + (1, 2) => {} + (2, 1) => {} + _ => {} + } + match (Some(0u8),) { + (None | Some(0 | 1),) => {} + (Some(2..=255),) => {} + } + match ((0u8,),) { + ((0 | 1,) | (2 | 3,),) => {}, + ((_,),) => {}, + } + match (&[0u8][..],) { + ([] | [0 | 1..=255] | [_, ..],) => {}, + } +} diff --git a/src/test/ui/or-patterns/exhaustiveness-pass.stderr b/src/test/ui/or-patterns/exhaustiveness-pass.stderr new file mode 100644 index 0000000000000..1f4278c4b8098 --- /dev/null +++ b/src/test/ui/or-patterns/exhaustiveness-pass.stderr @@ -0,0 +1,8 @@ +error: or-patterns are not fully implemented yet + --> $DIR/exhaustiveness-pass.rs:10:10 + | +LL | (0 | _,) => {} + | ^^^^^ + +error: aborting due to previous error + diff --git a/src/test/compile-fail/or-patterns.rs b/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.rs similarity index 73% rename from src/test/compile-fail/or-patterns.rs rename to src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.rs index 118090c9eb291..2cd8ca2dbac62 100644 --- a/src/test/compile-fail/or-patterns.rs +++ b/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.rs @@ -3,20 +3,14 @@ #![allow(incomplete_features)] #![deny(unreachable_patterns)] +// We wrap patterns in a tuple because top-level or-patterns are special-cased for now. fn main() { - // We wrap patterns in a tuple because top-level or-patterns are special-cased for now. - // Get the fatal error out of the way match (0u8,) { (0 | _,) => {} //~^ ERROR or-patterns are not fully implemented yet } - match (0u8,) { - (1 | 2,) => {} - _ => {} - } - match (0u8,) { (1 | 2,) => {} (1,) => {} //~ ERROR unreachable pattern @@ -33,32 +27,25 @@ fn main() { (1 | 2,) => {} //~ ERROR unreachable pattern _ => {} } - match (0u8,) { - (1 | 1,) => {} // redundancy not detected for now - _ => {} - } match (0u8, 0u8) { (1 | 2, 3 | 4) => {} - (1, 2) => {} (1, 3) => {} //~ ERROR unreachable pattern (1, 4) => {} //~ ERROR unreachable pattern (2, 4) => {} //~ ERROR unreachable pattern (2 | 1, 4) => {} //~ ERROR unreachable pattern + (1, 5 | 6) => {} + (1, 4 | 5) => {} //~ ERROR unreachable pattern _ => {} } match (Some(0u8),) { (None | Some(1 | 2),) => {} (Some(1),) => {} //~ ERROR unreachable pattern (None,) => {} //~ ERROR unreachable pattern - (Some(_),) => {} + _ => {} } match ((0u8,),) { ((1 | 2,) | (3 | 4,),) => {}, ((1..=4,),) => {}, //~ ERROR unreachable pattern - ((_,),) => {}, - } - match (&[0u8][..],) { - ([] | [0 | 1..=255] | [_, ..],) => {}, - (_,) => {}, //~ ERROR unreachable pattern + _ => {}, } } diff --git a/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr b/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr new file mode 100644 index 0000000000000..a4d55d805c3c6 --- /dev/null +++ b/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr @@ -0,0 +1,80 @@ +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:16:9 + | +LL | (1,) => {} + | ^^^^ + | +note: lint level defined here + --> $DIR/exhaustiveness-unreachable-pattern.rs:4:9 + | +LL | #![deny(unreachable_patterns)] + | ^^^^^^^^^^^^^^^^^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:21:9 + | +LL | (2,) => {} + | ^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:27:9 + | +LL | (1 | 2,) => {} + | ^^^^^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:32:9 + | +LL | (1, 3) => {} + | ^^^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:33:9 + | +LL | (1, 4) => {} + | ^^^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:34:9 + | +LL | (2, 4) => {} + | ^^^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:35:9 + | +LL | (2 | 1, 4) => {} + | ^^^^^^^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:37:9 + | +LL | (1, 4 | 5) => {} + | ^^^^^^^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:42:9 + | +LL | (Some(1),) => {} + | ^^^^^^^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:43:9 + | +LL | (None,) => {} + | ^^^^^^^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:48:9 + | +LL | ((1..=4,),) => {}, + | ^^^^^^^^^^^ + +error: or-patterns are not fully implemented yet + --> $DIR/exhaustiveness-unreachable-pattern.rs:10:10 + | +LL | (0 | _,) => {} + | ^^^^^ + +error: aborting due to 12 previous errors + From 0f4c5fb20cf5d499bc3d6426b1909863f1c86a5b Mon Sep 17 00:00:00 2001 From: Nadrieril Feneanar Date: Sat, 30 Nov 2019 13:35:46 +0000 Subject: [PATCH 6/6] Apply suggestions from code review Co-Authored-By: varkor --- src/librustc_mir/hair/pattern/_match.rs | 4 ++-- src/test/ui/or-patterns/exhaustiveness-pass.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs index 2e339b1eb885d..d54f6b03cdd20 100644 --- a/src/librustc_mir/hair/pattern/_match.rs +++ b/src/librustc_mir/hair/pattern/_match.rs @@ -1838,7 +1838,7 @@ fn pat_constructor<'tcx>( if slice.is_some() { VarLen(prefix, suffix) } else { FixedLen(prefix + suffix) }; Some(Slice(Slice { array_len, kind })) } - PatKind::Or { .. } => bug!("Or-pattern hould have been expanded earlier on."), + PatKind::Or { .. } => bug!("Or-pattern should have been expanded earlier on."), } } @@ -2444,7 +2444,7 @@ fn specialize_one_pattern<'p, 'a: 'p, 'q: 'p, 'tcx>( _ => span_bug!(pat.span, "unexpected ctor {:?} for slice pat", constructor), }, - PatKind::Or { .. } => bug!("Or-pattern hould have been expanded earlier on."), + PatKind::Or { .. } => bug!("Or-pattern should have been expanded earlier on."), }; debug!("specialize({:#?}, {:#?}) = {:#?}", pat, ctor_wild_subpatterns, result); diff --git a/src/test/ui/or-patterns/exhaustiveness-pass.rs b/src/test/ui/or-patterns/exhaustiveness-pass.rs index a29cc7253ad58..62a851719f96d 100644 --- a/src/test/ui/or-patterns/exhaustiveness-pass.rs +++ b/src/test/ui/or-patterns/exhaustiveness-pass.rs @@ -17,7 +17,7 @@ fn main() { } match (0u8,) { - (1 | 1,) => {} // redundancy not detected for now + (1 | 1,) => {} // FIXME(or_patterns): redundancy not detected for now. _ => {} } match (0u8, 0u8) {