Auto merge of rust-lang#2249 - dtolnay-contrib:rustfmt3, r=oli-obk

Format tests with rustfmt (151-200 of 300)

Extracted from rust-lang#2097.

This PR is still only doing the easy cases with no comments involved.

In the next PRs after this, I'll start grouping by common comment patterns, e.g. all the cases resembling rust-lang/miri#2097 (comment) together in one PR.

Author: bors

tests/fail/intrinsics/simd-rem-by-zero.rs

@@ -8,8 +8,10 @@ extern "platform-intrinsic" {
 #[allow(non_camel_case_types)]
 struct i32x2(i32, i32);
 
-fn main() { unsafe {
-    let x = i32x2(1, 1);
-    let y = i32x2(1, 0);
-    simd_rem(x, y); //~ERROR Undefined Behavior: calculating the remainder with a divisor of zero
-} }
+fn main() {
+    unsafe {
+        let x = i32x2(1, 1);
+        let y = i32x2(1, 0);
+        simd_rem(x, y); //~ERROR Undefined Behavior: calculating the remainder with a divisor of zero
+    }
+}

tests/fail/intrinsics/simd-rem-by-zero.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: calculating the remainder with a divisor of zero
   --> $DIR/simd-rem-by-zero.rs:LL:CC
    |
-LL |     simd_rem(x, y);
-   |     ^^^^^^^^^^^^^^ calculating the remainder with a divisor of zero
+LL |         simd_rem(x, y);
+   |         ^^^^^^^^^^^^^^ calculating the remainder with a divisor of zero
    |
    = 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/intrinsics/simd-scatter.rs

@@ -2,8 +2,14 @@
 #![feature(portable_simd)]
 use std::simd::*;
 
-fn main() { unsafe {
-    let mut vec: Vec<i8> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
-    let idxs = Simd::from_array([9, 3, 0, 17]);
-    Simd::from_array([-27, 82, -41, 124]).scatter_select_unchecked(&mut vec, Mask::splat(true), idxs);
-} }
+fn main() {
+    unsafe {
+        let mut vec: Vec<i8> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
+        let idxs = Simd::from_array([9, 3, 0, 17]);
+        Simd::from_array([-27, 82, -41, 124]).scatter_select_unchecked(
+            &mut vec,
+            Mask::splat(true),
+            idxs,
+        );
+    }
+}

tests/fail/intrinsics/simd-scatter.stderr

@@ -11,8 +11,12 @@ LL |             intrinsics::simd_scatter(self, ptrs, enable.to_int())
 note: inside `main` at $DIR/simd-scatter.rs:LL:CC
   --> $DIR/simd-scatter.rs:LL:CC
    |
-LL |     Simd::from_array([-27, 82, -41, 124]).scatter_select_unchecked(&mut vec, Mask::splat(true), idxs);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | /         Simd::from_array([-27, 82, -41, 124]).scatter_select_unchecked(
+LL | |             &mut vec,
+LL | |             Mask::splat(true),
+LL | |             idxs,
+LL | |         );
+   | |_________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail/intrinsics/simd-select-bitmask-invalid.rs

@@ -9,7 +9,9 @@ extern "platform-intrinsic" {
 #[derive(Copy, Clone)]
 struct i32x2(i32, i32);
 
-fn main() { unsafe {
-    let x = i32x2(0, 1);
-    simd_select_bitmask(0b11111111u8, x, x); //~ERROR bitmask less than 8 bits long must be filled with 0s for the remaining bits
-} }
+fn main() {
+    unsafe {
+        let x = i32x2(0, 1);
+        simd_select_bitmask(0b11111111u8, x, x); //~ERROR bitmask less than 8 bits long must be filled with 0s for the remaining bits
+    }
+}

tests/fail/intrinsics/simd-select-bitmask-invalid.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: a SIMD bitmask less than 8 bits long must be filled with 0s for the remaining bits
   --> $DIR/simd-select-bitmask-invalid.rs:LL:CC
    |
-LL |     simd_select_bitmask(0b11111111u8, x, x);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ a SIMD bitmask less than 8 bits long must be filled with 0s for the remaining bits
+LL |         simd_select_bitmask(0b11111111u8, x, x);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ a SIMD bitmask less than 8 bits long must be filled with 0s for the remaining bits
    |
    = 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/intrinsics/simd-select-invalid-bool.rs

@@ -9,7 +9,9 @@ extern "platform-intrinsic" {
 #[derive(Copy, Clone)]
 struct i32x2(i32, i32);
 
-fn main() { unsafe {
-    let x = i32x2(0, 1);
-    simd_select(x, x, x); //~ERROR must be all-0-bits or all-1-bits
-} }
+fn main() {
+    unsafe {
+        let x = i32x2(0, 1);
+        simd_select(x, x, x); //~ERROR must be all-0-bits or all-1-bits
+    }
+}

tests/fail/intrinsics/simd-select-invalid-bool.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: each element of a SIMD mask must be all-0-bits or all-1-bits
   --> $DIR/simd-select-invalid-bool.rs:LL:CC
    |
-LL |     simd_select(x, x, x);
-   |     ^^^^^^^^^^^^^^^^^^^^ each element of a SIMD mask must be all-0-bits or all-1-bits
+LL |         simd_select(x, x, x);
+   |         ^^^^^^^^^^^^^^^^^^^^ each element of a SIMD mask must be all-0-bits or all-1-bits
    |
    = 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/intrinsics/simd-shl-too-far.rs

@@ -8,8 +8,10 @@ extern "platform-intrinsic" {
 #[allow(non_camel_case_types)]
 struct i32x2(i32, i32);
 
-fn main() { unsafe {
-    let x = i32x2(1, 1);
-    let y = i32x2(100, 0);
-    simd_shl(x, y); //~ERROR overflowing shift by 100 in `simd_shl` in SIMD lane 0
-} }
+fn main() {
+    unsafe {
+        let x = i32x2(1, 1);
+        let y = i32x2(100, 0);
+        simd_shl(x, y); //~ERROR overflowing shift by 100 in `simd_shl` in SIMD lane 0
+    }
+}

tests/fail/intrinsics/simd-shl-too-far.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: overflowing shift by 100 in `simd_shl` in SIMD lane 0
   --> $DIR/simd-shl-too-far.rs:LL:CC
    |
-LL |     simd_shl(x, y);
-   |     ^^^^^^^^^^^^^^ overflowing shift by 100 in `simd_shl` in SIMD lane 0
+LL |         simd_shl(x, y);
+   |         ^^^^^^^^^^^^^^ overflowing shift by 100 in `simd_shl` in SIMD lane 0
    |
    = 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/intrinsics/simd-shr-too-far.rs

@@ -8,8 +8,10 @@ extern "platform-intrinsic" {
 #[allow(non_camel_case_types)]
 struct i32x2(i32, i32);
 
-fn main() { unsafe {
-    let x = i32x2(1, 1);
-    let y = i32x2(20, 40);
-    simd_shr(x, y); //~ERROR overflowing shift by 40 in `simd_shr` in SIMD lane 1
-} }
+fn main() {
+    unsafe {
+        let x = i32x2(1, 1);
+        let y = i32x2(20, 40);
+        simd_shr(x, y); //~ERROR overflowing shift by 40 in `simd_shr` in SIMD lane 1
+    }
+}

tests/fail/intrinsics/simd-shr-too-far.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: overflowing shift by 40 in `simd_shr` in SIMD lane 1
   --> $DIR/simd-shr-too-far.rs:LL:CC
    |
-LL |     simd_shr(x, y);
-   |     ^^^^^^^^^^^^^^ overflowing shift by 40 in `simd_shr` in SIMD lane 1
+LL |         simd_shr(x, y);
+   |         ^^^^^^^^^^^^^^ overflowing shift by 40 in `simd_shr` in SIMD lane 1
    |
    = 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/invalid_enum_tag.rs

@@ -8,7 +8,10 @@ use std::mem;
 
 #[repr(C)]
 pub enum Foo {
-    A, B, C, D
+    A,
+    B,
+    C,
+    D,
 }
 
 fn main() {

tests/fail/issue-miri-1112.rs

@@ -12,11 +12,7 @@ pub struct Meta {
 
 impl Meta {
     pub fn new() -> Self {
-        Meta {
-            drop_fn: |_| {},
-            size: 0,
-            align: 1,
-        }
+        Meta { drop_fn: |_| {}, size: 0, align: 1 }
     }
 }
 

tests/fail/memleak_rc.rs

@@ -2,8 +2,8 @@
 // stderr-per-bitwidth
 // normalize-stderr-test: ".*│.*" -> "$$stripped$$"
 
-use std::rc::Rc;
 use std::cell::RefCell;
+use std::rc::Rc;
 
 struct Dummy(Rc<RefCell<Option<Dummy>>>);
 

tests/fail/modifying_constants.rs

@@ -4,6 +4,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 read-only
+    *y = 42; //~ ERROR read-only
     assert_eq!(*x, 42);
 }

tests/fail/never_say_never.rs

@@ -7,9 +7,11 @@
 fn main() {
     let y = &5;
     let x: ! = unsafe {
-        *(y as *const _ as *const !)  //~ ERROR entering unreachable code
+        *(y as *const _ as *const !) //~ ERROR entering unreachable code
     };
     f(x)
 }
 
-fn f(x: !) -> ! { x }
+fn f(x: !) -> ! {
+    x
+}

tests/fail/never_transmute_void.rs

@@ -14,8 +14,6 @@ mod m {
 }
 
 fn main() {
-    let v = unsafe {
-        std::mem::transmute::<(), m::Void>(())
-    };
+    let v = unsafe { std::mem::transmute::<(), m::Void>(()) };
     m::f(v); //~ inside `main`
 }

tests/fail/rc_as_ptr.rs

@@ -1,8 +1,8 @@
 // This should fail even without validation
 // compile-flags: -Zmiri-disable-validation
 
-use std::rc::{Rc, Weak};
 use std::ptr;
+use std::rc::{Rc, Weak};
 
 /// Taken from the `Weak::as_ptr` doctest.
 fn main() {

tests/fail/reading_half_a_pointer.rs

@@ -13,7 +13,7 @@ struct Wrapper {
     data: Data,
 }
 
-static G : i32 = 0;
+static G: i32 = 0;
 
 fn main() {
     let mut w = Wrapper { align: 0, data: Data { pad: 0, ptr: &G } };

tests/fail/shim_arg_size.rs

@@ -4,10 +4,10 @@ fn main() {
     extern "C" {
         // Use the wrong type(ie. not the pointer width) for the `size`
         // argument.
-        #[cfg(target_pointer_width="64")]
+        #[cfg(target_pointer_width = "64")]
         fn malloc(size: u32) -> *mut std::ffi::c_void;
 
-        #[cfg(target_pointer_width="32")]
+        #[cfg(target_pointer_width = "32")]
         fn malloc(size: u16) -> *mut std::ffi::c_void;
     }
 

tests/fail/should-pass/cpp20_rwc_syncs.rs

@@ -76,7 +76,9 @@ fn test_cpp20_rwc_syncs() {
     // Our ui_test does not yet support overriding failure status codes.
     if (b, c) == (0, 0) {
         // This *should* be unreachable, but Miri will reach it.
-        unsafe { std::hint::unreachable_unchecked(); }
+        unsafe {
+            std::hint::unreachable_unchecked();
+        }
     }
 }
 

tests/fail/should-pass/cpp20_rwc_syncs.stderr

@@ -11,8 +11,8 @@ LL |     unsafe { intrinsics::unreachable() }
 note: inside `test_cpp20_rwc_syncs` at $DIR/cpp20_rwc_syncs.rs:LL:CC
   --> $DIR/cpp20_rwc_syncs.rs:LL:CC
    |
-LL |         unsafe { std::hint::unreachable_unchecked(); }
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |             std::hint::unreachable_unchecked();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: inside `main` at $DIR/cpp20_rwc_syncs.rs:LL:CC
   --> $DIR/cpp20_rwc_syncs.rs:LL:CC
    |

tests/fail/stacked_borrows/alias_through_mutation.rs

@@ -1,6 +1,8 @@
 // This makes a ref that was passed to us via &mut alias with things it should not alias with
 fn retarget(x: &mut &u32, target: &mut u32) {
-    unsafe { *x = &mut *(target as *mut _); }
+    unsafe {
+        *x = &mut *(target as *mut _);
+    }
 }
 
 fn main() {

tests/fail/stacked_borrows/alias_through_mutation.stderr

@@ -12,8 +12,8 @@ LL |     let _val = *target_alias;
 help: <TAG> was created by a retag at offsets [0x0..0x4]
   --> $DIR/alias_through_mutation.rs:LL:CC
    |
-LL |     unsafe { *x = &mut *(target as *mut _); }
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         *x = &mut *(target as *mut _);
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
 help: <TAG> was later invalidated at offsets [0x0..0x4]
   --> $DIR/alias_through_mutation.rs:LL:CC
    |

tests/fail/stacked_borrows/aliasing_mut1.rs

@@ -8,8 +8,7 @@ fn main() {
     // We need to apply some tricky to be able to call `safe` with two mutable references
     // with the same tag: We transmute both the fn ptr (to take raw ptrs) and the argument
     // (to be raw, but still have the unique tag).
-    let safe_raw: fn(x: *mut i32, y: *mut i32) = unsafe {
-        mem::transmute::<fn(&mut i32, &mut i32), _>(safe)
-    };
+    let safe_raw: fn(x: *mut i32, y: *mut i32) =
+        unsafe { mem::transmute::<fn(&mut i32, &mut i32), _>(safe) };
     safe_raw(xraw, xraw);
 }

tests/fail/stacked_borrows/aliasing_mut2.rs

@@ -8,8 +8,7 @@ fn main() {
     let xraw: *mut i32 = unsafe { mem::transmute_copy(&xref) };
     let xshr = &*xref;
     // transmute fn ptr around so that we can avoid retagging
-    let safe_raw: fn(x: *const i32, y: *mut i32) = unsafe {
-        mem::transmute::<fn(&i32, &mut i32), _>(safe)
-    };
+    let safe_raw: fn(x: *const i32, y: *mut i32) =
+        unsafe { mem::transmute::<fn(&i32, &mut i32), _>(safe) };
     safe_raw(xshr, xraw);
 }

tests/fail/stacked_borrows/aliasing_mut3.rs

@@ -8,8 +8,7 @@ fn main() {
     let xraw: *mut i32 = unsafe { mem::transmute_copy(&xref) };
     let xshr = &*xref;
     // transmute fn ptr around so that we can avoid retagging
-    let safe_raw: fn(x: *mut i32, y: *const i32) = unsafe {
-        mem::transmute::<fn(&mut i32, &i32), _>(safe)
-    };
+    let safe_raw: fn(x: *mut i32, y: *const i32) =
+        unsafe { mem::transmute::<fn(&mut i32, &i32), _>(safe) };
     safe_raw(xraw, xshr);
 }

tests/fail/stacked_borrows/aliasing_mut4.rs

@@ -1,5 +1,5 @@
-use std::mem;
 use std::cell::Cell;
+use std::mem;
 
 // Make sure &mut UnsafeCell also is exclusive
 pub fn safe(_x: &i32, _y: &mut Cell<i32>) {} //~ ERROR protect
@@ -10,8 +10,7 @@ fn main() {
     let xraw: *mut i32 = unsafe { mem::transmute_copy(&xref) };
     let xshr = &*xref;
     // transmute fn ptr around so that we can avoid retagging
-    let safe_raw: fn(x: *const i32, y: *mut Cell<i32>) = unsafe {
-        mem::transmute::<fn(&i32, &mut Cell<i32>), _>(safe)
-    };
+    let safe_raw: fn(x: *const i32, y: *mut Cell<i32>) =
+        unsafe { mem::transmute::<fn(&i32, &mut Cell<i32>), _>(safe) };
     safe_raw(xshr, xraw as *mut _);
 }