Convert some of the tests to the new format

Author: bjorn3

tests/compile-fail/alignment.rs

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

tests/compile-fail/assume.rs

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

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

@@ -28,10 +28,11 @@ 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 a raw memory access tried to access part of a pointer value as raw bytes
+    return (p & (u64_align + 1)) == 0; //~ ERROR constant evaluation error [E0080]
+    //~^ NOTE 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));
+    assert!(is_u64_aligned(&x.t)); //~ NOTE inside call to `is_u64_aligned
 }

tests/compile-fail/cast_box_int_to_fn_ptr.rs

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

tests/compile-fail/cast_fn_ptr.rs

@@ -5,5 +5,6 @@ fn main() {
         std::mem::transmute::<fn(), fn(i32)>(f)
     };
 
-    g(42) //~ ERROR tried to call a function with sig fn() through a function pointer of type fn(i32)
+    g(42) //~ ERROR constant evaluation error [E0080]
+    //~^ NOTE tried to call a function with sig fn() through a function pointer of type fn(i32)
 }

tests/compile-fail/cast_fn_ptr2.rs

@@ -5,5 +5,6 @@ fn main() {
         std::mem::transmute::<fn((i32,i32)), fn(i32)>(f)
     };
 
-    g(42) //~ ERROR tried to call a function with sig fn((i32, i32)) through a function pointer of type fn(i32)
+    g(42) //~ ERROR constant evaluation error [E0080]
+    //~^ NOTE tried to call a function with sig fn((i32, i32)) through a function pointer of type fn(i32)
 }

tests/compile-fail/cast_int_to_fn_ptr.rs

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

tests/compile-fail/ctlz_nonzero.rs

@@ -10,6 +10,7 @@ pub fn main() {
     unsafe {
         use rusti::*;
 
-        ctlz_nonzero(0u8); //~ ERROR: ctlz_nonzero called on 0
+        ctlz_nonzero(0u8); //~ ERROR constant evaluation error [E0080]
+        //~^ NOTE ctlz_nonzero called on 0
     }
 }

tests/compile-fail/cttz_nonzero.rs

@@ -10,6 +10,7 @@ pub fn main() {
     unsafe {
         use rusti::*;
 
-        cttz_nonzero(0u8); //~ ERROR: cttz_nonzero called on 0
+        cttz_nonzero(0u8); //~ ERROR constant evaluation error [E0080]
+        //~^ NOTE cttz_nonzero called on 0
     }
 }

tests/compile-fail/dangling_pointer_deref.rs

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

tests/compile-fail/deref_fn_ptr.rs

@@ -2,7 +2,8 @@ fn f() {}
 
 fn main() {
     let x: i32 = unsafe {
-        *std::mem::transmute::<fn(), *const i32>(f) //~ ERROR: tried to dereference a function pointer
+        *std::mem::transmute::<fn(), *const i32>(f) //~ ERROR constant evaluation error [E0080]
+        //~^ NOTE tried to dereference a function pointer
     };
     panic!("this should never print: {}", x);
 }

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

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

tests/compile-fail/execute_memory.rs

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

tests/compile-fail/fn_ptr_offset.rs

@@ -10,5 +10,6 @@ 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: tried to use a function pointer after offsetting it
+    x(); //~ ERROR constant evaluation error [E0080]
+    //~^ NOTE tried to use a function pointer after offsetting it
 }

tests/compile-fail/invalid_bool.rs

@@ -1,4 +1,5 @@
 fn main() {
-    let b = unsafe { std::mem::transmute::<u8, bool>(2) }; //~ ERROR: invalid boolean value read
-    if b { unreachable!() } else { unreachable!() }
+    let b = unsafe { std::mem::transmute::<u8, bool>(2) };
+    if b { unreachable!() } else { unreachable!() } //~ ERROR constant evaluation error [E0080]
+    //~^ NOTE invalid boolean value read
 }

tests/compile-fail/invalid_enum_discriminant.rs

@@ -9,9 +9,10 @@ pub enum Foo {
 fn main() {
     let f = unsafe { std::mem::transmute::<i32, Foo>(42) };
     match f {
-        Foo::A => {}, //~ ERROR invalid enum discriminant value read
+        Foo::A => {},
         Foo::B => {},
         Foo::C => {},
         Foo::D => {},
     }
-}
+} //~ ERROR constant evaluation error [E0080]
+//~^ NOTE entered unreachable code