Fix several occurences of the improper_ctypes lint in tests where that was not the intent

tests/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs

@@ -4,7 +4,6 @@
 #![crate_type = "lib"]
 #![no_core]
 #![feature(no_core, lang_items)]
-#![allow(improper_ctypes)]
 
 #[lang = "sized"]
 trait Sized {}
@@ -83,8 +82,7 @@ pub struct Tiny {
 
 // CHECK: define void @f_agg_tiny(i64 %0)
 #[no_mangle]
-pub extern "C" fn f_agg_tiny(mut e: Tiny) {
-}
+pub extern "C" fn f_agg_tiny(mut e: Tiny) {}
 
 // CHECK: define i64 @f_agg_tiny_ret()
 #[no_mangle]
@@ -100,8 +98,7 @@ pub struct Small {
 
 // CHECK: define void @f_agg_small([2 x i64] %0)
 #[no_mangle]
-pub extern "C" fn f_agg_small(mut x: Small) {
-}
+pub extern "C" fn f_agg_small(mut x: Small) {}
 
 // CHECK: define [2 x i64] @f_agg_small_ret()
 #[no_mangle]
@@ -116,8 +113,7 @@ pub struct SmallAligned {
 
 // CHECK: define void @f_agg_small_aligned(i128 %0)
 #[no_mangle]
-pub extern "C" fn f_agg_small_aligned(mut x: SmallAligned) {
-}
+pub extern "C" fn f_agg_small_aligned(mut x: SmallAligned) {}
 
 #[repr(C)]
 pub struct Large {
@@ -129,8 +125,7 @@ pub struct Large {
 
 // CHECK: define void @f_agg_large({{%Large\*|ptr}} {{.*}}%x)
 #[no_mangle]
-pub extern "C" fn f_agg_large(mut x: Large) {
-}
+pub extern "C" fn f_agg_large(mut x: Large) {}
 
 // CHECK: define void @f_agg_large_ret({{%Large\*|ptr}} {{.*}}sret{{.*}}, i32 noundef signext %i, i8 noundef signext %j)
 #[no_mangle]

tests/debuginfo/type-names.rs

@@ -355,7 +355,6 @@ fn generic_function<T>(x: T) -> T {
     x
 }
 
-#[allow(improper_ctypes)]
 extern "C" {
     fn printf(_: *const u8, ...) -> isize;
 }

tests/ui/abi/abi-sysv64-arg-passing.rs

@@ -32,32 +32,35 @@
 // note: windows is ignored as rust_test_helpers does not have the sysv64 abi on windows
 
 #[allow(dead_code)]
-#[allow(improper_ctypes)]
-
+// #[allow(improper_ctypes)]
 #[cfg(target_arch = "x86_64")]
 mod tests {
     #[repr(C)]
     #[derive(Copy, Clone, PartialEq, Debug)]
     pub struct TwoU8s {
-        one: u8, two: u8
+        one: u8,
+        two: u8,
     }
 
     #[repr(C)]
     #[derive(Copy, Clone, PartialEq, Debug)]
     pub struct TwoU16s {
-        one: u16, two: u16
+        one: u16,
+        two: u16,
     }
 
     #[repr(C)]
     #[derive(Copy, Clone, PartialEq, Debug)]
     pub struct TwoU32s {
-        one: u32, two: u32
+        one: u32,
+        two: u32,
     }
 
     #[repr(C)]
     #[derive(Copy, Clone, PartialEq, Debug)]
     pub struct TwoU64s {
-        one: u64, two: u64
+        one: u64,
+        two: u64,
     }
 
     #[repr(C)]
@@ -83,19 +86,34 @@ mod tests {
 
     #[repr(C)]
     #[derive(Copy, Clone)]
-    pub struct Quad { a: u64, b: u64, c: u64, d: u64 }
+    pub struct Quad {
+        a: u64,
+        b: u64,
+        c: u64,
+        d: u64,
+    }
 
+    #[repr(C)]
     #[derive(Copy, Clone)]
-    pub struct QuadFloats { a: f32, b: f32, c: f32, d: f32 }
+    pub struct QuadFloats {
+        a: f32,
+        b: f32,
+        c: f32,
+        d: f32,
+    }
 
     #[repr(C)]
     #[derive(Copy, Clone)]
-    pub struct Floats { a: f64, b: u8, c: f64 }
+    pub struct Floats {
+        a: f64,
+        b: u8,
+        c: f64,
+    }
 
     #[repr(C, u8)]
     pub enum U8TaggedEnumOptionU64U64 {
         None,
-        Some(u64,u64),
+        Some(u64, u64),
     }
 
     #[repr(C, u8)]
@@ -111,6 +129,7 @@ mod tests {
         pub fn rust_dbg_extern_identity_u32(v: u32) -> u32;
         pub fn rust_dbg_extern_identity_u64(v: u64) -> u64;
         pub fn rust_dbg_extern_identity_double(v: f64) -> f64;
+        #[allow(improper_ctypes)] // intentional for test
         pub fn rust_dbg_extern_empty_struct(v1: ManyInts, e: Empty, v2: ManyInts);
         pub fn rust_dbg_extern_identity_TwoU8s(v: TwoU8s) -> TwoU8s;
         pub fn rust_dbg_extern_identity_TwoU16s(v: TwoU16s) -> TwoU16s;
@@ -123,8 +142,13 @@ mod tests {
         pub fn get_x(x: S) -> u64;
         pub fn get_y(x: S) -> u64;
         pub fn get_z(x: S) -> u64;
-        pub fn get_c_many_params(_: *const (), _: *const (),
-                                 _: *const (), _: *const (), f: Quad) -> u64;
+        pub fn get_c_many_params(
+            _: *const (),
+            _: *const (),
+            _: *const (),
+            _: *const (),
+            f: Quad,
+        ) -> u64;
         pub fn get_c_exhaust_sysv64_ints(
             _: *const (),
             _: *const (),
@@ -150,9 +174,7 @@ mod tests {
     }
 
     pub fn cabi_int_widening() {
-        let x = unsafe {
-            rust_int8_to_int32(-1)
-        };
+        let x = unsafe { rust_int8_to_int32(-1) };
 
         assert!(x == -1);
     }
@@ -189,15 +211,15 @@ mod tests {
                 arg3: 4,
                 arg4: 5,
                 arg5: 6,
-                arg6: TwoU8s { one: 7, two: 8, }
+                arg6: TwoU8s { one: 7, two: 8 },
             };
             let y = ManyInts {
                 arg1: 1,
                 arg2: 2,
                 arg3: 3,
                 arg4: 4,
                 arg5: 5,
-                arg6: TwoU8s { one: 6, two: 7, }
+                arg6: TwoU8s { one: 6, two: 7 },
             };
             let empty = Empty;
             rust_dbg_extern_empty_struct(x, empty, y);
@@ -206,31 +228,31 @@ mod tests {
 
     pub fn extern_pass_twou8s() {
         unsafe {
-            let x = TwoU8s {one: 22, two: 23};
+            let x = TwoU8s { one: 22, two: 23 };
             let y = rust_dbg_extern_identity_TwoU8s(x);
             assert_eq!(x, y);
         }
     }
 
     pub fn extern_pass_twou16s() {
         unsafe {
-            let x = TwoU16s {one: 22, two: 23};
+            let x = TwoU16s { one: 22, two: 23 };
             let y = rust_dbg_extern_identity_TwoU16s(x);
             assert_eq!(x, y);
         }
     }
 
     pub fn extern_pass_twou32s() {
         unsafe {
-            let x = TwoU32s {one: 22, two: 23};
+            let x = TwoU32s { one: 22, two: 23 };
             let y = rust_dbg_extern_identity_TwoU32s(x);
             assert_eq!(x, y);
         }
     }
 
     pub fn extern_pass_twou64s() {
         unsafe {
-            let x = TwoU64s {one: 22, two: 23};
+            let x = TwoU64s { one: 22, two: 23 };
             let y = rust_dbg_extern_identity_TwoU64s(x);
             assert_eq!(x, y);
         }
@@ -270,9 +292,7 @@ mod tests {
 
     #[inline(never)]
     fn indirect_call(func: unsafe extern "sysv64" fn(s: S) -> u64, s: S) -> u64 {
-        unsafe {
-            func(s)
-        }
+        unsafe { func(s) }
     }
 
     pub fn foreign_fn_with_byval() {
@@ -286,12 +306,7 @@ mod tests {
         use std::ptr;
         unsafe {
             let null = ptr::null();
-            let q = Quad {
-                a: 1,
-                b: 2,
-                c: 3,
-                d: 4
-            };
+            let q = Quad { a: 1, b: 2, c: 3, d: 4 };
             assert_eq!(get_c_many_params(null, null, null, null, q), q.c);
         }
     }
@@ -304,16 +319,8 @@ mod tests {
         use std::ptr;
         unsafe {
             let null = ptr::null();
-            let q = QuadFloats {
-                a: 10.2,
-                b: 20.3,
-                c: 30.4,
-                d: 40.5
-            };
-            assert_eq!(
-                get_c_exhaust_sysv64_ints(null, null, null, null, null, null, null, q),
-                q.c,
-            );
+            let q = QuadFloats { a: 10.2, b: 20.3, c: 30.4, d: 40.5 };
+            assert_eq!(get_c_exhaust_sysv64_ints(null, null, null, null, null, null, null, q), q.c);
         }
     }
 
@@ -323,10 +330,12 @@ mod tests {
 
     fn test1() {
         unsafe {
-            let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa,
-                     b: 0xbbbb_bbbb_bbbb_bbbb,
-                     c: 0xcccc_cccc_cccc_cccc,
-                     d: 0xdddd_dddd_dddd_dddd };
+            let q = Quad {
+                a: 0xaaaa_aaaa_aaaa_aaaa,
+                b: 0xbbbb_bbbb_bbbb_bbbb,
+                c: 0xcccc_cccc_cccc_cccc,
+                d: 0xdddd_dddd_dddd_dddd,
+            };
             let qq = rust_dbg_abi_1(q);
             println!("a: {:x}", qq.a as usize);
             println!("b: {:x}", qq.b as usize);
@@ -341,9 +350,7 @@ mod tests {
 
     fn test2() {
         unsafe {
-            let f = Floats { a: 1.234567890e-15_f64,
-                     b: 0b_1010_1010,
-                     c: 1.0987654321e-15_f64 };
+            let f = Floats { a: 1.234567890e-15_f64, b: 0b_1010_1010, c: 1.0987654321e-15_f64 };
             let ff = rust_dbg_abi_2(f);
             println!("a: {}", ff.a as f64);
             println!("b: {}", ff.b as usize);
@@ -369,7 +376,7 @@ mod tests {
         }
 
         let none_u64u64 = unsafe { rust_dbg_new_none_u64u64() };
-        if let U8TaggedEnumOptionU64U64::Some(_,_) = none_u64u64 {
+        if let U8TaggedEnumOptionU64U64::Some(_, _) = none_u64u64 {
             panic!("unexpected some");
         }
 
@@ -443,6 +450,4 @@ fn main() {
 }
 
 #[cfg(not(target_arch = "x86_64"))]
-fn main() {
-
-}
+fn main() {}

tests/ui/abi/abi-sysv64-register-usage.rs

@@ -44,11 +44,11 @@ pub extern "sysv64" fn all_the_registers(
 // this struct contains 8 i64's, while only 6 can be passed in registers.
 #[cfg(target_arch = "x86_64")]
 #[derive(PartialEq, Eq, Debug)]
+#[repr(C)]
 pub struct LargeStruct(i64, i64, i64, i64, i64, i64, i64, i64);
 
 #[cfg(target_arch = "x86_64")]
 #[inline(never)]
-#[allow(improper_ctypes_definitions)]
 pub extern "sysv64" fn large_struct_by_val(mut foo: LargeStruct) -> LargeStruct {
     foo.0 *= 1;
     foo.1 *= 2;

tests/ui/abi/extern/extern-pass-TwoU16s.rs

@@ -1,12 +1,12 @@
 // run-pass
-#![allow(improper_ctypes)]
 
 // ignore-wasm32-bare no libc for ffi testing
 
 // Test a foreign function that accepts and returns a struct
 // by value.
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
 pub struct TwoU16s {
     one: u16,
     two: u16,

tests/ui/abi/extern/extern-pass-TwoU32s.rs

@@ -1,12 +1,12 @@
 // run-pass
-#![allow(improper_ctypes)]
 
 // ignore-wasm32-bare no libc for ffi testing
 
 // Test a foreign function that accepts and returns a struct
 // by value.
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
 pub struct TwoU32s {
     one: u32,
     two: u32,

tests/ui/abi/extern/extern-pass-TwoU64s.rs

@@ -1,12 +1,12 @@
 // run-pass
-#![allow(improper_ctypes)]
 
 // ignore-wasm32-bare no libc for ffi testing
 
 // Test a foreign function that accepts and returns a struct
 // by value.
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
 pub struct TwoU64s {
     one: u64,
     two: u64,

tests/ui/abi/extern/extern-pass-TwoU8s.rs

@@ -1,12 +1,12 @@
 // run-pass
-#![allow(improper_ctypes)]
 
 // ignore-wasm32-bare no libc for ffi testing
 
 // Test a foreign function that accepts and returns a struct
 // by value.
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
 pub struct TwoU8s {
     one: u8,
     two: u8,

tests/ui/abi/extern/extern-return-TwoU16s.rs

@@ -1,8 +1,8 @@
 // run-pass
-#![allow(improper_ctypes)]
 
 // ignore-wasm32-bare no libc to test ffi with
 
+#[repr(C)]
 pub struct TwoU16s {
     one: u16,
     two: u16,