Run rustfmt on tests/codegen/.

Except for `simd-intrinsic/`, which has a lot of files containing
multiple types like `u8x64` which really are better when hand-formatted.

There is a surprising amount of two-space indenting in this directory.

Non-trivial changes:
- `rustfmt::skip` needed in `debug-column.rs` to preserve meaning of the
  test.
- `rustfmt::skip` used in a few places where hand-formatting read more
  nicely: `enum/enum-match.rs`
- Line number adjustments needed for the expected output of
  `debug-column.rs` and `coroutine-debug.rs`.

Author: nnethercote

rustfmt.toml

@@ -14,7 +14,7 @@ ignore = [
     # - some contain syntax errors that cause rustfmt to give an error
     # - some UI tests are broken by different formatting
     # - some require special comments in a particular position (e.g. `EMIT_MIR` comments)
-    "/tests/codegen/",
+    "/tests/codegen/simd-intrinsic/", # Many types like `u8x64` are better hand-formatted.
     "/tests/codegen-units/",
     "/tests/coverage/",
     "/tests/coverage-run-rustdoc/",

tests/codegen/aarch64-struct-align-128.rs

@@ -12,14 +12,12 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang="sized"]
-trait Sized { }
-#[lang="freeze"]
-trait Freeze { }
-#[lang="copy"]
-trait Copy { }
-
-
+#[lang = "sized"]
+trait Sized {}
+#[lang = "freeze"]
+trait Freeze {}
+#[lang = "copy"]
+trait Copy {}
 
 // Passed as `[i64 x 2]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
 #[repr(C)]
@@ -31,7 +29,7 @@ pub struct Align8 {
 // repr(transparent), so same as above.
 #[repr(transparent)]
 pub struct Transparent8 {
-    a: Align8
+    a: Align8,
 }
 
 // Passed as `[i64 x 2]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
@@ -47,8 +45,6 @@ extern "C" {
     fn test_8(a: Align8, b: Transparent8, c: Wrapped8);
 }
 
-
-
 // Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
 // EXCEPT on Linux, where there's a special case to use its unadjusted alignment,
 // making it the same as `Align8`, so it's be passed as `[i64 x 2]`.
@@ -62,7 +58,7 @@ pub struct Align16 {
 // repr(transparent), so same as above.
 #[repr(transparent)]
 pub struct Transparent16 {
-    a: Align16
+    a: Align16,
 }
 
 // Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
@@ -79,8 +75,6 @@ extern "C" {
     fn test_16(a: Align16, b: Transparent16, c: Wrapped16);
 }
 
-
-
 // Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
 #[repr(C)]
 pub struct I128 {
@@ -90,13 +84,13 @@ pub struct I128 {
 // repr(transparent), so same as above.
 #[repr(transparent)]
 pub struct TransparentI128 {
-    a: I128
+    a: I128,
 }
 
 // Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
 #[repr(C)]
 pub struct WrappedI128 {
-    pub a: I128
+    pub a: I128,
 }
 
 extern "C" {
@@ -106,8 +100,6 @@ extern "C" {
     fn test_i128(a: I128, b: TransparentI128, c: WrappedI128);
 }
 
-
-
 // Passed as `[2 x i64]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
 // Note that the Linux special case does not apply, because packing is not considered "adjustment".
 #[repr(C)]
@@ -119,13 +111,13 @@ pub struct Packed {
 // repr(transparent), so same as above.
 #[repr(transparent)]
 pub struct TransparentPacked {
-    a: Packed
+    a: Packed,
 }
 
 // Passed as `[2 x i64]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
 #[repr(C)]
 pub struct WrappedPacked {
-    pub a: Packed
+    pub a: Packed,
 }
 
 extern "C" {
@@ -135,13 +127,19 @@ extern "C" {
     fn test_packed(a: Packed, b: TransparentPacked, c: WrappedPacked);
 }
 
-
-
 pub unsafe fn main(
-    a1: Align8, a2: Transparent8, a3: Wrapped8,
-    b1: Align16, b2: Transparent16, b3: Wrapped16,
-    c1: I128, c2: TransparentI128, c3: WrappedI128,
-    d1: Packed, d2: TransparentPacked, d3: WrappedPacked,
+    a1: Align8,
+    a2: Transparent8,
+    a3: Wrapped8,
+    b1: Align16,
+    b2: Transparent16,
+    b3: Wrapped16,
+    c1: I128,
+    c2: TransparentI128,
+    c3: WrappedI128,
+    d1: Packed,
+    d2: TransparentPacked,
+    d3: WrappedPacked,
 ) {
     test_8(a1, a2, a3);
     test_16(b1, b2, b3);

tests/codegen/abi-efiapi.rs

@@ -17,12 +17,12 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang="sized"]
-trait Sized { }
-#[lang="freeze"]
-trait Freeze { }
-#[lang="copy"]
-trait Copy { }
+#[lang = "sized"]
+trait Sized {}
+#[lang = "freeze"]
+trait Freeze {}
+#[lang = "copy"]
+trait Copy {}
 
 //x86_64: define win64cc void @has_efiapi
 //i686: define void @has_efiapi

tests/codegen/abi-main-signature-16bit-c-int.rs

@@ -6,8 +6,6 @@
 //@[avr] only-avr
 //@[msp] only-msp430
 
-
-fn main() {
-}
+fn main() {}
 
 // CHECK: define i16 @main(i16, i8**)

tests/codegen/abi-main-signature-32bit-c-int.rs

@@ -6,7 +6,6 @@
 //@ ignore-avr
 //@ ignore-wasi wasi codegens the main symbol differently
 
-fn main() {
-}
+fn main() {}
 
 // CHECK: define{{( hidden| noundef)*}} i32 @main(i32{{( %0)?}}, ptr{{( %1)?}})

tests/codegen/abi-repr-ext.rs

@@ -24,14 +24,17 @@
 #![no_std]
 #![no_core]
 
-#[lang="sized"] trait Sized { }
-#[lang="freeze"] trait Freeze { }
-#[lang="copy"] trait Copy { }
+#[lang = "sized"]
+trait Sized {}
+#[lang = "freeze"]
+trait Freeze {}
+#[lang = "copy"]
+trait Copy {}
 
 #[repr(i8)]
 pub enum Type {
     Type1 = 0,
-    Type2 = 1
+    Type2 = 1,
 }
 
 // To accommodate rust#97800, one might consider writing the below as:
@@ -50,7 +53,6 @@ pub enum Type {
 // riscv-SAME:                  signext
 // CHECK-SAME: i8 @test()
 
-
 #[no_mangle]
 pub extern "C" fn test() -> Type {
     Type::Type1

tests/codegen/abi-x86_64_sysv.rs

@@ -5,25 +5,25 @@
 #![crate_type = "lib"]
 
 pub struct S24 {
-  a: i8,
-  b: i8,
-  c: i8,
+    a: i8,
+    b: i8,
+    c: i8,
 }
 
 pub struct S48 {
-  a: i16,
-  b: i16,
-  c: i8,
+    a: i16,
+    b: i16,
+    c: i8,
 }
 
 // CHECK: i24 @struct_24_bits(i24
 #[no_mangle]
 pub extern "sysv64" fn struct_24_bits(a: S24) -> S24 {
-  a
+    a
 }
 
 // CHECK: i48 @struct_48_bits(i48
 #[no_mangle]
 pub extern "sysv64" fn struct_48_bits(a: S48) -> S48 {
-  a
+    a
 }

tests/codegen/adjustments.rs

@@ -5,17 +5,16 @@
 // Hack to get the correct size for the length part in slices
 // CHECK: @helper([[USIZE:i[0-9]+]] %_1)
 #[no_mangle]
-pub fn helper(_: usize) {
-}
+pub fn helper(_: usize) {}
 
 // CHECK-LABEL: @no_op_slice_adjustment
 #[no_mangle]
 pub fn no_op_slice_adjustment(x: &[u8]) -> &[u8] {
     // We used to generate an extra alloca and memcpy for the block's trailing expression value, so
     // check that we copy directly to the return value slot
-// CHECK: %0 = insertvalue { ptr, [[USIZE]] } poison, ptr %x.0, 0
-// CHECK: %1 = insertvalue { ptr, [[USIZE]] } %0, [[USIZE]] %x.1, 1
-// CHECK: ret { ptr, [[USIZE]] } %1
+    // CHECK: %0 = insertvalue { ptr, [[USIZE]] } poison, ptr %x.0, 0
+    // CHECK: %1 = insertvalue { ptr, [[USIZE]] } %0, [[USIZE]] %x.1, 1
+    // CHECK: ret { ptr, [[USIZE]] } %1
     { x }
 }
 
@@ -24,6 +23,6 @@ pub fn no_op_slice_adjustment(x: &[u8]) -> &[u8] {
 pub fn no_op_slice_adjustment2(x: &[u8]) -> &[u8] {
     // We used to generate an extra alloca and memcpy for the function's return value, so check
     // that there's no memcpy (the slice is written to sret_slot element-wise)
-// CHECK-NOT: call void @llvm.memcpy.
+    // CHECK-NOT: call void @llvm.memcpy.
     no_op_slice_adjustment(x)
 }

tests/codegen/align-byval.rs

@@ -23,9 +23,12 @@
 #![no_std]
 #![no_core]
 
-#[lang="sized"] trait Sized { }
-#[lang="freeze"] trait Freeze { }
-#[lang="copy"] trait Copy { }
+#[lang = "sized"]
+trait Sized {}
+#[lang = "freeze"]
+trait Freeze {}
+#[lang = "copy"]
+trait Copy {}
 
 impl Copy for i32 {}
 impl Copy for i64 {}
@@ -58,7 +61,7 @@ pub struct ForceAlign4 {
 pub struct NaturalAlign8 {
     a: i64,
     b: i64,
-    c: i64
+    c: i64,
 }
 
 // On i686-windows, this is passed by reference (because alignment is >4 and requested/forced),
@@ -68,7 +71,7 @@ pub struct NaturalAlign8 {
 pub struct ForceAlign8 {
     a: i64,
     b: i64,
-    c: i64
+    c: i64,
 }
 
 // On i686-windows, this is passed on stack, because requested alignment is <=4.
@@ -77,28 +80,28 @@ pub struct ForceAlign8 {
 pub struct LowerFA8 {
     a: i64,
     b: i64,
-    c: i64
+    c: i64,
 }
 
 // On i686-windows, this is passed by reference, because it contains a field with
 // requested/forced alignment.
 #[repr(C)]
 pub struct WrappedFA8 {
-    a: ForceAlign8
+    a: ForceAlign8,
 }
 
 // On i686-windows, this has the same ABI as ForceAlign8, i.e. passed by reference.
 #[repr(transparent)]
 pub struct TransparentFA8 {
     _0: (),
-    a: ForceAlign8
+    a: ForceAlign8,
 }
 
 #[repr(C)]
 #[repr(align(16))]
 pub struct ForceAlign16 {
     a: [i32; 16],
-    b: i8
+    b: i8,
 }
 
 // CHECK-LABEL: @call_na1

tests/codegen/align-enum.rs

@@ -18,16 +18,16 @@ pub struct Nested64 {
 // CHECK-LABEL: @align64
 #[no_mangle]
 pub fn align64(a: u32) -> Align64 {
-// CHECK: %a64 = alloca [64 x i8], align 64
-// CHECK: call void @llvm.memcpy.{{.*}}(ptr align 64 %{{.*}}, ptr align 64 %{{.*}}, i{{[0-9]+}} 64, i1 false)
+    // CHECK: %a64 = alloca [64 x i8], align 64
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 64 %{{.*}}, ptr align 64 %{{.*}}, i{{[0-9]+}} 64, i1 false)
     let a64 = Align64::A(a);
     a64
 }
 
 // CHECK-LABEL: @nested64
 #[no_mangle]
 pub fn nested64(a: u8, b: u32, c: u16) -> Nested64 {
-// CHECK: %n64 = alloca [128 x i8], align 64
+    // CHECK: %n64 = alloca [128 x i8], align 64
     let n64 = Nested64 { a, b: Align64::B(b), c };
     n64
 }