modernize all errors in check_match

Author: arielb1

src/librustc_const_eval/diagnostics.rs

@@ -294,27 +294,6 @@ match x {
 ```
 "##,
 
-E0158: r##"
-`const` and `static` mean different things. A `const` is a compile-time
-constant, an alias for a literal value. This property means you can match it
-directly within a pattern.
-
-The `static` keyword, on the other hand, guarantees a fixed location in memory.
-This does not always mean that the value is constant. For example, a global
-mutex can be declared `static` as well.
-
-If you want to match against a `static`, consider using a guard instead:
-
-```
-static FORTY_TWO: i32 = 42;
-
-match Some(42) {
-    Some(x) if x == FORTY_TWO => {}
-    _ => {}
-}
-```
-"##,
-
 E0162: r##"
 An if-let pattern attempts to match the pattern, and enters the body if the
 match was successful. If the match is irrefutable (when it cannot fail to
@@ -564,6 +543,7 @@ let x = [0i32; 2];
 
 register_diagnostics! {
 //  E0002, // duplicated from E0001
+    E0158, // cannot resolve constant in pattern
     E0298, // cannot compare constants
 //  E0299, // mismatched types between arms
 //  E0471, // constant evaluation error (in pattern)

src/test/compile-fail/E0002.rs

@@ -28,8 +28,10 @@ impl Foo for Def {
 
 pub fn test<A: Foo, B: Foo>(arg: EFoo) {
     match arg {
-        A::X => println!("A::X"), //~ error: statics cannot be referenced in patterns [E0158]
-        B::X => println!("B::X"), //~ error: statics cannot be referenced in patterns [E0158]
+        A::X => println!("A::X"), //~ ERROR E0158
+        //~| unresolvable constant here
+        B::X => println!("B::X"), //~ ERROR E0158
+        //~| unresolvable constant here
         _ => (),
     }
 }

src/test/compile-fail/associated-const-type-parameter-arms.rs renamed to src/test/compile-fail/E0158.rs

@@ -13,6 +13,7 @@ struct Irrefutable(i32);
 fn main() {
     let irr = Irrefutable(0);
     if let Irrefutable(x) = irr { //~ ERROR E0162
+        //~| this pattern always applies
         println!("{}", x);
     }
 }

src/test/compile-fail/E0162.rs

@@ -17,9 +17,9 @@ pub mod b {
     pub fn key(e: ::E) -> &'static str {
         match e {
             A => "A",
-//~^ WARN pattern binding `A` is named the same as one of the variants of the type `E`
+//~^ WARN pattern binding `A` is named the same as one of the variants of the type `E` [E0170]
             B => "B", //~ ERROR: unreachable pattern
-//~^ WARN pattern binding `B` is named the same as one of the variants of the type `E`
+//~^ WARN pattern binding `B` is named the same as one of the variants of the type `E` [E0170]
         }
     }
 }

src/test/compile-fail/issue-14221.rs renamed to src/test/compile-fail/E0170.rs

@@ -9,7 +9,12 @@
 // except according to those terms.
 
 fn main() {
-    let xs : Vec<Option<i32>> = vec!(Some(1), None);
+    for
+        &0
+        //~^ ERROR refutable pattern in `for` loop binding [E0297]
+        //~| `&_` not covered
+        in [1].iter()
+    {
 
-    for Some(x) in xs {} //~ ERROR E0297
+    }
 }

src/test/compile-fail/E0297.rs

@@ -8,10 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+fn mangle(x: &mut Option<u32>) -> bool { *x = None; false }
+
 fn main() {
-    match Some(()) {
-        None => { },
-        option if option.take().is_none() => {}, //~ ERROR E0301
-        Some(_) => { }
+    let ref mut x = Some(4);
+    match x {
+        &mut None => {}
+        &mut Some(_) if
+            mangle(
+                x //~ ERROR E0301
+                )
+            => {}
+        &mut Some(_) => {}
     }
 }

src/test/compile-fail/E0301.rs

@@ -9,9 +9,15 @@
 // except according to those terms.
 
 fn main() {
-    match Some(()) {
-        None => { },
-        option if { option = None; false } => { }, //~ ERROR E0302
-        Some(_) => { }
+    let ref mut x = Some(4);
+    match x {
+        &mut None => {}
+        &mut Some(_) if
+        {
+            *x = None; //~ ERROR E0302
+            false
+        }
+            => {}
+        &mut Some(_) => {}
     }
 }

src/test/compile-fail/E0302.rs

@@ -9,9 +9,8 @@
 // except according to those terms.
 
 fn main() {
-    match Some("hi".to_string()) {
-        ref op_string_ref @ Some(s) => {}, //~ ERROR E0303
-                                           //~^ ERROR E0009
-        None => {},
+    match 0 {
+        ref mut x @ y //~ ERROR E0303
+            => {}
     }
 }

src/test/compile-fail/E0303.rs

@@ -15,8 +15,11 @@ enum Option<T> {
 
 fn main() {
     match &mut Some(1) {
-        ref mut z @ &mut Some(ref a) => {
-        //~^ ERROR pattern bindings are not allowed after an `@`
+        ref mut z
+        //~^ NOTE within this binding
+            @ &mut Some(ref a) => {
+            //~^ ERROR nested pattern bindings are invalid
+            //~| invalid nested binding here
             **z = None;
             println!("{}", *a);
         }