adjust compile-fail error messages

This also passes miri-test-libstd!

tests/compile-fail/stacked_borrows/alias_through_mutation.rs

@@ -9,5 +9,5 @@ fn main() {
     retarget(&mut target_alias, target);
     // now `target_alias` points to the same thing as `target`
     *target = 13;
-    let _val = *target_alias; //~ ERROR does not exist on the borrow stack
+    let _val = *target_alias; //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/aliasing_mut3.rs

@@ -1,6 +1,6 @@
 use std::mem;
 
-pub fn safe(_x: &mut i32, _y: &i32) {} //~ ERROR does not exist on the borrow stack
+pub fn safe(_x: &mut i32, _y: &i32) {} //~ ERROR borrow stack
 
 fn main() {
     let mut x = 0;

tests/compile-fail/stacked_borrows/box_exclusive_violation1.rs

@@ -8,7 +8,7 @@ fn demo_mut_advanced_unique(mut our: Box<i32>) -> i32 {
   unknown_code_2();
 
   // We know this will return 5
-  *our //~ ERROR does not exist on the borrow stack
+  *our //~ ERROR borrow stack
 }
 
 // Now comes the evil context

tests/compile-fail/stacked_borrows/buggy_as_mut_slice.rs

@@ -13,5 +13,5 @@ fn main() {
     let v1 = safe::as_mut_slice(&v);
     let _v2 = safe::as_mut_slice(&v);
     v1[1] = 5;
-    //~^ ERROR does not exist on the borrow stack
+    //~^ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/buggy_split_at_mut.rs

@@ -9,7 +9,7 @@ mod safe {
             assert!(mid <= len);
 
             (from_raw_parts_mut(ptr, len - mid), // BUG: should be "mid" instead of "len - mid"
-            //~^ ERROR does not exist on the borrow stack
+            //~^ ERROR borrow stack
             from_raw_parts_mut(ptr.offset(mid as isize), len - mid))
         }
     }

tests/compile-fail/stacked_borrows/illegal_read1.rs

@@ -7,7 +7,7 @@ fn main() {
     let xref = unsafe { &mut *xraw }; // derived from raw, so using raw is still ok...
     callee(xraw);
     let _val = *xref; // ...but any use of raw will invalidate our ref.
-    //~^ ERROR: does not exist on the borrow stack
+    //~^ ERROR: borrow stack
 }
 
 fn callee(xraw: *mut i32) {

tests/compile-fail/stacked_borrows/illegal_read2.rs

@@ -7,7 +7,7 @@ fn main() {
     let xref = unsafe { &mut *xraw }; // derived from raw, so using raw is still ok...
     callee(xraw);
     let _val = *xref; // ...but any use of raw will invalidate our ref.
-    //~^ ERROR: does not exist on the borrow stack
+    //~^ ERROR: borrow stack
 }
 
 fn callee(xraw: *mut i32) {

tests/compile-fail/stacked_borrows/illegal_read3.rs

@@ -15,7 +15,7 @@ fn main() {
     callee(xref1_sneaky);
     // ... though any use of it will invalidate our ref.
     let _val = *xref2;
-    //~^ ERROR: does not exist on the borrow stack
+    //~^ ERROR: borrow stack
 }
 
 fn callee(xref1: usize) {

tests/compile-fail/stacked_borrows/illegal_read4.rs

@@ -5,5 +5,5 @@ fn main() {
     let xraw = xref1 as *mut _;
     let xref2 = unsafe { &mut *xraw };
     let _val = unsafe { *xraw }; // use the raw again, this invalidates xref2 *even* with the special read except for uniq refs
-    let _illegal = *xref2; //~ ERROR does not exist on the borrow stack
+    let _illegal = *xref2; //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/illegal_read5.rs

@@ -12,5 +12,5 @@ fn main() {
     let _val = *xref; // we can even still use our mutable reference
     mem::forget(unsafe { ptr::read(xshr) }); // but after reading through the shared ref
     let _val = *xref; // the mutable one is dead and gone
-    //~^ ERROR does not exist on the borrow stack
+    //~^ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/illegal_write1.rs

@@ -5,5 +5,5 @@ fn main() {
         let x : *mut u32 = xref as *const _ as *mut _;
         unsafe { *x = 42; } // invalidates shared ref, activates raw
     }
-    let _x = *xref; //~ ERROR is not frozen
+    let _x = *xref; //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/illegal_write2.rs

@@ -3,6 +3,6 @@ fn main() {
     let target2 = target as *mut _;
     drop(&mut *target); // reborrow
     // Now make sure our ref is still the only one.
-    unsafe { *target2 = 13; } //~ ERROR does not exist on the borrow stack
+    unsafe { *target2 = 13; } //~ ERROR borrow stack
     let _val = *target;
 }

tests/compile-fail/stacked_borrows/illegal_write3.rs

@@ -3,6 +3,6 @@ fn main() {
     // Make sure raw ptr with raw tag cannot mutate frozen location without breaking the shared ref.
     let r#ref = ⌖ // freeze
     let ptr = r#ref as *const _ as *mut _; // raw ptr, with raw tag
-    unsafe { *ptr = 42; } //~ ERROR does not exist on the borrow stack
+    unsafe { *ptr = 42; } //~ ERROR borrow stack
     let _val = *r#ref;
 }

tests/compile-fail/stacked_borrows/illegal_write4.rs

@@ -9,5 +9,5 @@ fn main() {
     let ptr = reference as *const _ as *mut i32; // raw ptr, with raw tag
     let _mut_ref: &mut i32 = unsafe { mem::transmute(ptr) }; // &mut, with raw tag
     // Now we retag, making our ref top-of-stack -- and, in particular, unfreezing.
-    let _val = *reference; //~ ERROR is not frozen
+    let _val = *reference; //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/illegal_write5.rs

@@ -8,7 +8,7 @@ fn main() {
     callee(xraw);
     // ... though any use of raw value will invalidate our ref.
     let _val = *xref;
-    //~^ ERROR: does not exist on the borrow stack
+    //~^ ERROR: borrow stack
 }
 
 fn callee(xraw: *mut i32) {

tests/compile-fail/stacked_borrows/load_invalid_mut.rs

@@ -5,5 +5,5 @@ fn main() {
     let xref = unsafe { &mut *xraw };
     let xref_in_mem = Box::new(xref);
     let _val = unsafe { *xraw }; // invalidate xref
-    let _val = *xref_in_mem; //~ ERROR does not exist on the borrow stack
+    let _val = *xref_in_mem; //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/load_invalid_shr.rs

@@ -5,5 +5,5 @@ fn main() {
     let xref = unsafe { &*xraw };
     let xref_in_mem = Box::new(xref);
     unsafe { *xraw = 42 }; // unfreeze
-    let _val = *xref_in_mem; //~ ERROR is not frozen
+    let _val = *xref_in_mem; //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/mut_exclusive_violation1.rs

@@ -21,7 +21,7 @@ fn unknown_code_1(x: &i32) { unsafe {
 } }
 
 fn unknown_code_2() { unsafe {
-    *LEAK = 7; //~ ERROR barrier
+    *LEAK = 7; //~ ERROR borrow stack
 } }
 
 fn main() {

tests/compile-fail/stacked_borrows/outdated_local.rs

@@ -3,7 +3,7 @@ fn main() {
     let y: *const i32 = &x;
     x = 1; // this invalidates y by reactivating the lowermost uniq borrow for this local
 
-    assert_eq!(unsafe { *y }, 1); //~ ERROR does not exist on the borrow stack
+    assert_eq!(unsafe { *y }, 1); //~ ERROR borrow stack
 
     assert_eq!(x, 1);
 }

tests/compile-fail/stacked_borrows/pass_invalid_mut.rs

@@ -6,5 +6,5 @@ fn main() {
     let xraw = x as *mut _;
     let xref = unsafe { &mut *xraw };
     let _val = unsafe { *xraw }; // invalidate xref
-    foo(xref); //~ ERROR does not exist on the borrow stack
+    foo(xref); //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/pass_invalid_shr.rs

@@ -6,5 +6,5 @@ fn main() {
     let xraw = x as *mut _;
     let xref = unsafe { &*xraw };
     unsafe { *xraw = 42 }; // unfreeze
-    foo(xref); //~ ERROR is not frozen
+    foo(xref); //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/pointer_smuggling.rs

@@ -8,7 +8,7 @@ fn fun1(x: &mut u8) {
 
 fn fun2() {
     // Now we use a pointer we are not allowed to use
-    let _x = unsafe { *PTR }; //~ ERROR does not exist on the borrow stack
+    let _x = unsafe { *PTR }; //~ ERROR borrow stack
 }
 
 fn main() {

tests/compile-fail/stacked_borrows/return_invalid_mut.rs

@@ -3,7 +3,7 @@ fn foo(x: &mut (i32, i32)) -> &mut i32 {
     let xraw = x as *mut (i32, i32);
     let ret = unsafe { &mut (*xraw).1 };
     let _val = unsafe { *xraw }; // invalidate xref
-    ret //~ ERROR does not exist on the borrow stack
+    ret //~ ERROR borrow stack
 }
 
 fn main() {

tests/compile-fail/stacked_borrows/return_invalid_mut_option.rs

@@ -3,7 +3,7 @@ fn foo(x: &mut (i32, i32)) -> Option<&mut i32> {
     let xraw = x as *mut (i32, i32);
     let ret = Some(unsafe { &mut (*xraw).1 });
     let _val = unsafe { *xraw }; // invalidate xref
-    ret //~ ERROR does not exist on the borrow stack
+    ret //~ ERROR borrow stack
 }
 
 fn main() {

tests/compile-fail/stacked_borrows/return_invalid_mut_tuple.rs

@@ -3,7 +3,7 @@ fn foo(x: &mut (i32, i32)) -> (&mut i32,) {
     let xraw = x as *mut (i32, i32);
     let ret = (unsafe { &mut (*xraw).1 },);
     let _val = unsafe { *xraw }; // invalidate xref
-    ret //~ ERROR does not exist on the borrow stack
+    ret //~ ERROR borrow stack
 }
 
 fn main() {

tests/compile-fail/stacked_borrows/return_invalid_shr.rs

@@ -3,7 +3,7 @@ fn foo(x: &mut (i32, i32)) -> &i32 {
     let xraw = x as *mut (i32, i32);
     let ret = unsafe { &(*xraw).1 };
     unsafe { *xraw = (42, 23) }; // unfreeze
-    ret //~ ERROR is not frozen
+    ret //~ ERROR borrow stack
 }
 
 fn main() {

tests/compile-fail/stacked_borrows/return_invalid_shr_option.rs

@@ -3,7 +3,7 @@ fn foo(x: &mut (i32, i32)) -> Option<&i32> {
     let xraw = x as *mut (i32, i32);
     let ret = Some(unsafe { &(*xraw).1 });
     unsafe { *xraw = (42, 23) }; // unfreeze
-    ret //~ ERROR is not frozen
+    ret //~ ERROR borrow stack
 }
 
 fn main() {

tests/compile-fail/stacked_borrows/return_invalid_shr_tuple.rs

@@ -3,7 +3,7 @@ fn foo(x: &mut (i32, i32)) -> (&i32,) {
     let xraw = x as *mut (i32, i32);
     let ret = (unsafe { &(*xraw).1 },);
     unsafe { *xraw = (42, 23) }; // unfreeze
-    ret //~ ERROR is not frozen
+    ret //~ ERROR borrow stack
 }
 
 fn main() {

tests/compile-fail/stacked_borrows/shr_frozen_violation1.rs

@@ -8,9 +8,6 @@ fn main() {
     println!("{}", foo(&mut 0));
 }
 
-// If we replace the `*const` by `&`, my current dev version of miri
-// *does* find the problem, but not for a good reason: It finds it because
-// of barriers, and we shouldn't rely on unknown code using barriers.
-fn unknown_code(x: *const i32) {
-    unsafe { *(x as *mut i32) = 7; } //~ ERROR barrier
+fn unknown_code(x: &i32) {
+    unsafe { *(x as *const i32 as *mut i32) = 7; } //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/static_memory_modification.rs

@@ -3,6 +3,6 @@ static X: usize = 5;
 #[allow(mutable_transmutes)]
 fn main() {
     let _x = unsafe {
-        std::mem::transmute::<&usize, &mut usize>(&X) //~ ERROR mutable reference with frozen tag
+        std::mem::transmute::<&usize, &mut usize>(&X) //~ ERROR borrow stack
     };
 }

tests/compile-fail/stacked_borrows/transmute-is-no-escape.rs

@@ -10,5 +10,5 @@ fn main() {
     let _raw: *mut i32 = unsafe { mem::transmute(&mut x[0]) };
     // `raw` still carries a tag, so we get another pointer to the same location that does not carry a tag
     let raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
-    unsafe { *raw = 13; } //~ ERROR does not exist on the borrow stack
+    unsafe { *raw = 13; } //~ ERROR borrow stack
 }

tests/compile-fail/stacked_borrows/unescaped_local.rs

@@ -4,5 +4,5 @@ fn main() {
     let mut x = 42;
     let raw = &mut x as *mut i32 as usize as *mut i32;
     let _ptr = &mut x;
-    unsafe { *raw = 13; } //~ ERROR does not exist on the borrow stack
+    unsafe { *raw = 13; } //~ ERROR borrow stack
 }