Auto merge of #54624 - arielb1:evaluate-outlives, r=nikomatsakis

[rust.git] / src / test / ui / exhaustive_integer_patterns.rs

diff --git a/src/test/ui/exhaustive_integer_patterns.rs b/src/test/ui/exhaustive_integer_patterns.rs
index 39bac8919ffdf7ae1ba4881f30a66a1a87b39280..7825aaa291286c08ea26b202ac43af8e83308a63 100644 (file)
--- a/src/test/ui/exhaustive_integer_patterns.rs
+++ b/src/test/ui/exhaustive_integer_patterns.rs
@@ -34,7 +34,7 @@ fn main() {
     }
 
     // An incomplete set of values.
-    match x { //~ ERROR non-exhaustive patterns: `128u8...255u8` not covered
+    match x { //~ ERROR non-exhaustive patterns
         0 .. 128 => {}
     }
 
@@ -55,10 +55,19 @@ fn main() {
     }
 
     // Let's test other types too!
-    match '\u{0}' {
+    let c: char = '\u{0}';
+    match c {
         '\u{0}' ..= char::MAX => {} // ok
     }
 
+    // We can actually get away with just covering the
+    // following two ranges, which correspond to all
+    // valid Unicode Scalar Values.
+    match c {
+        '\u{0000}' ..= '\u{D7FF}' => {}
+        '\u{E000}' ..= '\u{10_FFFF}' => {}
+    }
+
     match 0usize {
         0 ..= usize::MAX => {} // ok
     }
@@ -84,13 +93,22 @@ fn main() {
     }
 
     match 0i8 {
-        -128..=127 => {} // ok
+        -128 ..= 127 => {} // ok
+    }
+
+    match 0i8 { //~ ERROR non-exhaustive patterns
+        -127 ..= 127 => {}
     }
 
     match 0i16 {
         i16::MIN ..= i16::MAX => {} // ok
     }
 
+    match 0i16 { //~ ERROR non-exhaustive patterns
+        i16::MIN ..= -1 => {}
+        1 ..= i16::MAX => {}
+    }
+
     match 0i32 {
         i32::MIN ..= i32::MAX => {} // ok
     }
@@ -102,4 +120,54 @@ fn main() {
     match 0i128 {
         i128::MIN ..= i128::MAX => {} // ok
     }
+
+    // Make sure that guards don't factor into the exhaustiveness checks.
+    match 0u8 { //~ ERROR non-exhaustive patterns
+        0 .. 128 => {}
+        128 ..= 255 if true => {}
+    }
+
+    match 0u8 {
+        0 .. 128 => {}
+        128 ..= 255 if false => {}
+        128 ..= 255 => {} // ok, because previous arm was guarded
+    }
+
+    // Now things start getting a bit more interesting. Testing products!
+    match (0u8, Some(())) { //~ ERROR non-exhaustive patterns
+        (1, _) => {}
+        (_, None) => {}
+    }
+
+    match (0u8, true) { //~ ERROR non-exhaustive patterns
+        (0 ..= 125, false) => {}
+        (128 ..= 255, false) => {}
+        (0 ..= 255, true) => {}
+    }
+
+    match (0u8, true) { // ok
+        (0 ..= 125, false) => {}
+        (128 ..= 255, false) => {}
+        (0 ..= 255, true) => {}
+        (125 .. 128, false) => {}
+    }
+
+    match 0u8 { // ok
+        0 .. 2 => {}
+        1 ..= 2 => {}
+        _ => {}
+    }
+
+    const LIM: u128 = u128::MAX - 1;
+    match 0u128 { //~ ERROR non-exhaustive patterns
+        0 ..= LIM => {}
+    }
+
+    match 0u128 { //~ ERROR non-exhaustive patterns
+        0 ..= 4 => {}
+    }
+
+    match 0u128 { //~ ERROR non-exhaustive patterns
+        4 ..= u128::MAX => {}
+    }
 }