Auto merge of rust-lang#2356 - rust-lang:slash_slash_at, r=RalfJung

require level and colon in `//~` style comments

implements rust-lang/miri#2348 (comment)

Author: bors

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

@@ -4,6 +4,6 @@ fn main() {
     unsafe {
         let x = alloc(Layout::from_size_align_unchecked(1, 1));
         let _y = realloc(x, Layout::from_size_align_unchecked(1, 1), 1);
-        let _z = *x; //~ ERROR dereferenced after this allocation got freed
+        let _z = *x; //~ ERROR: dereferenced after this allocation got freed
     }
 }

tests/fail/backtrace/bad-backtrace-decl.rs

@@ -7,7 +7,7 @@ fn main() {
     let frames = unsafe { miri_get_backtrace(0) };
     for frame in frames.into_iter() {
         unsafe {
-            miri_resolve_frame(*frame, 0); //~ ERROR Undefined Behavior: bad declaration of miri_resolve_frame - should return a struct with 5 fields
+            miri_resolve_frame(*frame, 0); //~ ERROR: Undefined Behavior: bad declaration of miri_resolve_frame - should return a struct with 5 fields
         }
     }
 }

tests/fail/backtrace/bad-backtrace-flags.rs

@@ -4,6 +4,6 @@ extern "Rust" {
 
 fn main() {
     unsafe {
-        miri_get_backtrace(2, std::ptr::null_mut()); //~ ERROR  unsupported operation: unknown `miri_get_backtrace` flags 2
+        miri_get_backtrace(2, std::ptr::null_mut()); //~ ERROR:  unsupported operation: unknown `miri_get_backtrace` flags 2
     }
 }

tests/fail/backtrace/bad-backtrace-ptr.rs

@@ -4,6 +4,6 @@ extern "Rust" {
 
 fn main() {
     unsafe {
-        miri_resolve_frame(std::ptr::null_mut(), 0); //~ ERROR null pointer is a dangling pointer
+        miri_resolve_frame(std::ptr::null_mut(), 0); //~ ERROR: null pointer is a dangling pointer
     }
 }

tests/fail/backtrace/bad-backtrace-resolve-flags.rs

@@ -20,6 +20,6 @@ fn main() {
         miri_get_backtrace(1, buf.as_mut_ptr());
 
         // miri_resolve_frame will error from an invalid backtrace before it will from invalid flags
-        miri_resolve_frame(buf[0], 2); //~ ERROR  unsupported operation: unknown `miri_resolve_frame` flags 2
+        miri_resolve_frame(buf[0], 2); //~ ERROR:  unsupported operation: unknown `miri_resolve_frame` flags 2
     }
 }

tests/fail/backtrace/bad-backtrace-resolve-names-flags.rs

@@ -11,6 +11,6 @@ fn main() {
         miri_get_backtrace(1, buf.as_mut_ptr());
 
         // miri_resolve_frame_names will error from an invalid backtrace before it will from invalid flags
-        miri_resolve_frame_names(buf[0], 2, std::ptr::null_mut(), std::ptr::null_mut()); //~ ERROR  unsupported operation: unknown `miri_resolve_frame_names` flags 2
+        miri_resolve_frame_names(buf[0], 2, std::ptr::null_mut(), std::ptr::null_mut()); //~ ERROR:  unsupported operation: unknown `miri_resolve_frame_names` flags 2
     }
 }

tests/fail/backtrace/bad-backtrace-size-flags.rs

@@ -4,6 +4,6 @@ extern "Rust" {
 
 fn main() {
     unsafe {
-        miri_backtrace_size(2); //~ ERROR  unsupported operation: unknown `miri_backtrace_size` flags 2
+        miri_backtrace_size(2); //~ ERROR:  unsupported operation: unknown `miri_backtrace_size` flags 2
     }
 }

tests/fail/box-cell-alias.rs

@@ -6,7 +6,7 @@ use std::cell::Cell;
 
 fn helper(val: Box<Cell<u8>>, ptr: *const Cell<u8>) -> u8 {
     val.set(10);
-    unsafe { (*ptr).set(20) }; //~ ERROR does not exist in the borrow stack
+    unsafe { (*ptr).set(20) }; //~ ERROR: does not exist in the borrow stack
     val.get()
 }
 

tests/fail/branchless-select-i128-pointer.rs

@@ -12,7 +12,7 @@ fn main() {
         // However, it drops provenance when transmuting to TwoPtrs, so this is UB.
         let val = unsafe {
             transmute::<_, &str>(
-                //~^ ERROR constructing invalid value: encountered a dangling reference
+                //~^ ERROR: constructing invalid value: encountered a dangling reference
                 !mask & transmute::<_, TwoPtrs>("false !")
                     | mask & transmute::<_, TwoPtrs>("true !"),
             )

tests/fail/breakpoint.rs

@@ -2,6 +2,6 @@
 
 fn main() {
     unsafe {
-        core::intrinsics::breakpoint() //~ ERROR Trace/breakpoint trap
+        core::intrinsics::breakpoint() //~ ERROR: Trace/breakpoint trap
     };
 }

tests/fail/concurrency/thread_local_static_dealloc.rs

@@ -13,6 +13,6 @@ unsafe impl Send for SendRaw {}
 fn main() {
     unsafe {
         let dangling_ptr = std::thread::spawn(|| SendRaw(&TLS as *const u8)).join().unwrap();
-        let _val = *dangling_ptr.0; //~ ERROR dereferenced after this allocation got freed
+        let _val = *dangling_ptr.0; //~ ERROR: dereferenced after this allocation got freed
     }
 }

tests/fail/concurrency/unwind_top_of_stack.rs

@@ -10,7 +10,7 @@ extern crate libc;
 use std::{mem, ptr};
 
 extern "C-unwind" fn thread_start(_null: *mut libc::c_void) -> *mut libc::c_void {
-    //~^ ERROR unwinding past the topmost frame of the stack
+    //~^ ERROR: unwinding past the topmost frame of the stack
     panic!()
 }
 

tests/fail/dangling_pointers/dangling_pointer_addr_of.rs

@@ -7,6 +7,6 @@ fn main() {
         let b = Box::new(42);
         &*b as *const i32
     };
-    let x = unsafe { ptr::addr_of!(*p) }; //~ ERROR dereferenced after this allocation got freed
+    let x = unsafe { ptr::addr_of!(*p) }; //~ ERROR: dereferenced after this allocation got freed
     panic!("this should never print: {:?}", x);
 }

tests/fail/dangling_pointers/dangling_pointer_deref.rs

@@ -6,6 +6,6 @@ fn main() {
         let b = Box::new(42);
         &*b as *const i32
     };
-    let x = unsafe { *p }; //~ ERROR dereferenced after this allocation got freed
+    let x = unsafe { *p }; //~ ERROR: dereferenced after this allocation got freed
     panic!("this should never print: {}", x);
 }

tests/fail/dangling_pointers/dangling_zst_deref.rs

@@ -7,5 +7,5 @@ fn main() {
         let b = Box::new(42);
         &*b as *const i32 as *const ()
     };
-    let _x = unsafe { *p }; //~ ERROR dereferenced after this allocation got freed
+    let _x = unsafe { *p }; //~ ERROR: dereferenced after this allocation got freed
 }

tests/fail/dangling_pointers/deref-invalid-ptr.rs

@@ -3,5 +3,5 @@
 
 fn main() {
     let x = 16usize as *const u32;
-    let _y = unsafe { &*x as *const u32 }; //~ ERROR is a dangling pointer
+    let _y = unsafe { &*x as *const u32 }; //~ ERROR: is a dangling pointer
 }

tests/fail/dangling_pointers/deref-partially-dangling.rs

@@ -3,6 +3,6 @@
 fn main() {
     let x = (1, 13);
     let xptr = &x as *const _ as *const (i32, i32, i32);
-    let val = unsafe { (*xptr).1 }; //~ ERROR pointer to 12 bytes starting at offset 0 is out-of-bounds
+    let val = unsafe { (*xptr).1 }; //~ ERROR: pointer to 12 bytes starting at offset 0 is out-of-bounds
     assert_eq!(val, 13);
 }

tests/fail/dangling_pointers/dyn_size.rs

@@ -9,5 +9,5 @@ fn main() {
     // That should be UB, as the reference is not fully dereferencable.
     let ptr: *const SliceWithHead = unsafe { std::mem::transmute((&buf, 4usize)) };
     // Re-borrow that. This should be UB.
-    let _ptr = unsafe { &*ptr }; //~ ERROR pointer to 5 bytes starting at offset 0 is out-of-bounds
+    let _ptr = unsafe { &*ptr }; //~ ERROR: pointer to 5 bytes starting at offset 0 is out-of-bounds
 }

tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.rs

@@ -4,5 +4,5 @@
 fn main() {
     // This pointer *could* be NULL so we cannot load from it, not even at ZST
     let ptr = (&0u8 as *const u8).wrapping_sub(0x800) as *const ();
-    let _x: () = unsafe { *ptr }; //~ ERROR out-of-bounds
+    let _x: () = unsafe { *ptr }; //~ ERROR: out-of-bounds
 }

tests/fail/dangling_pointers/maybe_null_pointer_write_zst.rs

@@ -7,5 +7,5 @@ fn main() {
     // Also not assigning directly as that's array initialization, not assignment.
     let zst_val = [1u8; 0];
     let ptr = (&0u8 as *const u8).wrapping_sub(0x800) as *mut [u8; 0];
-    unsafe { *ptr = zst_val }; //~ ERROR out-of-bounds
+    unsafe { *ptr = zst_val }; //~ ERROR: out-of-bounds
 }

tests/fail/dangling_pointers/null_pointer_deref.rs

@@ -1,5 +1,5 @@
 #[allow(deref_nullptr)]
 fn main() {
-    let x: i32 = unsafe { *std::ptr::null() }; //~ ERROR null pointer is a dangling pointer
+    let x: i32 = unsafe { *std::ptr::null() }; //~ ERROR: null pointer is a dangling pointer
     panic!("this should never print: {}", x);
 }

tests/fail/dangling_pointers/null_pointer_deref_zst.rs

@@ -3,6 +3,6 @@
 
 #[allow(deref_nullptr)]
 fn main() {
-    let x: () = unsafe { *std::ptr::null() }; //~ ERROR dereferencing pointer failed: null pointer is a dangling pointer
+    let x: () = unsafe { *std::ptr::null() }; //~ ERROR: dereferencing pointer failed: null pointer is a dangling pointer
     panic!("this should never print: {:?}", x);
 }

tests/fail/dangling_pointers/null_pointer_write.rs

@@ -1,4 +1,4 @@
 #[allow(deref_nullptr)]
 fn main() {
-    unsafe { *std::ptr::null_mut() = 0i32 }; //~ ERROR null pointer is a dangling pointer
+    unsafe { *std::ptr::null_mut() = 0i32 }; //~ ERROR: null pointer is a dangling pointer
 }

tests/fail/dangling_pointers/out_of_bounds_read1.rs

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

tests/fail/dangling_pointers/out_of_bounds_read2.rs

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

tests/fail/dangling_pointers/stack_temporary.rs

@@ -8,7 +8,7 @@ unsafe fn make_ref<'a>(x: *mut i32) -> &'a mut i32 {
 fn main() {
     unsafe {
         let x = make_ref(&mut 0); // The temporary storing "0" is deallocated at the ";"!
-        let val = *x; //~ ERROR dereferenced after this allocation got freed
+        let val = *x; //~ ERROR: dereferenced after this allocation got freed
         println!("{}", val);
     }
 }

tests/fail/dangling_pointers/storage_dead_dangling.rs

@@ -10,7 +10,7 @@ fn fill(v: &mut i32) {
 }
 
 fn evil() {
-    unsafe { &mut *(LEAK as *mut i32) }; //~ ERROR is a dangling pointer
+    unsafe { &mut *(LEAK as *mut i32) }; //~ ERROR: is a dangling pointer
 }
 
 fn main() {

tests/fail/dangling_pointers/wild_pointer_deref.rs

@@ -2,6 +2,6 @@
 
 fn main() {
     let p = 44 as *const i32;
-    let x = unsafe { *p }; //~ ERROR is a dangling pointer
+    let x = unsafe { *p }; //~ ERROR: is a dangling pointer
     panic!("this should never print: {}", x);
 }

tests/fail/data_race/alloc_read_race.rs

@@ -38,7 +38,7 @@ pub fn main() {
             let pointer = &*ptr.0;
 
             // Note: could also error due to reading uninitialized memory, but the data-race detector triggers first.
-            *pointer.load(Ordering::Relaxed) //~ ERROR Data race detected between Read on thread `<unnamed>` and Allocate on thread `<unnamed>`
+            *pointer.load(Ordering::Relaxed) //~ ERROR: Data race detected between Read on thread `<unnamed>` and Allocate on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/alloc_write_race.rs

@@ -36,7 +36,7 @@ pub fn main() {
 
         let j2 = spawn(move || {
             let pointer = &*ptr.0;
-            *pointer.load(Ordering::Relaxed) = 2; //~ ERROR Data race detected between Write on thread `<unnamed>` and Allocate on thread `<unnamed>`
+            *pointer.load(Ordering::Relaxed) = 2; //~ ERROR: Data race detected between Write on thread `<unnamed>` and Allocate on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/atomic_read_na_write_race1.rs

@@ -24,7 +24,7 @@ pub fn main() {
 
         let j2 = spawn(move || {
             //Equivalent to: (&*c.0).load(Ordering::SeqCst)
-            intrinsics::atomic_load_seqcst(c.0 as *mut usize) //~ ERROR Data race detected between Atomic Load on thread `<unnamed>` and Write on thread `<unnamed>`
+            intrinsics::atomic_load_seqcst(c.0 as *mut usize) //~ ERROR: Data race detected between Atomic Load on thread `<unnamed>` and Write on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/atomic_read_na_write_race2.rs

@@ -24,7 +24,7 @@ pub fn main() {
 
         let j2 = spawn(move || {
             let atomic_ref = &mut *c.0;
-            *atomic_ref.get_mut() = 32; //~ ERROR Data race detected between Write on thread `<unnamed>` and Atomic Load on thread `<unnamed>`
+            *atomic_ref.get_mut() = 32; //~ ERROR: Data race detected between Write on thread `<unnamed>` and Atomic Load on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/atomic_write_na_read_race1.rs

@@ -24,7 +24,7 @@ pub fn main() {
 
         let j2 = spawn(move || {
             let atomic_ref = &mut *c.0;
-            *atomic_ref.get_mut() //~ ERROR Data race detected between Read on thread `<unnamed>` and Atomic Store on thread `<unnamed>`
+            *atomic_ref.get_mut() //~ ERROR: Data race detected between Read on thread `<unnamed>` and Atomic Store on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/atomic_write_na_read_race2.rs

@@ -24,7 +24,7 @@ pub fn main() {
 
         let j2 = spawn(move || {
             //Equivalent to: (&*c.0).store(32, Ordering::SeqCst)
-            atomic_store(c.0 as *mut usize, 32); //~ ERROR Data race detected between Atomic Store on thread `<unnamed>` and Read on thread `<unnamed>`
+            atomic_store(c.0 as *mut usize, 32); //~ ERROR: Data race detected between Atomic Store on thread `<unnamed>` and Read on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/atomic_write_na_write_race1.rs

@@ -24,7 +24,7 @@ pub fn main() {
 
         let j2 = spawn(move || {
             //Equivalent to: (&*c.0).store(64, Ordering::SeqCst)
-            atomic_store(c.0 as *mut usize, 64); //~ ERROR Data race detected between Atomic Store on thread `<unnamed>` and Write on thread `<unnamed>`
+            atomic_store(c.0 as *mut usize, 64); //~ ERROR: Data race detected between Atomic Store on thread `<unnamed>` and Write on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/atomic_write_na_write_race2.rs

@@ -24,7 +24,7 @@ pub fn main() {
 
         let j2 = spawn(move || {
             let atomic_ref = &mut *c.0;
-            *atomic_ref.get_mut() = 32; //~ ERROR Data race detected between Write on thread `<unnamed>` and Atomic Store on thread `<unnamed>`
+            *atomic_ref.get_mut() = 32; //~ ERROR: Data race detected between Write on thread `<unnamed>` and Atomic Store on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/dangling_thread_async_race.rs

@@ -35,7 +35,7 @@ fn main() {
 
     let join2 = unsafe {
         spawn(move || {
-            *c.0 = 64; //~ ERROR Data race detected between Write on thread `<unnamed>` and Write on thread `<unnamed>`
+            *c.0 = 64; //~ ERROR: Data race detected between Write on thread `<unnamed>` and Write on thread `<unnamed>`
         })
     };
 

tests/fail/data_race/dangling_thread_race.rs

@@ -34,6 +34,6 @@ fn main() {
     spawn(|| ()).join().unwrap();
 
     unsafe {
-        *c.0 = 64; //~ ERROR Data race detected between Write on thread `main` and Write on thread `<unnamed>`
+        *c.0 = 64; //~ ERROR: Data race detected between Write on thread `main` and Write on thread `<unnamed>`
     }
 }

tests/fail/data_race/dealloc_read_race1.rs

@@ -26,7 +26,7 @@ pub fn main() {
 
         let j2 = spawn(move || {
             __rust_dealloc(
-                //~^ ERROR Data race detected between Deallocate on thread `<unnamed>` and Read on thread `<unnamed>`
+                //~^ ERROR: Data race detected between Deallocate on thread `<unnamed>` and Read on thread `<unnamed>`
                 ptr.0 as *mut _,
                 std::mem::size_of::<usize>(),
                 std::mem::align_of::<usize>(),

tests/fail/data_race/dealloc_read_race2.rs

@@ -31,7 +31,7 @@ pub fn main() {
         let j2 = spawn(move || {
             // Also an error of the form: Data race detected between Read on thread `<unnamed>` and Deallocate on thread `<unnamed>`
             // but the invalid allocation is detected first.
-            *ptr.0 //~ ERROR dereferenced after this allocation got freed
+            *ptr.0 //~ ERROR: dereferenced after this allocation got freed
         });
 
         j1.join().unwrap();

tests/fail/data_race/dealloc_read_race_stack.rs

@@ -36,7 +36,7 @@ pub fn main() {
                 sleep(Duration::from_millis(200));
 
                 // Now `stack_var` gets deallocated.
-            } //~ ERROR Data race detected between Deallocate on thread `<unnamed>` and Read on thread `<unnamed>`
+            } //~ ERROR: Data race detected between Deallocate on thread `<unnamed>` and Read on thread `<unnamed>`
         });
 
         let j2 = spawn(move || {

tests/fail/data_race/dealloc_write_race1.rs

@@ -25,7 +25,7 @@ pub fn main() {
 
         let j2 = spawn(move || {
             __rust_dealloc(
-                //~^ ERROR Data race detected between Deallocate on thread `<unnamed>` and Write on thread `<unnamed>`
+                //~^ ERROR: Data race detected between Deallocate on thread `<unnamed>` and Write on thread `<unnamed>`
                 ptr.0 as *mut _,
                 std::mem::size_of::<usize>(),
                 std::mem::align_of::<usize>(),

tests/fail/data_race/dealloc_write_race2.rs

@@ -30,7 +30,7 @@ pub fn main() {
         let j2 = spawn(move || {
             // Also an error of the form: Data race detected between Write on thread `<unnamed>` and Deallocate on thread `<unnamed>`
             // but the invalid allocation is detected first.
-            *ptr.0 = 2; //~ ERROR dereferenced after this allocation got freed
+            *ptr.0 = 2; //~ ERROR: dereferenced after this allocation got freed
         });
 
         j1.join().unwrap();

tests/fail/data_race/dealloc_write_race_stack.rs

@@ -36,7 +36,7 @@ pub fn main() {
                 sleep(Duration::from_millis(200));
 
                 // Now `stack_var` gets deallocated.
-            } //~ ERROR Data race detected between Deallocate on thread `<unnamed>` and Write on thread `<unnamed>`
+            } //~ ERROR: Data race detected between Deallocate on thread `<unnamed>` and Write on thread `<unnamed>`
         });
 
         let j2 = spawn(move || {

tests/fail/data_race/enable_after_join_to_main.rs

@@ -31,7 +31,7 @@ pub fn main() {
         });
 
         let j2 = spawn(move || {
-            *c.0 = 64; //~ ERROR Data race detected between Write on thread `<unnamed>` and Write on thread `<unnamed>`
+            *c.0 = 64; //~ ERROR: Data race detected between Write on thread `<unnamed>` and Write on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/fence_after_load.rs

@@ -21,5 +21,5 @@ fn main() {
     // The fence is useless, since it did not happen-after the `store` in the other thread.
     // Hence this is a data race.
     // Also see https://github.com/rust-lang/miri/issues/2192.
-    unsafe { V = 2 } //~ERROR Data race detected between Write on thread `main` and Write on thread `<unnamed>`
+    unsafe { V = 2 } //~ERROR: Data race detected between Write on thread `main` and Write on thread `<unnamed>`
 }

tests/fail/data_race/read_write_race.rs

@@ -20,7 +20,7 @@ pub fn main() {
         });
 
         let j2 = spawn(move || {
-            *c.0 = 64; //~ ERROR Data race detected between Write on thread `<unnamed>` and Read on thread `<unnamed>`
+            *c.0 = 64; //~ ERROR: Data race detected between Write on thread `<unnamed>` and Read on thread `<unnamed>`
         });
 
         j1.join().unwrap();

tests/fail/data_race/read_write_race_stack.rs

@@ -43,7 +43,7 @@ pub fn main() {
 
             sleep(Duration::from_millis(200));
 
-            stack_var //~ ERROR Data race detected between Read on thread `<unnamed>` and Write on thread `<unnamed>`
+            stack_var //~ ERROR: Data race detected between Read on thread `<unnamed>` and Write on thread `<unnamed>`
         });
 
         let j2 = spawn(move || {