Format tests with rustfmt (276-287 of 299)

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

@@ -11,8 +11,10 @@ fn main() {
         // This is branchless code to select one or the other pointer.
         // However, it drops provenance when transmuting to TwoPtrs, so this is UB.
         let val = unsafe {
-            transmute::<_, &str>( //~ERROR type validation failed: encountered a dangling reference
-                !mask & transmute::<_, TwoPtrs>("false !") | mask & transmute::<_, TwoPtrs>("true !"),
+            transmute::<_, &str>(
+                //~^ ERROR type validation failed: encountered a dangling reference
+                !mask & transmute::<_, TwoPtrs>("false !")
+                    | mask & transmute::<_, TwoPtrs>("true !"),
             )
         };
         println!("{}", val);

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

@@ -2,7 +2,9 @@ error: Undefined Behavior: type validation failed: encountered a dangling refere
   --> $DIR/branchless-select-i128-pointer.rs:LL:CC
    |
 LL | /             transmute::<_, &str>(
-LL | |                 !mask & transmute::<_, TwoPtrs>("false !") | mask & transmute::<_, TwoPtrs>("true !"),
+LL | |
+LL | |                 !mask & transmute::<_, TwoPtrs>("false !")
+LL | |                     | mask & transmute::<_, TwoPtrs>("true !"),
 LL | |             )
    | |_____________^ type validation failed: encountered a dangling reference (address $HEX is unallocated)
    |

tests/fail/data_race/dealloc_read_race1.rs

@@ -19,11 +19,16 @@ pub fn main() {
 
     unsafe {
         let j1 = spawn(move || {
-            *ptr.0
+            let _val = *ptr.0;
         });
 
         let j2 = spawn(move || {
-            __rust_dealloc(ptr.0 as *mut _, std::mem::size_of::<usize>(), std::mem::align_of::<usize>());  //~ ERROR Data race detected between Deallocate on Thread(id = 2) and Read on Thread(id = 1)
+            __rust_dealloc(
+                //~^ ERROR Data race detected between Deallocate on Thread(id = 2) and Read on Thread(id = 1)
+                ptr.0 as *mut _,
+                std::mem::size_of::<usize>(),
+                std::mem::align_of::<usize>(),
+            );
         });
 
         j1.join().unwrap();

tests/fail/data_race/dealloc_read_race1.stderr

@@ -1,8 +1,13 @@
 error: Undefined Behavior: Data race detected between Deallocate on Thread(id = 2) and Read on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
   --> $DIR/dealloc_read_race1.rs:LL:CC
    |
-LL |             __rust_dealloc(ptr.0 as *mut _, std::mem::size_of::<usize>(), std::mem::align_of::<usize>());
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Data race detected between Deallocate on Thread(id = 2) and Read on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
+LL | /             __rust_dealloc(
+LL | |
+LL | |                 ptr.0 as *mut _,
+LL | |                 std::mem::size_of::<usize>(),
+LL | |                 std::mem::align_of::<usize>(),
+LL | |             );
+   | |_____________^ Data race detected between Deallocate on Thread(id = 2) and Read on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information

tests/fail/data_race/dealloc_write_race1.rs

@@ -22,7 +22,12 @@ pub fn main() {
         });
 
         let j2 = spawn(move || {
-            __rust_dealloc(ptr.0 as *mut _, std::mem::size_of::<usize>(), std::mem::align_of::<usize>());  //~ ERROR Data race detected between Deallocate on Thread(id = 2) and Write on Thread(id = 1)
+            __rust_dealloc(
+                //~^ ERROR Data race detected between Deallocate on Thread(id = 2) and Write on Thread(id = 1)
+                ptr.0 as *mut _,
+                std::mem::size_of::<usize>(),
+                std::mem::align_of::<usize>(),
+            );
         });
 
         j1.join().unwrap();

tests/fail/data_race/dealloc_write_race1.stderr

@@ -1,8 +1,13 @@
 error: Undefined Behavior: Data race detected between Deallocate on Thread(id = 2) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
   --> $DIR/dealloc_write_race1.rs:LL:CC
    |
-LL |             __rust_dealloc(ptr.0 as *mut _, std::mem::size_of::<usize>(), std::mem::align_of::<usize>());
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Data race detected between Deallocate on Thread(id = 2) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
+LL | /             __rust_dealloc(
+LL | |
+LL | |                 ptr.0 as *mut _,
+LL | |                 std::mem::size_of::<usize>(),
+LL | |                 std::mem::align_of::<usize>(),
+LL | |             );
+   | |_____________^ Data race detected between Deallocate on Thread(id = 2) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information

tests/fail/function_calls/check_callback_abi.rs

@@ -8,7 +8,8 @@ fn main() {
     unsafe {
         // Make sure we check the ABI when Miri itself invokes a function
         // as part of a shim implementation.
-        std::intrinsics::r#try( //~ ERROR calling a function with ABI C using caller ABI Rust
+        std::intrinsics::r#try(
+            //~^ ERROR calling a function with ABI C using caller ABI Rust
             std::mem::transmute::<extern "C" fn(*mut u8), _>(try_fn),
             std::ptr::null_mut(),
             |_, _| unreachable!(),

tests/fail/function_calls/check_callback_abi.stderr

@@ -2,6 +2,7 @@ error: Undefined Behavior: calling a function with ABI C using caller ABI Rust
   --> $DIR/check_callback_abi.rs:LL:CC
    |
 LL | /         std::intrinsics::r#try(
+LL | |
 LL | |             std::mem::transmute::<extern "C" fn(*mut u8), _>(try_fn),
 LL | |             std::ptr::null_mut(),
 LL | |             |_, _| unreachable!(),

tests/fail/function_calls/exported_symbol_abi_mismatch.cache.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: calling a function with calling convention Rust using calling convention C
   --> $DIR/exported_symbol_abi_mismatch.rs:LL:CC
    |
-LL |         unsafe { foo() }
-   |                  ^^^^^ calling a function with calling convention Rust using calling convention C
+LL |             foo();
+   |             ^^^^^ calling a function with calling convention Rust using calling convention C
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information

tests/fail/function_calls/exported_symbol_abi_mismatch.fn_ptr.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: calling a function with calling convention Rust using calling convention C
   --> $DIR/exported_symbol_abi_mismatch.rs:LL:CC
    |
-LL |     unsafe { std::mem::transmute::<unsafe fn(), unsafe extern "C" fn()>(foo)() }
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ calling a function with calling convention Rust using calling convention C
+LL |         std::mem::transmute::<unsafe fn(), unsafe extern "C" fn()>(foo)();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ calling a function with calling convention Rust using calling convention C
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information

tests/fail/function_calls/exported_symbol_abi_mismatch.no_cache.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: calling a function with calling convention Rust using calling convention C
   --> $DIR/exported_symbol_abi_mismatch.rs:LL:CC
    |
-LL |         unsafe { foo() }
-   |                  ^^^^^ calling a function with calling convention Rust using calling convention C
+LL |             foo();
+   |             ^^^^^ calling a function with calling convention Rust using calling convention C
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information

tests/fail/function_calls/exported_symbol_abi_mismatch.rs

@@ -10,20 +10,26 @@ fn main() {
     }
 
     #[cfg(fn_ptr)]
-    unsafe { std::mem::transmute::<unsafe fn(), unsafe extern "C" fn()>(foo)() }
-    //[fn_ptr]~^ ERROR calling a function with calling convention Rust using calling convention C
+    unsafe {
+        std::mem::transmute::<unsafe fn(), unsafe extern "C" fn()>(foo)();
+        //[fn_ptr]~^ ERROR calling a function with calling convention Rust using calling convention C
+    }
 
     // `Instance` caching should not suppress ABI check.
     #[cfg(cache)]
-    unsafe { foo() }
+    unsafe {
+        foo();
+    }
 
     {
         #[cfg_attr(any(cache, fn_ptr), allow(clashing_extern_declarations))]
         extern "C" {
             fn foo();
         }
-        unsafe { foo() }
-        //[no_cache]~^ ERROR calling a function with calling convention Rust using calling convention C
-        //[cache]~^^ ERROR calling a function with calling convention Rust using calling convention C
+        unsafe {
+            foo();
+            //[no_cache]~^ ERROR calling a function with calling convention Rust using calling convention C
+            //[cache]~| ERROR calling a function with calling convention Rust using calling convention C
+        }
     }
 }

tests/fail/type-too-large.rs

@@ -1,6 +1,6 @@
 // ignore-32bit
 
 fn main() {
-    let _fat: [u8; (1<<61)+(1<<31)] =
-        [0; (1u64<<61) as usize +(1u64<<31) as usize]; //~ ERROR post-monomorphization error
+    let _fat: [u8; (1 << 61) + (1 << 31)];
+    _fat = [0; (1u64 << 61) as usize + (1u64 << 31) as usize]; //~ ERROR post-monomorphization error
 }

tests/fail/type-too-large.stderr

@@ -1,8 +1,8 @@
 error: post-monomorphization error: values of the type `[u8; 2305843011361177600]` are too big for the current architecture
   --> $DIR/type-too-large.rs:LL:CC
    |
-LL |         [0; (1u64<<61) as usize +(1u64<<31) as usize];
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ values of the type `[u8; 2305843011361177600]` are too big for the current architecture
+LL |     _fat = [0; (1u64 << 61) as usize + (1u64 << 31) as usize];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ values of the type `[u8; 2305843011361177600]` are too big for the current architecture
    |
    = note: inside `main` at $DIR/type-too-large.rs:LL:CC
 

tests/fail/validity/invalid_char.rs

@@ -1,8 +1,9 @@
 fn main() {
     assert!(std::char::from_u32(-1_i32 as u32).is_none());
-    let _val = match unsafe { std::mem::transmute::<i32, char>(-1) } { //~ ERROR encountered 0xffffffff, but expected a valid unicode scalar value
-        'a' => {true},
-        'b' => {false},
-        _ => {true},
+    let _val = match unsafe { std::mem::transmute::<i32, char>(-1) } {
+        //~^ ERROR encountered 0xffffffff, but expected a valid unicode scalar value
+        'a' => true,
+        'b' => false,
+        _ => true,
     };
 }

tests/pass/0weak_memory_consistency.rs

@@ -54,12 +54,13 @@ fn test_corr() {
         x.store(2, Relaxed);
     });
 
+    #[rustfmt::skip]
     let j2 = spawn(move || {
         let r2 = x.load(Relaxed); // -------------------------------------+
         y.store(1, Release); // ---------------------+                    |
         r2 //                                        |                    |
     }); //                                           |                    |
-    //                                               |synchronizes-with   |happens-before
+    #[rustfmt::skip] //                              |synchronizes-with   |happens-before
     let j3 = spawn(move || { //                      |                    |
         acquires_value(&y, 1); // <------------------+                    |
         x.load(Relaxed) // <----------------------------------------------+
@@ -80,15 +81,16 @@ fn test_wrc() {
     let x = static_atomic(0);
     let y = static_atomic(0);
 
+    #[rustfmt::skip]
     let j1 = spawn(move || {
         x.store(1, Release); // ---------------------+---------------------+
     }); //                                           |                     |
-    //                                               |synchronizes-with    |
+    #[rustfmt::skip] //                              |synchronizes-with    |
     let j2 = spawn(move || { //                      |                     |
         acquires_value(&x, 1); // <------------------+                     |
         y.store(1, Release); // ---------------------+                     |happens-before
     }); //                                           |                     |
-    //                                               |synchronizes-with    |
+    #[rustfmt::skip] //                              |synchronizes-with    |
     let j3 = spawn(move || { //                      |                     |
         acquires_value(&y, 1); // <------------------+                     |
         x.load(Relaxed) // <-----------------------------------------------+
@@ -107,11 +109,12 @@ fn test_message_passing() {
     let x = EvilSend(ptr);
     let y = static_atomic(0);
 
+    #[rustfmt::skip]
     let j1 = spawn(move || {
         unsafe { *x.0 = 1 }; // -----------------------------------------+
         y.store(1, Release); // ---------------------+                   |
     }); //                                           |                   |
-    //                                               |synchronizes-with  | happens-before
+    #[rustfmt::skip] //                              |synchronizes-with  | happens-before
     let j2 = spawn(move || { //                      |                   |
         acquires_value(&y, 1); // <------------------+                   |
         unsafe { *x.0 } // <---------------------------------------------+