1 files changed, 0 insertions, 417 deletions
diff --git a/src/test/ui/lint/clashing-extern-fn.rs b/src/test/ui/lint/clashing-extern-fn.rs
deleted file mode 100644
index 809e0602671..00000000000
--- a/src/test/ui/lint/clashing-extern-fn.rs
+++ /dev/null
@@ -1,417 +0,0 @@
-// check-pass
-// aux-build:external_extern_fn.rs
-#![crate_type = "lib"]
-#![warn(clashing_extern_declarations)]
-
-mod redeclared_different_signature {
-    mod a {
-        extern "C" {
-            fn clash(x: u8);
-        }
-    }
-    mod b {
-        extern "C" {
-            fn clash(x: u64); //~ WARN `clash` redeclared with a different signature
-        }
-    }
-}
-
-mod redeclared_same_signature {
-    mod a {
-        extern "C" {
-            fn no_clash(x: u8);
-        }
-    }
-    mod b {
-        extern "C" {
-            fn no_clash(x: u8);
-        }
-    }
-}
-
-extern crate external_extern_fn;
-mod extern_no_clash {
-    // Should not clash with external_extern_fn::extern_fn.
-    extern "C" {
-        fn extern_fn(x: u8);
-    }
-}
-
-extern "C" {
-    fn some_other_new_name(x: i16);
-
-    #[link_name = "extern_link_name"]
-    fn some_new_name(x: i16);
-
-    #[link_name = "link_name_same"]
-    fn both_names_different(x: i16);
-}
-
-fn link_name_clash() {
-    extern "C" {
-        fn extern_link_name(x: u32);
-        //~^ WARN `extern_link_name` redeclared with a different signature
-
-        #[link_name = "some_other_new_name"]
-        //~^ WARN `some_other_extern_link_name` redeclares `some_other_new_name` with a different
-        fn some_other_extern_link_name(x: u32);
-
-        #[link_name = "link_name_same"]
-        //~^ WARN `other_both_names_different` redeclares `link_name_same` with a different
-        fn other_both_names_different(x: u32);
-    }
-}
-
-mod a {
-    extern "C" {
-        fn different_mod(x: u8);
-    }
-}
-mod b {
-    extern "C" {
-        fn different_mod(x: u64); //~ WARN `different_mod` redeclared with a different signature
-    }
-}
-
-extern "C" {
-    fn variadic_decl(x: u8, ...);
-}
-
-fn variadic_clash() {
-    extern "C" {
-        fn variadic_decl(x: u8); //~ WARN `variadic_decl` redeclared with a different signature
-    }
-}
-
-#[no_mangle]
-fn no_mangle_name(x: u8) {}
-
-extern "C" {
-    #[link_name = "unique_link_name"]
-    fn link_name_specified(x: u8);
-}
-
-fn tricky_no_clash() {
-    extern "C" {
-        // Shouldn't warn, because the declaration above actually declares a different symbol (and
-        // Rust's name resolution rules around shadowing will handle this gracefully).
-        fn link_name_specified() -> u32;
-
-        // The case of a no_mangle name colliding with an extern decl (see #28179) is related but
-        // shouldn't be reported by ClashingExternDeclarations, because this is an example of
-        // unmangled name clash causing bad behaviour in functions with a defined body.
-        fn no_mangle_name() -> u32;
-    }
-}
-
-mod banana {
-    mod one {
-        #[repr(C)]
-        struct Banana {
-            weight: u32,
-            length: u16,
-        }
-        extern "C" {
-            fn weigh_banana(count: *const Banana) -> u64;
-        }
-    }
-
-    mod two {
-        #[repr(C)]
-        struct Banana {
-            weight: u32,
-            length: u16,
-        } // note: distinct type
-          // This should not trigger the lint because two::Banana is structurally equivalent to
-          // one::Banana.
-        extern "C" {
-            fn weigh_banana(count: *const Banana) -> u64;
-        }
-    }
-
-    mod three {
-        // This _should_ trigger the lint, because repr(packed) should generate a struct that has a
-        // different layout.
-        #[repr(packed)]
-        struct Banana {
-            weight: u32,
-            length: u16,
-        }
-        #[allow(improper_ctypes)]
-        extern "C" {
-            fn weigh_banana(count: *const Banana) -> u64;
-            //~^ WARN `weigh_banana` redeclared with a different signature
-        }
-    }
-}
-
-mod sameish_members {
-    mod a {
-        #[repr(C)]
-        struct Point {
-            x: i16,
-            y: i16,
-        }
-
-        extern "C" {
-            fn draw_point(p: Point);
-        }
-    }
-    mod b {
-        #[repr(C)]
-        struct Point {
-            coordinates: [i16; 2],
-        }
-
-        // It's possible we are overconservative for this case, as accessing the elements of the
-        // coordinates array might end up correctly accessing `.x` and `.y`. However, this may not
-        // always be the case, for every architecture and situation. This is also a really odd
-        // thing to do anyway.
-        extern "C" {
-            fn draw_point(p: Point);
-            //~^ WARN `draw_point` redeclared with a different signature
-        }
-    }
-}
-
-mod same_sized_members_clash {
-    mod a {
-        #[repr(C)]
-        struct Point3 {
-            x: f32,
-            y: f32,
-            z: f32,
-        }
-        extern "C" {
-            fn origin() -> Point3;
-        }
-    }
-    mod b {
-        #[repr(C)]
-        struct Point3 {
-            x: i32,
-            y: i32,
-            z: i32, // NOTE: Incorrectly redeclared as i32
-        }
-        extern "C" {
-            fn origin() -> Point3; //~ WARN `origin` redeclared with a different signature
-        }
-    }
-}
-
-mod transparent {
-    #[repr(transparent)]
-    struct T(usize);
-    mod a {
-        use super::T;
-        extern "C" {
-            fn transparent() -> T;
-            fn transparent_incorrect() -> T;
-        }
-    }
-
-    mod b {
-        extern "C" {
-            // Shouldn't warn here, because repr(transparent) guarantees that T's layout is the
-            // same as just the usize.
-            fn transparent() -> usize;
-
-            // Should warn, because there's a signedness conversion here:
-            fn transparent_incorrect() -> isize;
-            //~^ WARN `transparent_incorrect` redeclared with a different signature
-        }
-    }
-}
-
-mod missing_return_type {
-    mod a {
-        extern "C" {
-            fn missing_return_type() -> usize;
-        }
-    }
-
-    mod b {
-        extern "C" {
-            // This should output a warning because we can't assume that the first declaration is
-            // the correct one -- if this one is the correct one, then calling the usize-returning
-            // version would allow reads into uninitialised memory.
-            fn missing_return_type();
-            //~^ WARN `missing_return_type` redeclared with a different signature
-        }
-    }
-}
-
-mod non_zero_and_non_null {
-    mod a {
-        extern "C" {
-            fn non_zero_usize() -> core::num::NonZeroUsize;
-            fn non_null_ptr() -> core::ptr::NonNull<usize>;
-        }
-    }
-    mod b {
-        extern "C" {
-            // If there's a clash in either of these cases you're either gaining an incorrect
-            // invariant that the value is non-zero, or you're missing out on that invariant. Both
-            // cases are warning for, from both a caller-convenience and optimisation perspective.
-            fn non_zero_usize() -> usize;
-            //~^ WARN `non_zero_usize` redeclared with a different signature
-            fn non_null_ptr() -> *const usize;
-            //~^ WARN `non_null_ptr` redeclared with a different signature
-        }
-    }
-}
-
-// See #75739
-mod non_zero_transparent {
-    mod a1 {
-        use std::num::NonZeroUsize;
-        extern "C" {
-            fn f1() -> NonZeroUsize;
-        }
-    }
-
-    mod b1 {
-        #[repr(transparent)]
-        struct X(NonZeroUsize);
-        use std::num::NonZeroUsize;
-        extern "C" {
-            fn f1() -> X;
-        }
-    }
-
-    mod a2 {
-        use std::num::NonZeroUsize;
-        extern "C" {
-            fn f2() -> NonZeroUsize;
-        }
-    }
-
-    mod b2 {
-        #[repr(transparent)]
-        struct X1(NonZeroUsize);
-
-        #[repr(transparent)]
-        struct X(X1);
-
-        use std::num::NonZeroUsize;
-        extern "C" {
-            // Same case as above, but with two layers of newtyping.
-            fn f2() -> X;
-        }
-    }
-
-    mod a3 {
-        #[repr(transparent)]
-        struct X(core::ptr::NonNull<i32>);
-
-        use std::num::NonZeroUsize;
-        extern "C" {
-            fn f3() -> X;
-        }
-    }
-
-    mod b3 {
-        extern "C" {
-            fn f3() -> core::ptr::NonNull<i32>;
-        }
-    }
-
-    mod a4 {
-        #[repr(transparent)]
-        enum E {
-            X(std::num::NonZeroUsize),
-        }
-        extern "C" {
-            fn f4() -> E;
-        }
-    }
-
-    mod b4 {
-        extern "C" {
-            fn f4() -> std::num::NonZeroUsize;
-        }
-    }
-}
-
-mod null_optimised_enums {
-    mod a {
-        extern "C" {
-            fn option_non_zero_usize() -> usize;
-            fn option_non_zero_isize() -> isize;
-            fn option_non_null_ptr() -> *const usize;
-
-            fn option_non_zero_usize_incorrect() -> usize;
-            fn option_non_null_ptr_incorrect() -> *const usize;
-        }
-    }
-    mod b {
-        extern "C" {
-            // This should be allowed, because these conversions are guaranteed to be FFI-safe (see
-            // #60300)
-            fn option_non_zero_usize() -> Option<core::num::NonZeroUsize>;
-            fn option_non_zero_isize() -> Option<core::num::NonZeroIsize>;
-            fn option_non_null_ptr() -> Option<core::ptr::NonNull<usize>>;
-
-            // However, these should be incorrect (note isize instead of usize)
-            fn option_non_zero_usize_incorrect() -> isize;
-            //~^ WARN `option_non_zero_usize_incorrect` redeclared with a different signature
-            fn option_non_null_ptr_incorrect() -> *const isize;
-            //~^ WARN `option_non_null_ptr_incorrect` redeclared with a different signature
-        }
-    }
-}
-
-#[allow(improper_ctypes)]
-mod unknown_layout {
-    mod a {
-        extern "C" {
-            pub fn generic(l: Link<u32>);
-        }
-        pub struct Link<T> {
-            pub item: T,
-            pub next: *const Link<T>,
-        }
-    }
-
-    mod b {
-        extern "C" {
-            pub fn generic(l: Link<u32>);
-        }
-        pub struct Link<T> {
-            pub item: T,
-            pub next: *const Link<T>,
-        }
-    }
-}
-
-mod hidden_niche {
-    mod a {
-        extern "C" {
-            fn hidden_niche_transparent() -> usize;
-            fn hidden_niche_transparent_no_niche() -> usize;
-            fn hidden_niche_unsafe_cell() -> usize;
-        }
-    }
-    mod b {
-        use std::cell::UnsafeCell;
-        use std::num::NonZeroUsize;
-
-        #[repr(transparent)]
-        struct Transparent { x: NonZeroUsize }
-
-        #[repr(transparent)]
-        struct TransparentNoNiche { y: UnsafeCell<NonZeroUsize> }
-
-        extern "C" {
-            fn hidden_niche_transparent() -> Option<Transparent>;
-
-            fn hidden_niche_transparent_no_niche() -> Option<TransparentNoNiche>;
-            //~^ WARN redeclared with a different signature
-            //~| WARN block uses type `Option<TransparentNoNiche>`, which is not FFI-safe
-
-            fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZeroUsize>>;
-            //~^ WARN redeclared with a different signature
-            //~| WARN block uses type `Option<UnsafeCell<NonZeroUsize>>`, which is not FFI-safe
-        }
-    }
-}