Auto merge of #130200 - matthiaskrgr:rollup-2g4ijc5, r=matthiaskrgr

Rollup of 5 pull requests

Successful merges:

 - #130143 (miri-test-libstd: add missing BOOTSTRAP_ARGS)
 - #130173 (rustdoc: add two regression tests)
 - #130175 (`rustc_mir_transform` cleanups 3)
 - #130184 (coverage: Clean up terminology in counter creation)
 - #130185 (abi/compatibility test: remove tests inside repr(C) wrappers)

r? `@ghost`
`@rustbot` modify labels: rollup

4 files changed, 63 insertions, 41 deletions

diff --git a/tests/rustdoc-ui/projection-as-union-type-error.rs b/tests/rustdoc-ui/projection-as-union-type-error.rs
new file mode 100644
index 00000000000..d1d2e72249d
--- /dev/null
+++ b/tests/rustdoc-ui/projection-as-union-type-error.rs
@@ -0,0 +1,14 @@
+// Test to ensure that there is no ICE when normalizing a projection.
+// See also <https://github.com/rust-lang/rust/pull/106938>.
+// issue: rust-lang/rust#107872
+
+pub trait Identity {
+    type Identity;
+}
+
+pub type Foo = u8;
+
+pub union Bar {
+    a:  <Foo as Identity>::Identity, //~ ERROR the trait bound `u8: Identity` is not satisfied
+    b: u8,
+}
diff --git a/tests/rustdoc-ui/projection-as-union-type-error.stderr b/tests/rustdoc-ui/projection-as-union-type-error.stderr
new file mode 100644
index 00000000000..32598015864
--- /dev/null
+++ b/tests/rustdoc-ui/projection-as-union-type-error.stderr
@@ -0,0 +1,15 @@
+error[E0277]: the trait bound `u8: Identity` is not satisfied
+  --> $DIR/projection-as-union-type-error.rs:12:9
+   |
+LL |     a:  <Foo as Identity>::Identity,
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Identity` is not implemented for `u8`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/projection-as-union-type-error.rs:5:1
+   |
+LL | pub trait Identity {
+   | ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/rustdoc-ui/recursive-type-alias-impl-trait-declaration-too-subtle-2.rs b/tests/rustdoc-ui/recursive-type-alias-impl-trait-declaration-too-subtle-2.rs
new file mode 100644
index 00000000000..9f8053d5538
--- /dev/null
+++ b/tests/rustdoc-ui/recursive-type-alias-impl-trait-declaration-too-subtle-2.rs
@@ -0,0 +1,23 @@
+// issue: rust-lang/rust#98250
+//@ check-pass
+
+#![feature(type_alias_impl_trait)]
+
+mod foo {
+    pub type Foo = impl PartialEq<(Foo, i32)>;
+
+    fn foo() -> Foo {
+        super::Bar
+    }
+}
+use foo::Foo;
+
+struct Bar;
+
+impl PartialEq<(Foo, i32)> for Bar {
+    fn eq(&self, _other: &(Foo, i32)) -> bool {
+        true
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/abi/compatibility.rs b/tests/ui/abi/compatibility.rs
index d37e793d989..9600c8dff67 100644
--- a/tests/ui/abi/compatibility.rs
+++ b/tests/ui/abi/compatibility.rs
@@ -189,7 +189,7 @@ mod prelude {
 #[cfg(not(host))]
 use prelude::*;
 
-macro_rules! assert_abi_compatible {
+macro_rules! test_abi_compatible {
     ($name:ident, $t1:ty, $t2:ty) => {
         mod $name {
             use super::*;
@@ -213,16 +213,6 @@ impl Clone for Zst {
 }
 
 #[repr(C)]
-struct ReprC1<T: ?Sized>(T);
-#[repr(C)]
-struct ReprC2Int<T>(i32, T);
-#[repr(C)]
-struct ReprC2Float<T>(f32, T);
-#[repr(C)]
-struct ReprC4<T>(T, Vec<i32>, Zst, T);
-#[repr(C)]
-struct ReprC4Mixed<T>(T, f32, i32, T);
-#[repr(C)]
 enum ReprCEnum<T> {
     Variant1,
     Variant2(T),
@@ -233,23 +223,6 @@ union ReprCUnion<T> {
     something: ManuallyDrop<T>,
 }
 
-macro_rules! test_abi_compatible {
-    ($name:ident, $t1:ty, $t2:ty) => {
-        mod $name {
-            use super::*;
-            assert_abi_compatible!(plain, $t1, $t2);
-            // We also do some tests with differences in fields of `repr(C)` types.
-            assert_abi_compatible!(repr_c_1, ReprC1<$t1>, ReprC1<$t2>);
-            assert_abi_compatible!(repr_c_2_int, ReprC2Int<$t1>, ReprC2Int<$t2>);
-            assert_abi_compatible!(repr_c_2_float, ReprC2Float<$t1>, ReprC2Float<$t2>);
-            assert_abi_compatible!(repr_c_4, ReprC4<$t1>, ReprC4<$t2>);
-            assert_abi_compatible!(repr_c_4mixed, ReprC4Mixed<$t1>, ReprC4Mixed<$t2>);
-            assert_abi_compatible!(repr_c_enum, ReprCEnum<$t1>, ReprCEnum<$t2>);
-            assert_abi_compatible!(repr_c_union, ReprCUnion<$t1>, ReprCUnion<$t2>);
-        }
-    };
-}
-
 // Compatibility of pointers.
 test_abi_compatible!(ptr_mut, *const i32, *mut i32);
 test_abi_compatible!(ptr_pointee, *const i32, *const Vec<i32>);
@@ -268,7 +241,6 @@ test_abi_compatible!(isize_int, isize, i64);
 
 // Compatibility of 1-ZST.
 test_abi_compatible!(zst_unit, Zst, ());
-#[cfg(not(any(target_arch = "sparc64")))]
 test_abi_compatible!(zst_array, Zst, [u8; 0]);
 test_abi_compatible!(nonzero_int, NonZero<i32>, i32);
 
@@ -285,13 +257,13 @@ test_abi_compatible!(arc, Arc<i32>, *mut i32);
 
 // `repr(transparent)` compatibility.
 #[repr(transparent)]
-struct Wrapper1<T: ?Sized>(T);
+struct TransparentWrapper1<T: ?Sized>(T);
 #[repr(transparent)]
-struct Wrapper2<T: ?Sized>((), Zst, T);
+struct TransparentWrapper2<T: ?Sized>((), Zst, T);
 #[repr(transparent)]
-struct Wrapper3<T>(T, [u8; 0], PhantomData<u64>);
+struct TransparentWrapper3<T>(T, [u8; 0], PhantomData<u64>);
 #[repr(transparent)]
-union WrapperUnion<T> {
+union TransparentWrapperUnion<T> {
     nothing: (),
     something: ManuallyDrop<T>,
 }
@@ -300,10 +272,10 @@ macro_rules! test_transparent {
     ($name:ident, $t:ty) => {
         mod $name {
             use super::*;
-            test_abi_compatible!(wrap1, $t, Wrapper1<$t>);
-            test_abi_compatible!(wrap2, $t, Wrapper2<$t>);
-            test_abi_compatible!(wrap3, $t, Wrapper3<$t>);
-            test_abi_compatible!(wrap4, $t, WrapperUnion<$t>);
+            test_abi_compatible!(wrap1, $t, TransparentWrapper1<$t>);
+            test_abi_compatible!(wrap2, $t, TransparentWrapper2<$t>);
+            test_abi_compatible!(wrap3, $t, TransparentWrapper3<$t>);
+            test_abi_compatible!(wrap4, $t, TransparentWrapperUnion<$t>);
         }
     };
 }
@@ -342,10 +314,8 @@ macro_rules! test_transparent_unsized {
     ($name:ident, $t:ty) => {
         mod $name {
             use super::*;
-            assert_abi_compatible!(wrap1, $t, Wrapper1<$t>);
-            assert_abi_compatible!(wrap1_reprc, ReprC1<$t>, ReprC1<Wrapper1<$t>>);
-            assert_abi_compatible!(wrap2, $t, Wrapper2<$t>);
-            assert_abi_compatible!(wrap2_reprc, ReprC1<$t>, ReprC1<Wrapper2<$t>>);
+            test_abi_compatible!(wrap1, $t, TransparentWrapper1<$t>);
+            test_abi_compatible!(wrap2, $t, TransparentWrapper2<$t>);
         }
     };
 }