Auto merge of #46641 - petrochenkov:nohelp2, r=nikomatsakis

Move compile-fail tests with NOTE/HELP annotations to UI

Remove NOTE/HELP annotations from UI tests

cc #44844 @oli-obk @est31
r? @nikomatsakis

Author: bors

src/Cargo.lock

@@ -133,13 +133,15 @@ Sometimes these built-in normalizations are not enough. In such cases, you
 may provide custom normalization rules using the header commands, e.g.
 
 ```
-// normalize-stderr-32bit: "fn() (32 bits)" -> "fn() ($PTR bits)"
-// normalize-stderr-64bit: "fn() (64 bits)" -> "fn() ($PTR bits)"
+// normalize-stdout-test: "foo" -> "bar"
+// normalize-stderr-32bit: "fn\(\) \(32 bits\)" -> "fn\(\) \($$PTR bits\)"
+// normalize-stderr-64bit: "fn\(\) \(64 bits\)" -> "fn\(\) \($$PTR bits\)"
 ```
 
 This tells the test, on 32-bit platforms, whenever the compiler writes
 `fn() (32 bits)` to stderr, it should be normalized to read `fn() ($PTR bits)`
-instead. Similar for 64-bit.
+instead. Similar for 64-bit. The replacement is performed by regexes using
+default regex flavor provided by `regex` crate.
 
 The corresponding reference file will use the normalized output to test both
 32-bit and 64-bit platforms:
@@ -156,4 +158,5 @@ Please see `ui/transmute/main.rs` and `.stderr` for a concrete usage example.
 
 Besides `normalize-stderr-32bit` and `-64bit`, one may use any target
 information or stage supported by `ignore-X` here as well (e.g.
-`normalize-stderr-windows`).
+`normalize-stderr-windows` or simply `normalize-stderr-test` for unconditional
+replacement).

src/test/COMPILER_TESTS.md

@@ -11,5 +11,4 @@
 fn main() {
     let x = Some(1);
     let Some(y) = x; //~ ERROR E0005
-    //~| NOTE pattern `None` not covered
 }

src/test/compile-fail/E0005.rs

@@ -13,9 +13,7 @@ fn main() {
     match x {
         op_string @ Some(s) => {},
         //~^ ERROR E0007
-        //~| NOTE binds an already bound by-move value by moving it
         //~| ERROR E0303
-        //~| NOTE not allowed after `@`
         None => {},
     }
 }

src/test/compile-fail/E0007.rs

@@ -12,7 +12,6 @@ fn main() {
     match Some("hi".to_string()) {
         Some(s) if s.len() == 0 => {},
         //~^ ERROR E0008
-        //~| NOTE moves value into pattern guard
         _ => {},
     }
 }

src/test/compile-fail/E0008.rs

@@ -14,8 +14,6 @@ fn main() {
     match x {
         Some((y, ref z)) => {},
         //~^ ERROR E0009
-        //~| NOTE by-move pattern here
-        //~| NOTE both by-ref and by-move used
         None => panic!()
     }
 }

src/test/compile-fail/E0009.rs

@@ -12,6 +12,5 @@
 #![allow(warnings)]
 
 const CON : Box<i32> = box 0; //~ ERROR E0010
-                              //~| NOTE allocation not allowed in
 
 fn main() {}

src/test/compile-fail/E0010.rs

@@ -12,10 +12,7 @@ static X: i32 = 1;
 const C: i32 = 2;
 
 const CR: &'static mut i32 = &mut C; //~ ERROR E0017
-                                     //~| NOTE constants require immutable values
 static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
-                                              //~| NOTE statics require immutable values
                                               //~| ERROR cannot borrow
 static CONST_REF: &'static mut i32 = &mut C; //~ ERROR E0017
-                                             //~| NOTE statics require immutable values
 fn main() {}

src/test/compile-fail/E0017.rs

@@ -18,10 +18,7 @@ fn main() {
     let x = Fruit::Apple(String::new(), String::new());
     match x {
         Fruit::Apple(a) => {}, //~ ERROR E0023
-                               //~| NOTE expected 2 fields, found 1
         Fruit::Apple(a, b, c) => {}, //~ ERROR E0023
-                                     //~| NOTE expected 2 fields, found 3
         Fruit::Pear(1, 2) => {}, //~ ERROR E0023
-                                 //~| NOTE expected 1 field, found 2
     }
 }

src/test/compile-fail/E0023.rs

@@ -17,6 +17,4 @@ fn main() {
     let x = Foo { a:1, b:2 };
     let Foo { a: x, a: y, b: 0 } = x;
     //~^ ERROR field `a` bound multiple times in the pattern
-    //~| NOTE multiple uses of `a` in pattern
-    //~| NOTE first use of `a`
 }