Stop ignoring expected note/help messages in compiletest suite.

Original issue: #21195

Relevant PR: #30778

Prior to this commit, if a compiletest testcase included the text
"HELP:" or "NOTE:" (note the colons), then it would indicate to the
compiletest suite that we should verify "help" and "note" expected
messages.

This commit updates this check to also check "HELP" and "NOTE" (not the
absense of colons) so that we always verify "help" and "note" expected
messages.

Author: frewsxcv

src/compiletest/runtest.rs

@@ -1013,8 +1013,8 @@ fn check_expected_errors(revision: Option<&str>,
         expected_errors.iter()
                         .fold((false, false),
                               |(acc_help, acc_note), ee|
-                                  (acc_help || ee.kind == "help:", acc_note ||
-                                   ee.kind == "note:"));
+                                  (acc_help || ee.kind == "help:" || ee.kind == "help",
+                                   acc_note || ee.kind == "note:" || ee.kind == "note"));
 
     // Scan and extract our error/warning messages,
     // which look like:

src/test/compile-fail/asm-out-assign-imm.rs

@@ -23,6 +23,7 @@ pub fn main() {
     unsafe {
         asm!("mov $1, $0" : "=r"(x) : "r"(5));
         //~^ ERROR re-assignment of immutable variable `x`
+        //~| NOTE in this expansion of asm!
     }
     foo(x);
 }

src/test/compile-fail/borrowck/borrowck-box-insensitivity.rs

@@ -54,80 +54,97 @@ fn borrow_after_move() {
 fn move_after_borrow() {
     let a: Box<_> = box B { x: box 0, y: box 1 };
     let _x = &a.x;
+    //~^ NOTE borrow of `a.x` occurs here
     let _y = a.y; //~ ERROR cannot move
 }
 
 fn copy_after_mut_borrow() {
     let mut a: Box<_> = box A { x: box 0, y: 1 };
     let _x = &mut a.x;
+    //~^ NOTE borrow of `a.x` occurs here
     let _y = a.y; //~ ERROR cannot use
 }
 
 fn move_after_mut_borrow() {
     let mut a: Box<_> = box B { x: box 0, y: box 1 };
     let _x = &mut a.x;
+    //~^ NOTE borrow of `a.x` occurs here
     let _y = a.y; //~ ERROR cannot move
 }
 
 fn borrow_after_mut_borrow() {
     let mut a: Box<_> = box A { x: box 0, y: 1 };
     let _x = &mut a.x;
+    //~^ NOTE previous borrow of `a` occurs here (through borrowing `a.x`);
     let _y = &a.y; //~ ERROR cannot borrow
 }
+//~^ NOTE previous borrow ends here
 
 fn mut_borrow_after_borrow() {
     let mut a: Box<_> = box A { x: box 0, y: 1 };
     let _x = &a.x;
+    //~^ NOTE previous borrow of `a` occurs here (through borrowing `a.x`)
     let _y = &mut a.y; //~ ERROR cannot borrow
 }
+//~^ NOTE previous borrow ends here
 
 fn copy_after_move_nested() {
     let a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
     let _x = a.x.x;
+    //~^ NOTE `a.x.x` moved here because it has type `Box<isize>`, which is moved by default
     let _y = a.y; //~ ERROR use of collaterally moved
 }
 
 fn move_after_move_nested() {
     let a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
     let _x = a.x.x;
+    //~^ NOTE `a.x.x` moved here because it has type `Box<isize>`, which is moved by default
     let _y = a.y; //~ ERROR use of collaterally moved
 }
 
 fn borrow_after_move_nested() {
     let a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
     let _x = a.x.x;
+    //~^ NOTE `a.x.x` moved here because it has type `Box<isize>`, which is moved by default
     let _y = &a.y; //~ ERROR use of collaterally moved
 }
 
 fn move_after_borrow_nested() {
     let a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
     let _x = &a.x.x;
+    //~^ NOTE borrow of `a.x.x` occurs here
     let _y = a.y; //~ ERROR cannot move
 }
 
 fn copy_after_mut_borrow_nested() {
     let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
     let _x = &mut a.x.x;
+    //~^ NOTE borrow of `a.x.x` occurs here
     let _y = a.y; //~ ERROR cannot use
 }
 
 fn move_after_mut_borrow_nested() {
     let mut a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
     let _x = &mut a.x.x;
+    //~^ NOTE borrow of `a.x.x` occurs here
     let _y = a.y; //~ ERROR cannot move
 }
 
 fn borrow_after_mut_borrow_nested() {
     let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
     let _x = &mut a.x.x;
+    //~^ NOTE previous borrow of `a.x.x` occurs here; the mutable borrow prevents
     let _y = &a.y; //~ ERROR cannot borrow
 }
+//~^ NOTE previous borrow ends here
 
 fn mut_borrow_after_borrow_nested() {
     let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
     let _x = &a.x.x;
+    //~^ NOTE previous borrow of `a.x.x` occurs here; the immutable borrow prevents
     let _y = &mut a.y; //~ ERROR cannot borrow
 }
+//~^ NOTE previous borrow ends here
 
 fn main() {
     copy_after_move();

src/test/compile-fail/borrowck/borrowck-let-suggestion.rs

@@ -12,6 +12,7 @@ fn f() {
     let x = [1].iter(); //~ ERROR borrowed value does not live long enough
                          //~^ NOTE reference must be valid for the block suffix following statement
                          //~^^ HELP consider using a `let` binding to increase its lifetime
+                         //~^^^ NOTE ...but borrowed value is only valid for the statement at 12:4
 }
 
 fn main() {

src/test/compile-fail/borrowck/borrowck-report-with-custom-diagnostic.rs

@@ -13,6 +13,7 @@ fn main() {
     // Original borrow ends at end of function
     let mut x = 1;
     let y = &mut x;
+    //~^ previous borrow of `x` occurs here; the mutable borrow prevents
     let z = &x; //~ ERROR cannot borrow
 }
 //~^ NOTE previous borrow ends here
@@ -23,6 +24,7 @@ fn foo() {
             // Original borrow ends at end of match arm
             let mut x = 1;
             let y = &x;
+            //~^ previous borrow of `x` occurs here; the immutable borrow prevents
             let z = &mut x; //~ ERROR cannot borrow
         }
      //~^ NOTE previous borrow ends here
@@ -35,6 +37,7 @@ fn bar() {
     || {
         let mut x = 1;
         let y = &mut x;
+        //~^ previous borrow of `x` occurs here; the mutable borrow prevents
         let z = &mut x; //~ ERROR cannot borrow
     };
  //~^ NOTE previous borrow ends here

src/test/compile-fail/borrowck/borrowck-vec-pattern-nesting.rs

@@ -17,6 +17,7 @@ fn a() {
     let mut vec = [box 1, box 2, box 3];
     match vec {
         [box ref _a, _, _] => {
+        //~^ borrow of `vec[..]` occurs here
             vec[0] = box 4; //~ ERROR cannot assign
         }
     }
@@ -27,6 +28,7 @@ fn b() {
     let vec: &mut [Box<isize>] = &mut vec;
     match vec {
         [_b..] => {
+        //~^ borrow of `vec[..]` occurs here
             vec[0] = box 4; //~ ERROR cannot assign
         }
     }
@@ -48,6 +50,7 @@ fn c() {
         _ => {}
     }
     let a = vec[0]; //~ ERROR cannot move out
+    //~^ NOTE attempting to move value to here
 }
 
 fn d() {
@@ -59,6 +62,7 @@ fn d() {
         _ => {}
     }
     let a = vec[0]; //~ ERROR cannot move out
+    //~^ NOTE attempting to move value to here
 }
 
 fn e() {

src/test/compile-fail/cast-as-bool.rs

@@ -12,4 +12,5 @@ fn main() {
     let u = 5 as bool;
     //~^ ERROR cannot cast as `bool`
     //~^^ HELP compare with zero instead
+    //~^^^ HELP run `rustc --explain E0054` to see a detailed explanation
 }

src/test/compile-fail/cast-rfc0401.rs

@@ -61,9 +61,11 @@ fn main()
     let _ = 3 as bool;
     //~^ ERROR cannot cast as `bool`
     //~^^ HELP compare with zero
+    //~^^^ HELP run `rustc --explain E0054` to see a detailed explanation
     let _ = E::A as bool;
     //~^ ERROR cannot cast as `bool`
     //~^^ HELP compare with zero
+    //~^^^ HELP run `rustc --explain E0054` to see a detailed explanation
     let _ = 0x61u32 as char; //~ ERROR only `u8` can be cast
 
     let _ = false as f32;
@@ -90,6 +92,9 @@ fn main()
     let _ = v as *const [u8]; //~ ERROR cannot cast
     let _ = fat_v as *const Foo;
     //~^ ERROR `core::marker::Sized` is not implemented for the type `[u8]`
+    //~^^ HELP run `rustc --explain E0277` to see a detailed explanation
+    //~^^^ NOTE `[u8]` does not have a constant size known at compile-time
+    //~^^^^ NOTE required for the cast to the object type `Foo`
     let _ = foo as *const str; //~ ERROR casting
     let _ = foo as *mut str; //~ ERROR casting
     let _ = main as *mut str; //~ ERROR casting
@@ -102,6 +107,9 @@ fn main()
     let a : *const str = "hello";
     let _ = a as *const Foo;
     //~^ ERROR `core::marker::Sized` is not implemented for the type `str`
+    //~^^ HELP run `rustc --explain E0277` to see a detailed explanation
+    //~^^^ NOTE `str` does not have a constant size known at compile-time
+    //~^^^^ NOTE required for the cast to the object type `Foo`
 
     // check no error cascade
     let _ = main.f as *const u32; //~ ERROR attempted access of field

src/test/compile-fail/fat-ptr-cast.rs

@@ -18,6 +18,7 @@ fn main() {
     let q = a.as_ptr();
 
     a as usize; //~ ERROR casting
+    //~^ HELP cast through a raw pointer first
     b as usize; //~ ERROR non-scalar cast
     p as usize;
     //~^ ERROR casting

src/test/compile-fail/feature-gate-negate-unsigned.rs

@@ -23,5 +23,6 @@ const _MAX: usize = -1;
 fn main() {
     let x = 5u8;
     let _y = -x; //~ ERROR unary negation of unsigned integer
+    //~^ HELP use a cast or the `!` operator
     -S; // should not trigger the gate; issue 26840
 }