don't use NOTE in tests

Author: RalfJung

tests/compile-fail-fullmir/reallocate-change-alloc.rs

@@ -9,7 +9,6 @@ fn main() {
     unsafe {
         let x = Global.alloc(Layout::from_size_align_unchecked(1, 1)).unwrap();
         Global.realloc(x, Layout::from_size_align_unchecked(1, 1), 1).unwrap();
-        let _z = *(x.as_ptr() as *mut u8); //~ ERROR constant evaluation error
-        //~^ NOTE dangling pointer was dereferenced
+        let _z = *(x.as_ptr() as *mut u8); //~ ERROR dangling pointer was dereferenced
     }
 }

tests/compile-fail/alignment.rs

@@ -5,8 +5,7 @@ fn main() {
     let x_ptr: *mut u8 = &mut x[0];
     let y_ptr = x_ptr as *mut u64;
     unsafe {
-        *y_ptr = 42; //~ ERROR constant evaluation error
-        //~^ NOTE tried to access memory with alignment 1, but alignment
+        *y_ptr = 42; //~ ERROR tried to access memory with alignment 1, but alignment
     }
     panic!("unreachable in miri");
 }

tests/compile-fail/assume.rs

@@ -5,7 +5,6 @@ fn main() {
     unsafe {
         std::intrinsics::assume(x < 10);
         std::intrinsics::assume(x > 1);
-        std::intrinsics::assume(x > 42); //~ ERROR constant evaluation error
-    //~^ NOTE `assume` argument was false
+        std::intrinsics::assume(x > 42); //~ `assume` argument was false
     }
 }

tests/compile-fail/bitop-beyond-alignment.rs

@@ -28,11 +28,10 @@ fn mk_rec() -> Rec {
 fn is_u64_aligned(u: &Tag<u64>) -> bool {
     let p: usize = unsafe { mem::transmute(u) };
     let u64_align = std::mem::align_of::<u64>();
-    return (p & (u64_align + 1)) == 0; //~ ERROR constant evaluation error
-    //~^ NOTE a raw memory access tried to access part of a pointer value as raw bytes
+    return (p & (u64_align + 1)) == 0; //~ ERROR a raw memory access tried to access part of a pointer value as raw bytes
 }
 
 pub fn main() {
     let x = mk_rec();
-    assert!(is_u64_aligned(&x.t)); //~ NOTE inside call to `is_u64_aligned
+    assert!(is_u64_aligned(&x.t));
 }

tests/compile-fail/cast_box_int_to_fn_ptr.rs

@@ -7,6 +7,5 @@ fn main() {
         std::mem::transmute::<&usize, &fn(i32)>(&b)
     };
 
-    (*g)(42) //~ ERROR constant evaluation error
-    //~^ NOTE a memory access tried to interpret some bytes as a pointer
+    (*g)(42) //~ ERROR a memory access tried to interpret some bytes as a pointer
 }

tests/compile-fail/cast_int_to_fn_ptr.rs

@@ -6,6 +6,5 @@ fn main() {
         std::mem::transmute::<usize, fn(i32)>(42)
     };
 
-    g(42) //~ ERROR constant evaluation error
-    //~^ NOTE a memory access tried to interpret some bytes as a pointer
+    g(42) //~ ERROR a memory access tried to interpret some bytes as a pointer
 }

tests/compile-fail/dangling_pointer_deref.rs

@@ -3,7 +3,6 @@ fn main() {
         let b = Box::new(42);
         &*b as *const i32
     };
-    let x = unsafe { *p }; //~ ERROR constant evaluation error
-    //~^ NOTE dangling pointer was dereferenced
+    let x = unsafe { *p }; //~ ERROR dangling pointer was dereferenced
     panic!("this should never print: {}", x);
 }

tests/compile-fail/div-by-zero-2.rs

@@ -11,6 +11,5 @@
 #![allow(const_err)]
 
 fn main() {
-    let _n = 1 / 0; //~ ERROR constant evaluation error
-    //~^ NOTE attempt to divide by zero
+    let _n = 1 / 0; //~ ERROR attempt to divide by zero
 }

tests/compile-fail/execute_memory.rs

@@ -7,7 +7,6 @@ fn main() {
     let x = box 42;
     unsafe {
         let f = std::mem::transmute::<Box<i32>, fn()>(x);
-        f() //~ ERROR constant evaluation error
-        //~^ NOTE tried to treat a memory pointer as a function pointer
+        f() //~ ERROR tried to treat a memory pointer as a function pointer
     }
 }

tests/compile-fail/fn_ptr_offset.rs

@@ -10,6 +10,5 @@ fn main() {
     let y : *mut u8 = unsafe { mem::transmute(x) };
     let y = y.wrapping_offset(1);
     let x : fn() = unsafe { mem::transmute(y) };
-    x(); //~ ERROR constant evaluation error
-    //~^ NOTE tried to use a function pointer after offsetting it
+    x(); //~ ERROR tried to use a function pointer after offsetting it
 }

tests/compile-fail/modifying_constants.rs

@@ -2,7 +2,6 @@
 fn main() {
     let x = &1; // the `&1` is promoted to a constant, but it used to be that only the pointer is marked static, not the pointee
     let y = unsafe { &mut *(x as *const i32 as *mut i32) };
-    *y = 42;  //~ ERROR constant evaluation error
-    //~^ NOTE tried to modify constant memory
+    *y = 42;  //~ ERROR tried to modify constant memory
     assert_eq!(*x, 42);
 }

tests/compile-fail/never_say_never.rs

@@ -7,8 +7,7 @@
 fn main() {
     let y = &5;
     let x: ! = unsafe {
-        *(y as *const _ as *const !)  //~ ERROR constant evaluation error
-        //~^ NOTE entered unreachable code
+        *(y as *const _ as *const !)  //~ ERROR entered unreachable code
     };
     f(x)
 }

tests/compile-fail/never_transmute_void.rs

@@ -8,8 +8,7 @@
 enum Void {}
 
 fn f(v: Void) -> ! {
-    match v {} //~ ERROR constant evaluation error
-    //~^ NOTE entered unreachable code
+    match v {} //~ ERROR  entered unreachable code
 }
 
 fn main() {

tests/compile-fail/out_of_bounds_read.rs

@@ -1,6 +1,5 @@
 fn main() {
     let v: Vec<u8> = vec![1, 2];
-    let x = unsafe { *v.as_ptr().wrapping_offset(5) }; //~ ERROR constant evaluation error
-    //~^ NOTE which has size 2
+    let x = unsafe { *v.as_ptr().wrapping_offset(5) }; //~ ERROR outside bounds of allocation
     panic!("this should never print: {}", x);
 }

tests/compile-fail/out_of_bounds_read2.rs

@@ -1,6 +1,5 @@
 fn main() {
     let v: Vec<u8> = vec![1, 2];
-    let x = unsafe { *v.as_ptr().wrapping_offset(5) }; //~ ERROR constant evaluation error
-    //~^ NOTE outside bounds of allocation
+    let x = unsafe { *v.as_ptr().wrapping_offset(5) }; //~ ERROR outside bounds of allocation
     panic!("this should never print: {}", x);
 }

tests/compile-fail/overflowing-lsh-neg.rs

@@ -12,6 +12,5 @@
 #![allow(const_err)]
 
 fn main() {
-    let _n = 2i64 << -1; //~ ERROR constant evaluation error
-    //~^ NOTE attempt to shift left with overflow
+    let _n = 2i64 << -1; //~ ERROR attempt to shift left with overflow
 }

tests/compile-fail/overflowing-rsh-2.rs

@@ -12,6 +12,5 @@
 
 fn main() {
     // Make sure we catch overflows that would be hidden by first casting the RHS to u32
-    let _n = 1i64 >> (u32::max_value() as i64 + 1); //~ ERROR constant evaluation error
-    //~^ NOTE attempt to shift right with overflow
+    let _n = 1i64 >> (u32::max_value() as i64 + 1); //~ ERROR attempt to shift right with overflow
 }

tests/compile-fail/overflowing-rsh.rs

@@ -11,6 +11,5 @@
 #![allow(exceeding_bitshifts)]
 
 fn main() {
-    let _n = 1i64 >> 64; //~ ERROR constant evaluation error
-    //~^ NOTE attempt to shift right with overflow
+    let _n = 1i64 >> 64; //~ ERROR attempt to shift right with overflow
 }

tests/compile-fail/overwriting_part_of_relocation_makes_the_rest_undefined.rs

@@ -6,7 +6,6 @@ fn main() {
         // "attempted to interpret some raw bytes as a pointer address" instead of
         // "attempted to read undefined bytes"
     }
-    let x = *p; //~ ERROR constant evaluation error
-    //~^ NOTE attempted to read undefined bytes
+    let x = *p; //~ ERROR attempted to read undefined bytes
     panic!("this should never print: {}", x);
 }

tests/compile-fail/pointer_byte_read_2.rs

@@ -3,6 +3,5 @@ fn main() {
     let y = &x;
     let z = &y as *const &i32 as *const u8;
     // the deref fails, because we are reading only a part of the pointer
-    let _ = unsafe { *z }; //~ ERROR constant evaluation error
-    //~^ NOTE tried to access part of a pointer value as raw bytes
+    let _ = unsafe { *z }; //~ ERROR tried to access part of a pointer value as raw bytes
 }

tests/compile-fail/pointers_to_different_allocations_are_unorderable.rs

@@ -1,8 +1,7 @@
 fn main() {
     let x: *const u8 = &1;
     let y: *const u8 = &2;
-    if x < y { //~ ERROR constant evaluation error
-    //~^ NOTE attempted to do invalid arithmetic on pointers
+    if x < y { //~ ERROR attempted to do invalid arithmetic on pointers
         unreachable!()
     }
 }

tests/compile-fail/ptr_int_cast.rs

@@ -2,8 +2,7 @@ fn main() {
     let x = &1;
     // Casting down to u8 and back up to a pointer loses too much precision; this must not work.
     let x = x as *const i32;
-    let x = x as u8; //~ ERROR constant evaluation error
-    //~^ NOTE a raw memory access tried to access part of a pointer value as raw bytes
+    let x = x as u8; //~ ERROR a raw memory access tried to access part of a pointer value as raw bytes
     let x = x as *const i32;
     let _ = unsafe { *x };
 }

tests/compile-fail/reading_half_a_pointer.rs

@@ -24,7 +24,6 @@ fn main() {
     // starts 1 byte to the right, so using it would actually be wrong!
     let d_alias = &mut w.data as *mut _ as *mut *const u8;
     unsafe {
-        let _x = *d_alias; //~ ERROR constant evaluation error
-        //~^ NOTE tried to access part of a pointer value as raw bytes
+        let _x = *d_alias; //~ ERROR tried to access part of a pointer value as raw bytes
     }
 }

tests/compile-fail/reference_to_packed.rs

@@ -15,6 +15,5 @@ fn main() {
         y: 99,
     };
     let p = unsafe { &foo.x };
-    let i = *p; //~ ERROR constant evaluation error
-    //~^ NOTE tried to access memory with alignment 1, but alignment 4 is required
+    let i = *p; //~ ERROR tried to access memory with alignment 1, but alignment 4 is required
 }

tests/compile-fail/static_memory_modification.rs

@@ -3,8 +3,7 @@ static X: usize = 5;
 #[allow(mutable_transmutes)]
 fn main() {
     unsafe {
-        *std::mem::transmute::<&usize, &mut usize>(&X) = 6; //~ ERROR constant evaluation error
-        //~^ NOTE tried to modify constant memory
+        *std::mem::transmute::<&usize, &mut usize>(&X) = 6; //~ ERROR tried to modify constant memory
         assert_eq!(X, 6);
     }
 }

tests/compile-fail/static_memory_modification2.rs

@@ -7,7 +7,6 @@ use std::mem::transmute;
 fn main() {
     unsafe {
         let s = "this is a test";
-        transmute::<&[u8], &mut [u8]>(s.as_bytes())[4] = 42; //~ ERROR constant evaluation error
-        //~^ NOTE tried to modify constant memory
+        transmute::<&[u8], &mut [u8]>(s.as_bytes())[4] = 42; //~ ERROR tried to modify constant memory
     }
 }

tests/compile-fail/static_memory_modification3.rs

@@ -4,7 +4,6 @@ use std::mem::transmute;
 fn main() {
     unsafe {
         let bs = b"this is a test";
-        transmute::<&[u8], &mut [u8]>(bs)[4] = 42; //~ ERROR constant evaluation error
-        //~^ NOTE tried to modify constant memory
+        transmute::<&[u8], &mut [u8]>(bs)[4] = 42; //~ ERROR tried to modify constant memory
     }
 }

tests/compile-fail/transmute-pair-undef.rs

@@ -16,6 +16,5 @@ fn main() {
         assert_eq!(byte, 0);
     }
     let v = unsafe { *z.offset(first_undef) };
-    if v == 0 {} //~ ERROR constant evaluation error
-    //~^ NOTE attempted to read undefined bytes
+    if v == 0 {} //~ ERROR attempted to read undefined bytes
 }

tests/compile-fail/transmute_fat.rs

@@ -10,6 +10,5 @@ fn main() {
     let bad = unsafe {
         std::mem::transmute::<&[u8], [u8; 8]>(&[1u8])
     };
-    let _ = bad[0] + bad[bad.len()-1]; //~ ERROR constant evaluation error
-    //~^ NOTE a raw memory access tried to access part of a pointer value as raw bytes
+    let _ = bad[0] + bad[bad.len()-1]; //~ ERROR a raw memory access tried to access part of a pointer value as raw bytes
 }

tests/compile-fail/transmute_fat2.rs

@@ -7,6 +7,5 @@ fn main() {
     let bad = unsafe {
         std::mem::transmute::<u64, &[u8]>(42)
     };
-    bad[0]; //~ ERROR constant evaluation error
-    //~^ NOTE index out of bounds: the len is 0 but the index is 0
+    bad[0]; //~ ERROR index out of bounds: the len is 0 but the index is 0
 }

tests/compile-fail/unaligned_ptr_cast.rs

@@ -2,6 +2,5 @@ fn main() {
     let x = &2u16;
     let x = x as *const _ as *const u32;
     // This must fail because alignment is violated
-    let _x = unsafe { *x }; //~ ERROR constant evaluation error
-    //~^ NOTE tried to access memory with alignment 2, but alignment 4 is required
+    let _x = unsafe { *x }; //~ ERROR tried to access memory with alignment 2, but alignment 4 is required
 }

tests/compile-fail/unaligned_ptr_cast2.rs

@@ -3,6 +3,5 @@ fn main() {
     let x = x as *const _ as *const *const u8;
     // This must fail because alignment is violated.  Test specifically for loading pointers, which have special code
     // in miri's memory.
-    let _x = unsafe { *x }; //~ ERROR constant evaluation error
-    //~^ NOTE tried to access memory with alignment 2, but alignment
+    let _x = unsafe { *x }; //~ ERROR tried to access memory with alignment 2, but alignment
 }

tests/compile-fail/unaligned_ptr_cast_zst.rs

@@ -2,6 +2,5 @@ fn main() {
     let x = &2u16;
     let x = x as *const _ as *const [u32; 0];
     // This must fail because alignment is violated.  Test specifically for loading ZST.
-    let _x = unsafe { *x }; //~ ERROR constant evaluation error
-    //~^ NOTE tried to access memory with alignment 2, but alignment 4 is required
+    let _x = unsafe { *x }; //~ ERROR tried to access memory with alignment 2, but alignment 4 is required
 }

tests/compile-fail/undefined_byte_read.rs

@@ -4,7 +4,6 @@
 fn main() {
     let v: Vec<u8> = Vec::with_capacity(10);
     let undef = unsafe { *v.get_unchecked(5) };
-    let x = undef + 1; //~ ERROR: error
-    //~^ NOTE attempted to read undefined bytes
+    let x = undef + 1; //~ ERROR attempted to read undefined bytes
     panic!("this should never print: {}", x);
 }

tests/compile-fail/wild_pointer_deref.rs

@@ -1,6 +1,5 @@
 fn main() {
     let p = 44 as *const i32;
-    let x = unsafe { *p }; //~ ERROR constant evaluation error
-    //~^ NOTE a memory access tried to interpret some bytes as a pointer
+    let x = unsafe { *p }; //~ ERROR a memory access tried to interpret some bytes as a pointer
     panic!("this should never print: {}", x);
 }

tests/compile-fail/zst.rs

@@ -1,5 +1,4 @@
 fn main() {
     let x = &() as *const () as *const i32;
-    let _ = unsafe { *x }; //~ ERROR constant evaluation error
-    //~^ NOTE tried to access memory with alignment 1, but alignment 4 is required
+    let _ = unsafe { *x }; //~ ERROR tried to access memory with alignment 1, but alignment 4 is required
 }