From 947be5f4316088f44cf2db69d137fd9afbfd7723 Mon Sep 17 00:00:00 2001
From: Tamir Duberstein <tamird@gmail.com>
Date: Thu, 17 Apr 2025 19:43:56 -0400
Subject: [PATCH 1/5] add CStr::display

The implementation delegates to `<ByteStr as Display>::fmt`.

Link: https://github.com/rust-lang/libs-team/issues/550
Link: https://github.com/rust-lang/rust/issues/139984.
---
 library/core/src/ffi/c_str.rs       | 24 ++++++++++++++++++++++++
 library/coretests/tests/ffi/cstr.rs |  6 ++++++
 library/coretests/tests/lib.rs      |  1 +
 3 files changed, 31 insertions(+)

diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs
index ac07c645c0195..c2799fa0b5c14 100644
--- a/library/core/src/ffi/c_str.rs
+++ b/library/core/src/ffi/c_str.rs
@@ -659,6 +659,30 @@ impl CStr {
         // instead of doing it afterwards.
         str::from_utf8(self.to_bytes())
     }
+
+    /// Returns an object that implements [`Display`] for safely printing a [`CStr`] that may
+    /// contain non-Unicode data.
+    ///
+    /// Behaves as if `self` were first lossily converted to a `str`, with invalid UTF-8 presented
+    /// as the Unicode replacement character: �.
+    ///
+    /// [`Display`]: fmt::Display
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(cstr_display)]
+    ///
+    /// let cstr = c"Hello, world!";
+    /// println!("{}", cstr.display());
+    /// ```
+    #[unstable(feature = "cstr_display", issue = "139984")]
+    #[must_use = "this does not display the `CStr`; \
+                  it returns an object that can be displayed"]
+    #[inline]
+    pub fn display(&self) -> impl fmt::Display {
+        crate::bstr::ByteStr::from_bytes(self.to_bytes())
+    }
 }
 
 // `.to_bytes()` representations are compared instead of the inner `[c_char]`s,
diff --git a/library/coretests/tests/ffi/cstr.rs b/library/coretests/tests/ffi/cstr.rs
index 0d85b22c585a1..dc34240cd99d2 100644
--- a/library/coretests/tests/ffi/cstr.rs
+++ b/library/coretests/tests/ffi/cstr.rs
@@ -19,3 +19,9 @@ fn debug() {
     let s = c"abc\x01\x02\n\xE2\x80\xA6\xFF";
     assert_eq!(format!("{s:?}"), r#""abc\x01\x02\n\xe2\x80\xa6\xff""#);
 }
+
+#[test]
+fn display() {
+    let s = c"\xf0\x28\x8c\xbc";
+    assert_eq!(format!("{}", s.display()), "�(��");
+}
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index b13012009815c..693b14ef76209 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -23,6 +23,7 @@
 #![feature(core_io_borrowed_buf)]
 #![feature(core_private_bignum)]
 #![feature(core_private_diy_float)]
+#![feature(cstr_display)]
 #![feature(dec2flt)]
 #![feature(duration_constants)]
 #![feature(duration_constructors)]

From d562c46be0bb599ae52db2f3bd0b5c4d7645bd70 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Tue, 27 May 2025 10:05:50 -0700
Subject: [PATCH 2/5] CI: Add cargo tests to aarch64-apple-darwin

This adds running of cargo's tests to the aarch64-apple-darwin job. The
reason for this is that tier-1 targets are ostensibly supposed to run
tests for host tools, but we are not doing that here. We do have fairly
good coverage in Cargo's CI, but we don't have much coverage of beta or
stable. I think it would be good to have a fallback here.
---
 src/ci/github-actions/jobs.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 1d175bd97e6a1..fbb3729f21da6 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -459,7 +459,9 @@ auto:
 
   - name: aarch64-apple
     env:
-      SCRIPT: ./x.py --stage 2 test --host=aarch64-apple-darwin --target=aarch64-apple-darwin
+      SCRIPT: >
+        ./x.py --stage 2 test --host=aarch64-apple-darwin --target=aarch64-apple-darwin &&
+        ./x.py --stage 2 test --host=aarch64-apple-darwin --target=aarch64-apple-darwin src/tools/cargo
       RUST_CONFIGURE_ARGS: >-
         --enable-sanitizers
         --enable-profiler

From 2a9363e59389dcfcb28146d4c8f4e4ce179ded77 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 26 May 2025 08:37:45 +0200
Subject: [PATCH 3/5] coretests: simplify test_float macro to derive more
 things from the type name

---
 library/coretests/tests/num/mod.rs | 236 +++++++++++++----------------
 1 file changed, 102 insertions(+), 134 deletions(-)

diff --git a/library/coretests/tests/num/mod.rs b/library/coretests/tests/num/mod.rs
index a6b75f7026604..cdde5b883aa9f 100644
--- a/library/coretests/tests/num/mod.rs
+++ b/library/coretests/tests/num/mod.rs
@@ -732,7 +732,7 @@ assume_usize_width! {
 }
 
 macro_rules! test_float {
-    ($modname: ident, $fassert: ident, $fty: ty, $inf: expr, $neginf: expr, $nan: expr, $min: expr, $max: expr, $min_pos: expr, $max_exp:expr) => {
+    ($modname: ident, $fassert: ident, $fty: ty) => {
         mod $modname {
             #[test]
             fn min() {
@@ -747,19 +747,19 @@ macro_rules! test_float {
                 $fassert!((-0.0 as $fty).min(9.0), -0.0);
                 $fassert!((-0.0 as $fty).min(9.0).is_sign_negative());
                 $fassert!((-0.0 as $fty).min(-9.0), -9.0);
-                $fassert!(($inf as $fty).min(9.0), 9.0);
-                $fassert!((9.0 as $fty).min($inf), 9.0);
-                $fassert!(($inf as $fty).min(-9.0), -9.0);
-                $fassert!((-9.0 as $fty).min($inf), -9.0);
-                $fassert!(($neginf as $fty).min(9.0), $neginf);
-                $fassert!((9.0 as $fty).min($neginf), $neginf);
-                $fassert!(($neginf as $fty).min(-9.0), $neginf);
-                $fassert!((-9.0 as $fty).min($neginf), $neginf);
-                $fassert!(($nan as $fty).min(9.0), 9.0);
-                $fassert!(($nan as $fty).min(-9.0), -9.0);
-                $fassert!((9.0 as $fty).min($nan), 9.0);
-                $fassert!((-9.0 as $fty).min($nan), -9.0);
-                $fassert!(($nan as $fty).min($nan).is_nan());
+                $fassert!((<$fty>::INFINITY as $fty).min(9.0), 9.0);
+                $fassert!((9.0 as $fty).min(<$fty>::INFINITY), 9.0);
+                $fassert!((<$fty>::INFINITY as $fty).min(-9.0), -9.0);
+                $fassert!((-9.0 as $fty).min(<$fty>::INFINITY), -9.0);
+                $fassert!((<$fty>::NEG_INFINITY as $fty).min(9.0), <$fty>::NEG_INFINITY);
+                $fassert!((9.0 as $fty).min(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
+                $fassert!((<$fty>::NEG_INFINITY as $fty).min(-9.0), <$fty>::NEG_INFINITY);
+                $fassert!((-9.0 as $fty).min(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
+                $fassert!((<$fty>::NAN as $fty).min(9.0), 9.0);
+                $fassert!((<$fty>::NAN as $fty).min(-9.0), -9.0);
+                $fassert!((9.0 as $fty).min(<$fty>::NAN), 9.0);
+                $fassert!((-9.0 as $fty).min(<$fty>::NAN), -9.0);
+                $fassert!((<$fty>::NAN as $fty).min(<$fty>::NAN).is_nan());
             }
             #[test]
             fn max() {
@@ -777,19 +777,19 @@ macro_rules! test_float {
                 $fassert!((0.0 as $fty).max(-9.0).is_sign_positive());
                 $fassert!((-0.0 as $fty).max(-9.0), -0.0);
                 $fassert!((-0.0 as $fty).max(-9.0).is_sign_negative());
-                $fassert!(($inf as $fty).max(9.0), $inf);
-                $fassert!((9.0 as $fty).max($inf), $inf);
-                $fassert!(($inf as $fty).max(-9.0), $inf);
-                $fassert!((-9.0 as $fty).max($inf), $inf);
-                $fassert!(($neginf as $fty).max(9.0), 9.0);
-                $fassert!((9.0 as $fty).max($neginf), 9.0);
-                $fassert!(($neginf as $fty).max(-9.0), -9.0);
-                $fassert!((-9.0 as $fty).max($neginf), -9.0);
-                $fassert!(($nan as $fty).max(9.0), 9.0);
-                $fassert!(($nan as $fty).max(-9.0), -9.0);
-                $fassert!((9.0 as $fty).max($nan), 9.0);
-                $fassert!((-9.0 as $fty).max($nan), -9.0);
-                $fassert!(($nan as $fty).max($nan).is_nan());
+                $fassert!((<$fty>::INFINITY as $fty).max(9.0), <$fty>::INFINITY);
+                $fassert!((9.0 as $fty).max(<$fty>::INFINITY), <$fty>::INFINITY);
+                $fassert!((<$fty>::INFINITY as $fty).max(-9.0), <$fty>::INFINITY);
+                $fassert!((-9.0 as $fty).max(<$fty>::INFINITY), <$fty>::INFINITY);
+                $fassert!((<$fty>::NEG_INFINITY as $fty).max(9.0), 9.0);
+                $fassert!((9.0 as $fty).max(<$fty>::NEG_INFINITY), 9.0);
+                $fassert!((<$fty>::NEG_INFINITY as $fty).max(-9.0), -9.0);
+                $fassert!((-9.0 as $fty).max(<$fty>::NEG_INFINITY), -9.0);
+                $fassert!((<$fty>::NAN as $fty).max(9.0), 9.0);
+                $fassert!((<$fty>::NAN as $fty).max(-9.0), -9.0);
+                $fassert!((9.0 as $fty).max(<$fty>::NAN), 9.0);
+                $fassert!((-9.0 as $fty).max(<$fty>::NAN), -9.0);
+                $fassert!((<$fty>::NAN as $fty).max(<$fty>::NAN).is_nan());
             }
             #[test]
             fn minimum() {
@@ -806,19 +806,19 @@ macro_rules! test_float {
                 $fassert!((-0.0 as $fty).minimum(9.0), -0.0);
                 $fassert!((-0.0 as $fty).minimum(9.0).is_sign_negative());
                 $fassert!((-0.0 as $fty).minimum(-9.0), -9.0);
-                $fassert!(($inf as $fty).minimum(9.0), 9.0);
-                $fassert!((9.0 as $fty).minimum($inf), 9.0);
-                $fassert!(($inf as $fty).minimum(-9.0), -9.0);
-                $fassert!((-9.0 as $fty).minimum($inf), -9.0);
-                $fassert!(($neginf as $fty).minimum(9.0), $neginf);
-                $fassert!((9.0 as $fty).minimum($neginf), $neginf);
-                $fassert!(($neginf as $fty).minimum(-9.0), $neginf);
-                $fassert!((-9.0 as $fty).minimum($neginf), $neginf);
-                $fassert!(($nan as $fty).minimum(9.0).is_nan());
-                $fassert!(($nan as $fty).minimum(-9.0).is_nan());
-                $fassert!((9.0 as $fty).minimum($nan).is_nan());
-                $fassert!((-9.0 as $fty).minimum($nan).is_nan());
-                $fassert!(($nan as $fty).minimum($nan).is_nan());
+                $fassert!((<$fty>::INFINITY as $fty).minimum(9.0), 9.0);
+                $fassert!((9.0 as $fty).minimum(<$fty>::INFINITY), 9.0);
+                $fassert!((<$fty>::INFINITY as $fty).minimum(-9.0), -9.0);
+                $fassert!((-9.0 as $fty).minimum(<$fty>::INFINITY), -9.0);
+                $fassert!((<$fty>::NEG_INFINITY as $fty).minimum(9.0), <$fty>::NEG_INFINITY);
+                $fassert!((9.0 as $fty).minimum(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
+                $fassert!((<$fty>::NEG_INFINITY as $fty).minimum(-9.0), <$fty>::NEG_INFINITY);
+                $fassert!((-9.0 as $fty).minimum(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
+                $fassert!((<$fty>::NAN as $fty).minimum(9.0).is_nan());
+                $fassert!((<$fty>::NAN as $fty).minimum(-9.0).is_nan());
+                $fassert!((9.0 as $fty).minimum(<$fty>::NAN).is_nan());
+                $fassert!((-9.0 as $fty).minimum(<$fty>::NAN).is_nan());
+                $fassert!((<$fty>::NAN as $fty).minimum(<$fty>::NAN).is_nan());
             }
             #[test]
             fn maximum() {
@@ -838,19 +838,19 @@ macro_rules! test_float {
                 $fassert!((0.0 as $fty).maximum(-9.0).is_sign_positive());
                 $fassert!((-0.0 as $fty).maximum(-9.0), -0.0);
                 $fassert!((-0.0 as $fty).maximum(-9.0).is_sign_negative());
-                $fassert!(($inf as $fty).maximum(9.0), $inf);
-                $fassert!((9.0 as $fty).maximum($inf), $inf);
-                $fassert!(($inf as $fty).maximum(-9.0), $inf);
-                $fassert!((-9.0 as $fty).maximum($inf), $inf);
-                $fassert!(($neginf as $fty).maximum(9.0), 9.0);
-                $fassert!((9.0 as $fty).maximum($neginf), 9.0);
-                $fassert!(($neginf as $fty).maximum(-9.0), -9.0);
-                $fassert!((-9.0 as $fty).maximum($neginf), -9.0);
-                $fassert!(($nan as $fty).maximum(9.0).is_nan());
-                $fassert!(($nan as $fty).maximum(-9.0).is_nan());
-                $fassert!((9.0 as $fty).maximum($nan).is_nan());
-                $fassert!((-9.0 as $fty).maximum($nan).is_nan());
-                $fassert!(($nan as $fty).maximum($nan).is_nan());
+                $fassert!((<$fty>::INFINITY as $fty).maximum(9.0), <$fty>::INFINITY);
+                $fassert!((9.0 as $fty).maximum(<$fty>::INFINITY), <$fty>::INFINITY);
+                $fassert!((<$fty>::INFINITY as $fty).maximum(-9.0), <$fty>::INFINITY);
+                $fassert!((-9.0 as $fty).maximum(<$fty>::INFINITY), <$fty>::INFINITY);
+                $fassert!((<$fty>::NEG_INFINITY as $fty).maximum(9.0), 9.0);
+                $fassert!((9.0 as $fty).maximum(<$fty>::NEG_INFINITY), 9.0);
+                $fassert!((<$fty>::NEG_INFINITY as $fty).maximum(-9.0), -9.0);
+                $fassert!((-9.0 as $fty).maximum(<$fty>::NEG_INFINITY), -9.0);
+                $fassert!((<$fty>::NAN as $fty).maximum(9.0).is_nan());
+                $fassert!((<$fty>::NAN as $fty).maximum(-9.0).is_nan());
+                $fassert!((9.0 as $fty).maximum(<$fty>::NAN).is_nan());
+                $fassert!((-9.0 as $fty).maximum(<$fty>::NAN).is_nan());
+                $fassert!((<$fty>::NAN as $fty).maximum(<$fty>::NAN).is_nan());
             }
             #[test]
             fn midpoint() {
@@ -863,38 +863,50 @@ macro_rules! test_float {
                 $fassert!((0.0 as $fty).midpoint(0.0), 0.0);
                 $fassert!((-0.0 as $fty).midpoint(-0.0), -0.0);
                 $fassert!((-5.0 as $fty).midpoint(5.0), 0.0);
-                $fassert!(($max as $fty).midpoint($min), 0.0);
-                $fassert!(($min as $fty).midpoint($max), -0.0);
-                $fassert!(($max as $fty).midpoint($min_pos), $max / 2.);
-                $fassert!((-$max as $fty).midpoint($min_pos), -$max / 2.);
-                $fassert!(($max as $fty).midpoint(-$min_pos), $max / 2.);
-                $fassert!((-$max as $fty).midpoint(-$min_pos), -$max / 2.);
-                $fassert!(($min_pos as $fty).midpoint($max), $max / 2.);
-                $fassert!(($min_pos as $fty).midpoint(-$max), -$max / 2.);
-                $fassert!((-$min_pos as $fty).midpoint($max), $max / 2.);
-                $fassert!((-$min_pos as $fty).midpoint(-$max), -$max / 2.);
-                $fassert!(($max as $fty).midpoint($max), $max);
-                $fassert!(($min_pos as $fty).midpoint($min_pos), $min_pos);
-                $fassert!((-$min_pos as $fty).midpoint(-$min_pos), -$min_pos);
-                $fassert!(($max as $fty).midpoint(5.0), $max / 2.0 + 2.5);
-                $fassert!(($max as $fty).midpoint(-5.0), $max / 2.0 - 2.5);
-                $fassert!(($inf as $fty).midpoint($inf), $inf);
-                $fassert!(($neginf as $fty).midpoint($neginf), $neginf);
-                $fassert!(($nan as $fty).midpoint(1.0).is_nan());
-                $fassert!((1.0 as $fty).midpoint($nan).is_nan());
-                $fassert!(($nan as $fty).midpoint($nan).is_nan());
+                $fassert!((<$fty>::MAX as $fty).midpoint(<$fty>::MIN), 0.0);
+                $fassert!((<$fty>::MIN as $fty).midpoint(<$fty>::MAX), -0.0);
+                $fassert!((<$fty>::MAX as $fty).midpoint(<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
+                $fassert!((-<$fty>::MAX as $fty).midpoint(<$fty>::MIN_POSITIVE), -<$fty>::MAX / 2.);
+                $fassert!((<$fty>::MAX as $fty).midpoint(-<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
+                $fassert!(
+                    (-<$fty>::MAX as $fty).midpoint(-<$fty>::MIN_POSITIVE),
+                    -<$fty>::MAX / 2.
+                );
+                $fassert!((<$fty>::MIN_POSITIVE).midpoint(<$fty>::MAX), <$fty>::MAX / 2.);
+                $fassert!((<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MAX), -<$fty>::MAX / 2.);
+                $fassert!((-<$fty>::MIN_POSITIVE).midpoint(<$fty>::MAX), <$fty>::MAX / 2.);
+                $fassert!((-<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MAX), -<$fty>::MAX / 2.);
+                $fassert!((<$fty>::MAX as $fty).midpoint(<$fty>::MAX), <$fty>::MAX);
+                $fassert!(
+                    (<$fty>::MIN_POSITIVE).midpoint(<$fty>::MIN_POSITIVE),
+                    <$fty>::MIN_POSITIVE
+                );
+                $fassert!(
+                    (-<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MIN_POSITIVE),
+                    -<$fty>::MIN_POSITIVE
+                );
+                $fassert!((<$fty>::MAX as $fty).midpoint(5.0), <$fty>::MAX / 2.0 + 2.5);
+                $fassert!((<$fty>::MAX as $fty).midpoint(-5.0), <$fty>::MAX / 2.0 - 2.5);
+                $fassert!((<$fty>::INFINITY as $fty).midpoint(<$fty>::INFINITY), <$fty>::INFINITY);
+                $fassert!(
+                    (<$fty>::NEG_INFINITY as $fty).midpoint(<$fty>::NEG_INFINITY),
+                    <$fty>::NEG_INFINITY
+                );
+                $fassert!((<$fty>::NAN as $fty).midpoint(1.0).is_nan());
+                $fassert!((1.0 as $fty).midpoint(<$fty>::NAN).is_nan());
+                $fassert!((<$fty>::NAN as $fty).midpoint(<$fty>::NAN).is_nan());
 
                 // test if large differences in magnitude are still correctly computed.
                 // NOTE: that because of how small x and y are, x + y can never overflow
                 // so (x + y) / 2.0 is always correct
                 // in particular, `2.pow(i)` will  never be at the max exponent, so it could
                 // be safely doubled, while j is significantly smaller.
-                for i in $max_exp.saturating_sub(64)..$max_exp {
+                for i in <$fty>::MAX_EXP.saturating_sub(64)..<$fty>::MAX_EXP {
                     for j in 0..64u8 {
                         let large = <$fty>::from(2.0f32).powi(i);
                         // a much smaller number, such that there is no chance of overflow to test
                         // potential double rounding in midpoint's implementation.
-                        let small = <$fty>::from(2.0f32).powi($max_exp - 1)
+                        let small = (2.0 as $fty).powi(<$fty>::MAX_EXP - 1)
                             * <$fty>::EPSILON
                             * <$fty>::from(j);
 
@@ -908,21 +920,21 @@ macro_rules! test_float {
             #[test]
             fn rem_euclid() {
                 // FIXME: Use $fassert when rem_euclid becomes const
-                assert!($inf.rem_euclid((42.0 as $fty)).is_nan());
-                assert_eq!((42.0 as $fty).rem_euclid($inf), (42.0 as $fty));
-                assert!((42.0 as $fty).rem_euclid($nan).is_nan());
-                assert!($inf.rem_euclid($inf).is_nan());
-                assert!($inf.rem_euclid($nan).is_nan());
-                assert!($nan.rem_euclid($inf).is_nan());
+                assert!(<$fty>::INFINITY.rem_euclid((42.0 as $fty)).is_nan());
+                assert_eq!((42.0 as $fty).rem_euclid(<$fty>::INFINITY), (42.0 as $fty));
+                assert!((42.0 as $fty).rem_euclid(<$fty>::NAN).is_nan());
+                assert!(<$fty>::INFINITY.rem_euclid(<$fty>::INFINITY).is_nan());
+                assert!(<$fty>::INFINITY.rem_euclid(<$fty>::NAN).is_nan());
+                assert!(<$fty>::NAN.rem_euclid(<$fty>::INFINITY).is_nan());
             }
             #[test]
             fn div_euclid() {
                 // FIXME: Use $fassert when div_euclid becomes const
-                assert_eq!((42.0 as $fty).div_euclid($inf), 0.0);
-                assert!((42.0 as $fty).div_euclid($nan).is_nan());
-                assert!($inf.div_euclid($inf).is_nan());
-                assert!($inf.div_euclid($nan).is_nan());
-                assert!($nan.div_euclid($inf).is_nan());
+                assert_eq!((42.0 as $fty).div_euclid(<$fty>::INFINITY), 0.0);
+                assert!((42.0 as $fty).div_euclid(<$fty>::NAN).is_nan());
+                assert!(<$fty>::INFINITY.div_euclid(<$fty>::INFINITY).is_nan());
+                assert!(<$fty>::INFINITY.div_euclid(<$fty>::NAN).is_nan());
+                assert!(<$fty>::NAN.div_euclid(<$fty>::INFINITY).is_nan());
             }
         }
     };
@@ -948,51 +960,7 @@ macro_rules! float_const_assert {
     };
 }
 
-test_float!(
-    f32,
-    float_assert,
-    f32,
-    f32::INFINITY,
-    f32::NEG_INFINITY,
-    f32::NAN,
-    f32::MIN,
-    f32::MAX,
-    f32::MIN_POSITIVE,
-    f32::MAX_EXP
-);
-test_float!(
-    f32_const,
-    float_const_assert,
-    f32,
-    f32::INFINITY,
-    f32::NEG_INFINITY,
-    f32::NAN,
-    f32::MIN,
-    f32::MAX,
-    f32::MIN_POSITIVE,
-    f32::MAX_EXP
-);
-test_float!(
-    f64,
-    float_assert,
-    f64,
-    f64::INFINITY,
-    f64::NEG_INFINITY,
-    f64::NAN,
-    f64::MIN,
-    f64::MAX,
-    f64::MIN_POSITIVE,
-    f64::MAX_EXP
-);
-test_float!(
-    f64_const,
-    float_const_assert,
-    f64,
-    f64::INFINITY,
-    f64::NEG_INFINITY,
-    f64::NAN,
-    f64::MIN,
-    f64::MAX,
-    f64::MIN_POSITIVE,
-    f64::MAX_EXP
-);
+test_float!(f32, float_assert, f32);
+test_float!(f32_const, float_const_assert, f32);
+test_float!(f64, float_assert, f64);
+test_float!(f64_const, float_const_assert, f64);

From e0ff77aea5c723934296b8a54d485dd11fbc4d6d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 26 May 2025 08:42:36 +0200
Subject: [PATCH 4/5] coretests: add abs() and copysign() tests, and remove
 now-unnecessary ui test

---
 library/coretests/tests/num/mod.rs          | 101 +++++++++++---------
 tests/ui/consts/const-eval/float_methods.rs |  46 ---------
 2 files changed, 56 insertions(+), 91 deletions(-)
 delete mode 100644 tests/ui/consts/const-eval/float_methods.rs

diff --git a/library/coretests/tests/num/mod.rs b/library/coretests/tests/num/mod.rs
index cdde5b883aa9f..1212d36a1b15c 100644
--- a/library/coretests/tests/num/mod.rs
+++ b/library/coretests/tests/num/mod.rs
@@ -747,19 +747,19 @@ macro_rules! test_float {
                 $fassert!((-0.0 as $fty).min(9.0), -0.0);
                 $fassert!((-0.0 as $fty).min(9.0).is_sign_negative());
                 $fassert!((-0.0 as $fty).min(-9.0), -9.0);
-                $fassert!((<$fty>::INFINITY as $fty).min(9.0), 9.0);
+                $fassert!(<$fty>::INFINITY.min(9.0), 9.0);
                 $fassert!((9.0 as $fty).min(<$fty>::INFINITY), 9.0);
-                $fassert!((<$fty>::INFINITY as $fty).min(-9.0), -9.0);
+                $fassert!(<$fty>::INFINITY.min(-9.0), -9.0);
                 $fassert!((-9.0 as $fty).min(<$fty>::INFINITY), -9.0);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).min(9.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.min(9.0), <$fty>::NEG_INFINITY);
                 $fassert!((9.0 as $fty).min(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).min(-9.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.min(-9.0), <$fty>::NEG_INFINITY);
                 $fassert!((-9.0 as $fty).min(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
-                $fassert!((<$fty>::NAN as $fty).min(9.0), 9.0);
-                $fassert!((<$fty>::NAN as $fty).min(-9.0), -9.0);
+                $fassert!(<$fty>::NAN.min(9.0), 9.0);
+                $fassert!(<$fty>::NAN.min(-9.0), -9.0);
                 $fassert!((9.0 as $fty).min(<$fty>::NAN), 9.0);
                 $fassert!((-9.0 as $fty).min(<$fty>::NAN), -9.0);
-                $fassert!((<$fty>::NAN as $fty).min(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.min(<$fty>::NAN).is_nan());
             }
             #[test]
             fn max() {
@@ -777,19 +777,19 @@ macro_rules! test_float {
                 $fassert!((0.0 as $fty).max(-9.0).is_sign_positive());
                 $fassert!((-0.0 as $fty).max(-9.0), -0.0);
                 $fassert!((-0.0 as $fty).max(-9.0).is_sign_negative());
-                $fassert!((<$fty>::INFINITY as $fty).max(9.0), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.max(9.0), <$fty>::INFINITY);
                 $fassert!((9.0 as $fty).max(<$fty>::INFINITY), <$fty>::INFINITY);
-                $fassert!((<$fty>::INFINITY as $fty).max(-9.0), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.max(-9.0), <$fty>::INFINITY);
                 $fassert!((-9.0 as $fty).max(<$fty>::INFINITY), <$fty>::INFINITY);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).max(9.0), 9.0);
+                $fassert!(<$fty>::NEG_INFINITY.max(9.0), 9.0);
                 $fassert!((9.0 as $fty).max(<$fty>::NEG_INFINITY), 9.0);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).max(-9.0), -9.0);
+                $fassert!(<$fty>::NEG_INFINITY.max(-9.0), -9.0);
                 $fassert!((-9.0 as $fty).max(<$fty>::NEG_INFINITY), -9.0);
-                $fassert!((<$fty>::NAN as $fty).max(9.0), 9.0);
-                $fassert!((<$fty>::NAN as $fty).max(-9.0), -9.0);
+                $fassert!(<$fty>::NAN.max(9.0), 9.0);
+                $fassert!(<$fty>::NAN.max(-9.0), -9.0);
                 $fassert!((9.0 as $fty).max(<$fty>::NAN), 9.0);
                 $fassert!((-9.0 as $fty).max(<$fty>::NAN), -9.0);
-                $fassert!((<$fty>::NAN as $fty).max(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.max(<$fty>::NAN).is_nan());
             }
             #[test]
             fn minimum() {
@@ -806,19 +806,19 @@ macro_rules! test_float {
                 $fassert!((-0.0 as $fty).minimum(9.0), -0.0);
                 $fassert!((-0.0 as $fty).minimum(9.0).is_sign_negative());
                 $fassert!((-0.0 as $fty).minimum(-9.0), -9.0);
-                $fassert!((<$fty>::INFINITY as $fty).minimum(9.0), 9.0);
+                $fassert!(<$fty>::INFINITY.minimum(9.0), 9.0);
                 $fassert!((9.0 as $fty).minimum(<$fty>::INFINITY), 9.0);
-                $fassert!((<$fty>::INFINITY as $fty).minimum(-9.0), -9.0);
+                $fassert!(<$fty>::INFINITY.minimum(-9.0), -9.0);
                 $fassert!((-9.0 as $fty).minimum(<$fty>::INFINITY), -9.0);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).minimum(9.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.minimum(9.0), <$fty>::NEG_INFINITY);
                 $fassert!((9.0 as $fty).minimum(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).minimum(-9.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.minimum(-9.0), <$fty>::NEG_INFINITY);
                 $fassert!((-9.0 as $fty).minimum(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
-                $fassert!((<$fty>::NAN as $fty).minimum(9.0).is_nan());
-                $fassert!((<$fty>::NAN as $fty).minimum(-9.0).is_nan());
+                $fassert!(<$fty>::NAN.minimum(9.0).is_nan());
+                $fassert!(<$fty>::NAN.minimum(-9.0).is_nan());
                 $fassert!((9.0 as $fty).minimum(<$fty>::NAN).is_nan());
                 $fassert!((-9.0 as $fty).minimum(<$fty>::NAN).is_nan());
-                $fassert!((<$fty>::NAN as $fty).minimum(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.minimum(<$fty>::NAN).is_nan());
             }
             #[test]
             fn maximum() {
@@ -838,19 +838,19 @@ macro_rules! test_float {
                 $fassert!((0.0 as $fty).maximum(-9.0).is_sign_positive());
                 $fassert!((-0.0 as $fty).maximum(-9.0), -0.0);
                 $fassert!((-0.0 as $fty).maximum(-9.0).is_sign_negative());
-                $fassert!((<$fty>::INFINITY as $fty).maximum(9.0), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.maximum(9.0), <$fty>::INFINITY);
                 $fassert!((9.0 as $fty).maximum(<$fty>::INFINITY), <$fty>::INFINITY);
-                $fassert!((<$fty>::INFINITY as $fty).maximum(-9.0), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.maximum(-9.0), <$fty>::INFINITY);
                 $fassert!((-9.0 as $fty).maximum(<$fty>::INFINITY), <$fty>::INFINITY);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).maximum(9.0), 9.0);
+                $fassert!(<$fty>::NEG_INFINITY.maximum(9.0), 9.0);
                 $fassert!((9.0 as $fty).maximum(<$fty>::NEG_INFINITY), 9.0);
-                $fassert!((<$fty>::NEG_INFINITY as $fty).maximum(-9.0), -9.0);
+                $fassert!(<$fty>::NEG_INFINITY.maximum(-9.0), -9.0);
                 $fassert!((-9.0 as $fty).maximum(<$fty>::NEG_INFINITY), -9.0);
-                $fassert!((<$fty>::NAN as $fty).maximum(9.0).is_nan());
-                $fassert!((<$fty>::NAN as $fty).maximum(-9.0).is_nan());
+                $fassert!(<$fty>::NAN.maximum(9.0).is_nan());
+                $fassert!(<$fty>::NAN.maximum(-9.0).is_nan());
                 $fassert!((9.0 as $fty).maximum(<$fty>::NAN).is_nan());
                 $fassert!((-9.0 as $fty).maximum(<$fty>::NAN).is_nan());
-                $fassert!((<$fty>::NAN as $fty).maximum(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.maximum(<$fty>::NAN).is_nan());
             }
             #[test]
             fn midpoint() {
@@ -863,20 +863,17 @@ macro_rules! test_float {
                 $fassert!((0.0 as $fty).midpoint(0.0), 0.0);
                 $fassert!((-0.0 as $fty).midpoint(-0.0), -0.0);
                 $fassert!((-5.0 as $fty).midpoint(5.0), 0.0);
-                $fassert!((<$fty>::MAX as $fty).midpoint(<$fty>::MIN), 0.0);
-                $fassert!((<$fty>::MIN as $fty).midpoint(<$fty>::MAX), -0.0);
-                $fassert!((<$fty>::MAX as $fty).midpoint(<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
-                $fassert!((-<$fty>::MAX as $fty).midpoint(<$fty>::MIN_POSITIVE), -<$fty>::MAX / 2.);
-                $fassert!((<$fty>::MAX as $fty).midpoint(-<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
-                $fassert!(
-                    (-<$fty>::MAX as $fty).midpoint(-<$fty>::MIN_POSITIVE),
-                    -<$fty>::MAX / 2.
-                );
+                $fassert!(<$fty>::MAX.midpoint(<$fty>::MIN), 0.0);
+                $fassert!(<$fty>::MIN.midpoint(<$fty>::MAX), -0.0);
+                $fassert!(<$fty>::MAX.midpoint(<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
+                $fassert!((-<$fty>::MAX).midpoint(<$fty>::MIN_POSITIVE), -<$fty>::MAX / 2.);
+                $fassert!(<$fty>::MAX.midpoint(-<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
+                $fassert!((-<$fty>::MAX).midpoint(-<$fty>::MIN_POSITIVE), -<$fty>::MAX / 2.);
                 $fassert!((<$fty>::MIN_POSITIVE).midpoint(<$fty>::MAX), <$fty>::MAX / 2.);
                 $fassert!((<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MAX), -<$fty>::MAX / 2.);
                 $fassert!((-<$fty>::MIN_POSITIVE).midpoint(<$fty>::MAX), <$fty>::MAX / 2.);
                 $fassert!((-<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MAX), -<$fty>::MAX / 2.);
-                $fassert!((<$fty>::MAX as $fty).midpoint(<$fty>::MAX), <$fty>::MAX);
+                $fassert!(<$fty>::MAX.midpoint(<$fty>::MAX), <$fty>::MAX);
                 $fassert!(
                     (<$fty>::MIN_POSITIVE).midpoint(<$fty>::MIN_POSITIVE),
                     <$fty>::MIN_POSITIVE
@@ -885,16 +882,16 @@ macro_rules! test_float {
                     (-<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MIN_POSITIVE),
                     -<$fty>::MIN_POSITIVE
                 );
-                $fassert!((<$fty>::MAX as $fty).midpoint(5.0), <$fty>::MAX / 2.0 + 2.5);
-                $fassert!((<$fty>::MAX as $fty).midpoint(-5.0), <$fty>::MAX / 2.0 - 2.5);
-                $fassert!((<$fty>::INFINITY as $fty).midpoint(<$fty>::INFINITY), <$fty>::INFINITY);
+                $fassert!(<$fty>::MAX.midpoint(5.0), <$fty>::MAX / 2.0 + 2.5);
+                $fassert!(<$fty>::MAX.midpoint(-5.0), <$fty>::MAX / 2.0 - 2.5);
+                $fassert!(<$fty>::INFINITY.midpoint(<$fty>::INFINITY), <$fty>::INFINITY);
                 $fassert!(
-                    (<$fty>::NEG_INFINITY as $fty).midpoint(<$fty>::NEG_INFINITY),
+                    <$fty>::NEG_INFINITY.midpoint(<$fty>::NEG_INFINITY),
                     <$fty>::NEG_INFINITY
                 );
-                $fassert!((<$fty>::NAN as $fty).midpoint(1.0).is_nan());
+                $fassert!(<$fty>::NAN.midpoint(1.0).is_nan());
                 $fassert!((1.0 as $fty).midpoint(<$fty>::NAN).is_nan());
-                $fassert!((<$fty>::NAN as $fty).midpoint(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.midpoint(<$fty>::NAN).is_nan());
 
                 // test if large differences in magnitude are still correctly computed.
                 // NOTE: that because of how small x and y are, x + y can never overflow
@@ -903,7 +900,7 @@ macro_rules! test_float {
                 // be safely doubled, while j is significantly smaller.
                 for i in <$fty>::MAX_EXP.saturating_sub(64)..<$fty>::MAX_EXP {
                     for j in 0..64u8 {
-                        let large = <$fty>::from(2.0f32).powi(i);
+                        let large = (2.0 as $fty).powi(i);
                         // a much smaller number, such that there is no chance of overflow to test
                         // potential double rounding in midpoint's implementation.
                         let small = (2.0 as $fty).powi(<$fty>::MAX_EXP - 1)
@@ -918,6 +915,20 @@ macro_rules! test_float {
                 }
             }
             #[test]
+            fn abs() {
+                $fassert!((-1.0 as $fty).abs(), 1.0);
+                $fassert!((1.0 as $fty).abs(), 1.0);
+                $fassert!(<$fty>::NEG_INFINITY.abs(), <$fty>::INFINITY);
+                $fassert!(<$fty>::INFINITY.abs(), <$fty>::INFINITY);
+            }
+            #[test]
+            fn copysign() {
+                $fassert!((1.0 as $fty).copysign(-2.0), -1.0);
+                $fassert!((-1.0 as $fty).copysign(2.0), 1.0);
+                $fassert!(<$fty>::INFINITY.copysign(-0.0), <$fty>::NEG_INFINITY);
+                $fassert!(<$fty>::NEG_INFINITY.copysign(0.0), <$fty>::INFINITY);
+            }
+            #[test]
             fn rem_euclid() {
                 // FIXME: Use $fassert when rem_euclid becomes const
                 assert!(<$fty>::INFINITY.rem_euclid((42.0 as $fty)).is_nan());
diff --git a/tests/ui/consts/const-eval/float_methods.rs b/tests/ui/consts/const-eval/float_methods.rs
deleted file mode 100644
index 853f75825ac24..0000000000000
--- a/tests/ui/consts/const-eval/float_methods.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//@ run-pass
-//! Tests the float intrinsics: min, max, abs, copysign
-
-#![feature(f16, f128)]
-
-const F16_MIN: f16 = 1.0_f16.min(0.5_f16);
-const F16_MAX: f16 = 1.0_f16.max(0.5_f16);
-const F16_ABS: f16 = (-1.0_f16).abs();
-const F16_COPYSIGN: f16 = 1.0_f16.copysign(-2.0_f16);
-
-const F32_MIN: f32 = 1.0_f32.min(0.5_f32);
-const F32_MAX: f32 = 1.0_f32.max(0.5_f32);
-const F32_ABS: f32 = (-1.0_f32).abs();
-const F32_COPYSIGN: f32 = 1.0_f32.copysign(-2.0_f32);
-
-const F64_MIN: f64 = 1.0_f64.min(0.5_f64);
-const F64_MAX: f64 = 1.0_f64.max(0.5_f64);
-const F64_ABS: f64 = (-1.0_f64).abs();
-const F64_COPYSIGN: f64 = 1.0_f64.copysign(-2.0_f64);
-
-const F128_MIN: f128 = 1.0_f128.min(0.5_f128);
-const F128_MAX: f128 = 1.0_f128.max(0.5_f128);
-const F128_ABS: f128 = (-1.0_f128).abs();
-const F128_COPYSIGN: f128 = 1.0_f128.copysign(-2.0_f128);
-
-fn main() {
-    assert_eq!(F16_MIN, 0.5);
-    assert_eq!(F16_MAX, 1.0);
-    assert_eq!(F16_ABS, 1.0);
-    assert_eq!(F16_COPYSIGN, -1.0);
-
-    assert_eq!(F32_MIN, 0.5);
-    assert_eq!(F32_MAX, 1.0);
-    assert_eq!(F32_ABS, 1.0);
-    assert_eq!(F32_COPYSIGN, -1.0);
-
-    assert_eq!(F64_MIN, 0.5);
-    assert_eq!(F64_MAX, 1.0);
-    assert_eq!(F64_ABS, 1.0);
-    assert_eq!(F64_COPYSIGN, -1.0);
-
-    assert_eq!(F128_MIN, 0.5);
-    assert_eq!(F128_MAX, 1.0);
-    assert_eq!(F128_ABS, 1.0);
-    assert_eq!(F128_COPYSIGN, -1.0);
-}

From 467eeabbb5e876abc6bf552670199695172ad07a Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Sun, 9 Mar 2025 19:03:12 +0000
Subject: [PATCH 5/5] Stabilise `repr128`

---
 .../src/error_codes/E0658.md                  |  12 +-
 compiler/rustc_feature/src/accepted.rs        |   2 +
 compiler/rustc_feature/src/unstable.rs        |   2 -
 .../rustc_hir_analysis/src/check/check.rs     |  15 +-
 .../src/language-features/repr128.md          |  18 --
 .../tests/ui/auxiliary/proc_macro_attr.rs     |   3 +-
 .../tests/ui/auxiliary/proc_macro_derive.rs   |   3 +-
 src/tools/clippy/tests/ui/cast.rs             |   2 -
 src/tools/clippy/tests/ui/cast.stderr         | 184 +++++++++---------
 .../ui/crashes/auxiliary/proc_macro_crash.rs  |   3 -
 src/tools/tidy/src/issues.txt                 |   1 -
 tests/codegen/enum/enum-u128.rs               |   3 -
 tests/debuginfo/msvc-pretty-enums.rs          |   2 -
 tests/mir-opt/enum_opt.rs                     |   2 -
 tests/mir-opt/matches_reduce_branches.rs      |   1 -
 tests/run-make/repr128-dwarf/main.rs          |   2 -
 .../rustdoc-json/enums/discriminant/limits.rs |   3 -
 .../ui/enum-discriminant/discriminant_size.rs |   3 +-
 .../discriminant_size.stderr                  |  11 --
 tests/ui/enum-discriminant/issue-43398.stderr |  11 --
 .../issue-70509-partial_eq.rs                 |   2 -
 .../issue-70509-partial_eq.stderr             |  11 --
 ...> repr128-get-discriminant-issue-43398.rs} |   2 -
 tests/ui/enum-discriminant/repr128.rs         |   3 +-
 tests/ui/enum-discriminant/repr128.stderr     |  11 --
 tests/ui/error-codes/E0658.rs                 |   5 +-
 tests/ui/error-codes/E0658.stderr             |  11 +-
 .../ui/feature-gates/feature-gate-repr128.rs  |   6 -
 .../feature-gates/feature-gate-repr128.stderr |  13 --
 tests/ui/lint/lint-ctypes-enum.rs             |   2 -
 tests/ui/lint/lint-ctypes-enum.stderr         |  68 +++----
 .../enums/repr/should_handle_all.rs           |   3 +-
 32 files changed, 143 insertions(+), 277 deletions(-)
 delete mode 100644 src/doc/unstable-book/src/language-features/repr128.md
 delete mode 100644 tests/ui/enum-discriminant/discriminant_size.stderr
 delete mode 100644 tests/ui/enum-discriminant/issue-43398.stderr
 delete mode 100644 tests/ui/enum-discriminant/issue-70509-partial_eq.stderr
 rename tests/ui/enum-discriminant/{issue-43398.rs => repr128-get-discriminant-issue-43398.rs} (75%)
 delete mode 100644 tests/ui/enum-discriminant/repr128.stderr
 delete mode 100644 tests/ui/feature-gates/feature-gate-repr128.rs
 delete mode 100644 tests/ui/feature-gates/feature-gate-repr128.stderr

diff --git a/compiler/rustc_error_codes/src/error_codes/E0658.md b/compiler/rustc_error_codes/src/error_codes/E0658.md
index 24245a38ae07f..65c82e4fb6ef5 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0658.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0658.md
@@ -3,10 +3,7 @@ An unstable feature was used.
 Erroneous code example:
 
 ```compile_fail,E0658
-#[repr(u128)] // error: use of unstable library feature 'repr128'
-enum Foo {
-    Bar(u64),
-}
+use std::intrinsics; // error: use of unstable library feature `core_intrinsics`
 ```
 
 If you're using a stable or a beta version of rustc, you won't be able to use
@@ -17,12 +14,9 @@ If you're using a nightly version of rustc, just add the corresponding feature
 to be able to use it:
 
 ```
-#![feature(repr128)]
+#![feature(core_intrinsics)]
 
-#[repr(u128)] // ok!
-enum Foo {
-    Bar(u64),
-}
+use std::intrinsics; // ok!
 ```
 
 [rustup]: https://rust-lang.github.io/rustup/concepts/channels.html
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 820af9ac84b2c..ffa6ffb40b61a 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -360,6 +360,8 @@ declare_features! (
     (accepted, relaxed_adts, "1.19.0", Some(35626)),
     /// Lessens the requirements for structs to implement `Unsize`.
     (accepted, relaxed_struct_unsize, "1.58.0", Some(81793)),
+    /// Allows the `#[repr(i128)]` attribute for enums.
+    (accepted, repr128, "CURRENT_RUSTC_VERSION", Some(56071)),
     /// Allows `repr(align(16))` struct attribute (RFC 1358).
     (accepted, repr_align, "1.25.0", Some(33626)),
     /// Allows using `#[repr(align(X))]` on enums with equivalent semantics
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 3e408a031118d..b46eac6d8a602 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -621,8 +621,6 @@ declare_features! (
     (incomplete, ref_pat_eat_one_layer_2024_structural, "1.81.0", Some(123076)),
     /// Allows using the `#[register_tool]` attribute.
     (unstable, register_tool, "1.41.0", Some(66079)),
-    /// Allows the `#[repr(i128)]` attribute for enums.
-    (incomplete, repr128, "1.16.0", Some(56071)),
     /// Allows `repr(simd)` and importing the various simd intrinsics.
     (unstable, repr_simd, "1.4.0", Some(27731)),
     /// Allows bounding the return type of AFIT/RPITIT.
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index db7a5fe789767..846eacce9e10b 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -18,7 +18,7 @@ use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
 use rustc_middle::middle::stability::EvalResult;
 use rustc_middle::ty::error::TypeErrorToStringExt;
 use rustc_middle::ty::layout::{LayoutError, MAX_SIMD_LANES};
-use rustc_middle::ty::util::{Discr, IntTypeExt};
+use rustc_middle::ty::util::Discr;
 use rustc_middle::ty::{
     AdtDef, BottomUpFolder, GenericArgKind, RegionKind, TypeFoldable, TypeSuperVisitable,
     TypeVisitable, TypeVisitableExt, fold_regions,
@@ -1385,19 +1385,6 @@ fn check_enum(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         );
     }
 
-    let repr_type_ty = def.repr().discr_type().to_ty(tcx);
-    if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
-        if !tcx.features().repr128() {
-            feature_err(
-                &tcx.sess,
-                sym::repr128,
-                tcx.def_span(def_id),
-                "repr with 128-bit type is unstable",
-            )
-            .emit();
-        }
-    }
-
     for v in def.variants() {
         if let ty::VariantDiscr::Explicit(discr_def_id) = v.discr {
             tcx.ensure_ok().typeck(discr_def_id.expect_local());
diff --git a/src/doc/unstable-book/src/language-features/repr128.md b/src/doc/unstable-book/src/language-features/repr128.md
deleted file mode 100644
index 146f50ee67b50..0000000000000
--- a/src/doc/unstable-book/src/language-features/repr128.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# `repr128`
-
-The tracking issue for this feature is: [#56071]
-
-[#56071]: https://github.com/rust-lang/rust/issues/56071
-
-------------------------
-
-The `repr128` feature adds support for `#[repr(u128)]` on `enum`s.
-
-```rust
-#![feature(repr128)]
-
-#[repr(u128)]
-enum Foo {
-    Bar(u64),
-}
-```
diff --git a/src/tools/clippy/tests/ui/auxiliary/proc_macro_attr.rs b/src/tools/clippy/tests/ui/auxiliary/proc_macro_attr.rs
index 4c61c5accd397..9b8e62867f0a7 100644
--- a/src/tools/clippy/tests/ui/auxiliary/proc_macro_attr.rs
+++ b/src/tools/clippy/tests/ui/auxiliary/proc_macro_attr.rs
@@ -1,5 +1,4 @@
-#![feature(repr128, proc_macro_hygiene, proc_macro_quote, box_patterns)]
-#![allow(incomplete_features)]
+#![feature(proc_macro_hygiene, proc_macro_quote, box_patterns)]
 #![allow(clippy::useless_conversion, clippy::uninlined_format_args)]
 
 extern crate proc_macro;
diff --git a/src/tools/clippy/tests/ui/auxiliary/proc_macro_derive.rs b/src/tools/clippy/tests/ui/auxiliary/proc_macro_derive.rs
index 1815dd58f5107..5992d15935d5b 100644
--- a/src/tools/clippy/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/src/tools/clippy/tests/ui/auxiliary/proc_macro_derive.rs
@@ -1,5 +1,4 @@
-#![feature(repr128, proc_macro_quote, proc_macro_span)]
-#![allow(incomplete_features)]
+#![feature(proc_macro_quote, proc_macro_span)]
 #![allow(clippy::field_reassign_with_default)]
 #![allow(clippy::eq_op)]
 #![allow(clippy::literal_string_with_formatting_args)]
diff --git a/src/tools/clippy/tests/ui/cast.rs b/src/tools/clippy/tests/ui/cast.rs
index 77329cf5455de..525be8216500a 100644
--- a/src/tools/clippy/tests/ui/cast.rs
+++ b/src/tools/clippy/tests/ui/cast.rs
@@ -1,7 +1,5 @@
 //@no-rustfix: only some diagnostics have suggestions
 
-#![feature(repr128)]
-#![allow(incomplete_features)]
 #![warn(
     clippy::cast_precision_loss,
     clippy::cast_possible_truncation,
diff --git a/src/tools/clippy/tests/ui/cast.stderr b/src/tools/clippy/tests/ui/cast.stderr
index 4d03282f6676e..1cb30d956679a 100644
--- a/src/tools/clippy/tests/ui/cast.stderr
+++ b/src/tools/clippy/tests/ui/cast.stderr
@@ -1,5 +1,5 @@
 error: casting `i32` to `f32` causes a loss of precision (`i32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast.rs:25:5
+  --> tests/ui/cast.rs:23:5
    |
 LL |     x0 as f32;
    |     ^^^^^^^^^
@@ -8,37 +8,37 @@ LL |     x0 as f32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_precision_loss)]`
 
 error: casting `i64` to `f32` causes a loss of precision (`i64` is 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast.rs:29:5
+  --> tests/ui/cast.rs:27:5
    |
 LL |     x1 as f32;
    |     ^^^^^^^^^
 
 error: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast.rs:32:5
+  --> tests/ui/cast.rs:30:5
    |
 LL |     x1 as f64;
    |     ^^^^^^^^^
 
 error: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast.rs:36:5
+  --> tests/ui/cast.rs:34:5
    |
 LL |     x2 as f32;
    |     ^^^^^^^^^
 
 error: casting `u64` to `f32` causes a loss of precision (`u64` is 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast.rs:40:5
+  --> tests/ui/cast.rs:38:5
    |
 LL |     x3 as f32;
    |     ^^^^^^^^^
 
 error: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast.rs:43:5
+  --> tests/ui/cast.rs:41:5
    |
 LL |     x3 as f64;
    |     ^^^^^^^^^
 
 error: casting `f32` to `i32` may truncate the value
-  --> tests/ui/cast.rs:47:5
+  --> tests/ui/cast.rs:45:5
    |
 LL |     1f32 as i32;
    |     ^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     1f32 as i32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_truncation)]`
 
 error: casting `f32` to `u32` may truncate the value
-  --> tests/ui/cast.rs:50:5
+  --> tests/ui/cast.rs:48:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     1f32 as u32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:50:5
+  --> tests/ui/cast.rs:48:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     1f32 as u32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_sign_loss)]`
 
 error: casting `f64` to `f32` may truncate the value
-  --> tests/ui/cast.rs:54:5
+  --> tests/ui/cast.rs:52:5
    |
 LL |     1f64 as f32;
    |     ^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     1f64 as f32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `i32` to `i8` may truncate the value
-  --> tests/ui/cast.rs:57:5
+  --> tests/ui/cast.rs:55:5
    |
 LL |     1i32 as i8;
    |     ^^^^^^^^^^
@@ -86,7 +86,7 @@ LL +     i8::try_from(1i32);
    |
 
 error: casting `i32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:60:5
+  --> tests/ui/cast.rs:58:5
    |
 LL |     1i32 as u8;
    |     ^^^^^^^^^^
@@ -99,7 +99,7 @@ LL +     u8::try_from(1i32);
    |
 
 error: casting `f64` to `isize` may truncate the value
-  --> tests/ui/cast.rs:63:5
+  --> tests/ui/cast.rs:61:5
    |
 LL |     1f64 as isize;
    |     ^^^^^^^^^^^^^
@@ -107,7 +107,7 @@ LL |     1f64 as isize;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f64` to `usize` may truncate the value
-  --> tests/ui/cast.rs:66:5
+  --> tests/ui/cast.rs:64:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
@@ -115,13 +115,13 @@ LL |     1f64 as usize;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f64` to `usize` may lose the sign of the value
-  --> tests/ui/cast.rs:66:5
+  --> tests/ui/cast.rs:64:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
 
 error: casting `u32` to `u16` may truncate the value
-  --> tests/ui/cast.rs:70:5
+  --> tests/ui/cast.rs:68:5
    |
 LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^^^^^^^^
@@ -134,7 +134,7 @@ LL +     u16::try_from(1f32 as u32);
    |
 
 error: casting `f32` to `u32` may truncate the value
-  --> tests/ui/cast.rs:70:5
+  --> tests/ui/cast.rs:68:5
    |
 LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^
@@ -142,13 +142,13 @@ LL |     1f32 as u32 as u16;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:70:5
+  --> tests/ui/cast.rs:68:5
    |
 LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^
 
 error: casting `i32` to `i8` may truncate the value
-  --> tests/ui/cast.rs:76:22
+  --> tests/ui/cast.rs:74:22
    |
 LL |         let _x: i8 = 1i32 as _;
    |                      ^^^^^^^^^
@@ -161,7 +161,7 @@ LL +         let _x: i8 = 1i32.try_into();
    |
 
 error: casting `f32` to `i32` may truncate the value
-  --> tests/ui/cast.rs:79:9
+  --> tests/ui/cast.rs:77:9
    |
 LL |         1f32 as i32;
    |         ^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL |         1f32 as i32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f64` to `i32` may truncate the value
-  --> tests/ui/cast.rs:82:9
+  --> tests/ui/cast.rs:80:9
    |
 LL |         1f64 as i32;
    |         ^^^^^^^^^^^
@@ -177,7 +177,7 @@ LL |         1f64 as i32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:85:9
+  --> tests/ui/cast.rs:83:9
    |
 LL |         1f32 as u8;
    |         ^^^^^^^^^^
@@ -185,13 +185,13 @@ LL |         1f32 as u8;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f32` to `u8` may lose the sign of the value
-  --> tests/ui/cast.rs:85:9
+  --> tests/ui/cast.rs:83:9
    |
 LL |         1f32 as u8;
    |         ^^^^^^^^^^
 
 error: casting `u8` to `i8` may wrap around the value
-  --> tests/ui/cast.rs:90:5
+  --> tests/ui/cast.rs:88:5
    |
 LL |     1u8 as i8;
    |     ^^^^^^^^^
@@ -200,31 +200,31 @@ LL |     1u8 as i8;
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
 
 error: casting `u16` to `i16` may wrap around the value
-  --> tests/ui/cast.rs:93:5
+  --> tests/ui/cast.rs:91:5
    |
 LL |     1u16 as i16;
    |     ^^^^^^^^^^^
 
 error: casting `u32` to `i32` may wrap around the value
-  --> tests/ui/cast.rs:96:5
+  --> tests/ui/cast.rs:94:5
    |
 LL |     1u32 as i32;
    |     ^^^^^^^^^^^
 
 error: casting `u64` to `i64` may wrap around the value
-  --> tests/ui/cast.rs:99:5
+  --> tests/ui/cast.rs:97:5
    |
 LL |     1u64 as i64;
    |     ^^^^^^^^^^^
 
 error: casting `usize` to `isize` may wrap around the value
-  --> tests/ui/cast.rs:102:5
+  --> tests/ui/cast.rs:100:5
    |
 LL |     1usize as isize;
    |     ^^^^^^^^^^^^^^^
 
 error: casting `usize` to `i8` may truncate the value
-  --> tests/ui/cast.rs:106:5
+  --> tests/ui/cast.rs:104:5
    |
 LL |     1usize as i8;
    |     ^^^^^^^^^^^^
@@ -237,7 +237,7 @@ LL +     i8::try_from(1usize);
    |
 
 error: casting `usize` to `i16` may truncate the value
-  --> tests/ui/cast.rs:110:5
+  --> tests/ui/cast.rs:108:5
    |
 LL |     1usize as i16;
    |     ^^^^^^^^^^^^^
@@ -250,7 +250,7 @@ LL +     i16::try_from(1usize);
    |
 
 error: casting `usize` to `i16` may wrap around the value on targets with 16-bit wide pointers
-  --> tests/ui/cast.rs:110:5
+  --> tests/ui/cast.rs:108:5
    |
 LL |     1usize as i16;
    |     ^^^^^^^^^^^^^
@@ -259,7 +259,7 @@ LL |     1usize as i16;
    = note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types
 
 error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast.rs:115:5
+  --> tests/ui/cast.rs:113:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
@@ -272,19 +272,19 @@ LL +     i32::try_from(1usize);
    |
 
 error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:115:5
+  --> tests/ui/cast.rs:113:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
 
 error: casting `usize` to `i64` may wrap around the value on targets with 64-bit wide pointers
-  --> tests/ui/cast.rs:120:5
+  --> tests/ui/cast.rs:118:5
    |
 LL |     1usize as i64;
    |     ^^^^^^^^^^^^^
 
 error: casting `u16` to `isize` may wrap around the value on targets with 16-bit wide pointers
-  --> tests/ui/cast.rs:126:5
+  --> tests/ui/cast.rs:124:5
    |
 LL |     1u16 as isize;
    |     ^^^^^^^^^^^^^
@@ -293,13 +293,13 @@ LL |     1u16 as isize;
    = note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types
 
 error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:130:5
+  --> tests/ui/cast.rs:128:5
    |
 LL |     1u32 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:134:5
+  --> tests/ui/cast.rs:132:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
@@ -312,55 +312,55 @@ LL +     isize::try_from(1u64);
    |
 
 error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
-  --> tests/ui/cast.rs:134:5
+  --> tests/ui/cast.rs:132:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:140:5
+  --> tests/ui/cast.rs:138:5
    |
 LL |     -1i32 as u32;
    |     ^^^^^^^^^^^^
 
 error: casting `isize` to `usize` may lose the sign of the value
-  --> tests/ui/cast.rs:144:5
+  --> tests/ui/cast.rs:142:5
    |
 LL |     -1isize as usize;
    |     ^^^^^^^^^^^^^^^^
 
 error: casting `i8` to `u8` may lose the sign of the value
-  --> tests/ui/cast.rs:156:5
+  --> tests/ui/cast.rs:154:5
    |
 LL |     (i8::MIN).abs() as u8;
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `u64` may lose the sign of the value
-  --> tests/ui/cast.rs:161:5
+  --> tests/ui/cast.rs:159:5
    |
 LL |     (-1i64).abs() as u64;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: casting `isize` to `usize` may lose the sign of the value
-  --> tests/ui/cast.rs:163:5
+  --> tests/ui/cast.rs:161:5
    |
 LL |     (-1isize).abs() as usize;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `u64` may lose the sign of the value
-  --> tests/ui/cast.rs:171:5
+  --> tests/ui/cast.rs:169:5
    |
 LL |     (unsafe { (-1i64).checked_abs().unwrap_unchecked() }) as u64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `u64` may lose the sign of the value
-  --> tests/ui/cast.rs:187:5
+  --> tests/ui/cast.rs:185:5
    |
 LL |     (unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }) as u64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `i8` may truncate the value
-  --> tests/ui/cast.rs:239:5
+  --> tests/ui/cast.rs:237:5
    |
 LL |     (-99999999999i64).min(1) as i8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -373,7 +373,7 @@ LL +     i8::try_from((-99999999999i64).min(1));
    |
 
 error: casting `u64` to `u8` may truncate the value
-  --> tests/ui/cast.rs:253:5
+  --> tests/ui/cast.rs:251:5
    |
 LL |     999999u64.clamp(0, 256) as u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -386,7 +386,7 @@ LL +     u8::try_from(999999u64.clamp(0, 256));
    |
 
 error: casting `main::E2` to `u8` may truncate the value
-  --> tests/ui/cast.rs:276:21
+  --> tests/ui/cast.rs:274:21
    |
 LL |             let _ = self as u8;
    |                     ^^^^^^^^^^
@@ -399,7 +399,7 @@ LL +             let _ = u8::try_from(self);
    |
 
 error: casting `main::E2::B` to `u8` will truncate the value
-  --> tests/ui/cast.rs:279:21
+  --> tests/ui/cast.rs:277:21
    |
 LL |             let _ = Self::B as u8;
    |                     ^^^^^^^^^^^^^
@@ -408,7 +408,7 @@ LL |             let _ = Self::B as u8;
    = help: to override `-D warnings` add `#[allow(clippy::cast_enum_truncation)]`
 
 error: casting `main::E5` to `i8` may truncate the value
-  --> tests/ui/cast.rs:321:21
+  --> tests/ui/cast.rs:319:21
    |
 LL |             let _ = self as i8;
    |                     ^^^^^^^^^^
@@ -421,13 +421,13 @@ LL +             let _ = i8::try_from(self);
    |
 
 error: casting `main::E5::A` to `i8` will truncate the value
-  --> tests/ui/cast.rs:324:21
+  --> tests/ui/cast.rs:322:21
    |
 LL |             let _ = Self::A as i8;
    |                     ^^^^^^^^^^^^^
 
 error: casting `main::E6` to `i16` may truncate the value
-  --> tests/ui/cast.rs:342:21
+  --> tests/ui/cast.rs:340:21
    |
 LL |             let _ = self as i16;
    |                     ^^^^^^^^^^^
@@ -440,7 +440,7 @@ LL +             let _ = i16::try_from(self);
    |
 
 error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:362:21
+  --> tests/ui/cast.rs:360:21
    |
 LL |             let _ = self as usize;
    |                     ^^^^^^^^^^^^^
@@ -453,7 +453,7 @@ LL +             let _ = usize::try_from(self);
    |
 
 error: casting `main::E10` to `u16` may truncate the value
-  --> tests/ui/cast.rs:410:21
+  --> tests/ui/cast.rs:408:21
    |
 LL |             let _ = self as u16;
    |                     ^^^^^^^^^^^
@@ -466,7 +466,7 @@ LL +             let _ = u16::try_from(self);
    |
 
 error: casting `u32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:422:13
+  --> tests/ui/cast.rs:420:13
    |
 LL |     let c = (q >> 16) as u8;
    |             ^^^^^^^^^^^^^^^
@@ -479,7 +479,7 @@ LL +     let c = u8::try_from(q >> 16);
    |
 
 error: casting `u32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:427:13
+  --> tests/ui/cast.rs:425:13
    |
 LL |     let c = (q / 1000) as u8;
    |             ^^^^^^^^^^^^^^^^
@@ -492,85 +492,85 @@ LL +     let c = u8::try_from(q / 1000);
    |
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:440:9
+  --> tests/ui/cast.rs:438:9
    |
 LL |         (x * x) as u32;
    |         ^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:446:32
+  --> tests/ui/cast.rs:444:32
    |
 LL |     let _a = |x: i32| -> u32 { (x * x * x * x) as u32 };
    |                                ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:449:5
+  --> tests/ui/cast.rs:447:5
    |
 LL |     (2_i32).checked_pow(3).unwrap() as u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:451:5
+  --> tests/ui/cast.rs:449:5
    |
 LL |     (-2_i32).pow(3) as u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:456:5
+  --> tests/ui/cast.rs:454:5
    |
 LL |     (-5_i32 % 2) as u32;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:459:5
+  --> tests/ui/cast.rs:457:5
    |
 LL |     (-5_i32 % -2) as u32;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:463:5
+  --> tests/ui/cast.rs:461:5
    |
 LL |     (-2_i32 >> 1) as u32;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:467:5
+  --> tests/ui/cast.rs:465:5
    |
 LL |     (x * x) as u32;
    |     ^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:469:5
+  --> tests/ui/cast.rs:467:5
    |
 LL |     (x * x * x) as u32;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:473:5
+  --> tests/ui/cast.rs:471:5
    |
 LL |     (y * y * y * y * -2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:476:5
+  --> tests/ui/cast.rs:474:5
    |
 LL |     (y * y * y / y * 2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:478:5
+  --> tests/ui/cast.rs:476:5
    |
 LL |     (y * y / y * 2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:481:5
+  --> tests/ui/cast.rs:479:5
    |
 LL |     (y / y * y * -2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `/`
-  --> tests/ui/cast.rs:481:6
+  --> tests/ui/cast.rs:479:6
    |
 LL |     (y / y * y * -2) as u16;
    |      ^^^^^
@@ -578,97 +578,97 @@ LL |     (y / y * y * -2) as u16;
    = note: `#[deny(clippy::eq_op)]` on by default
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:485:5
+  --> tests/ui/cast.rs:483:5
    |
 LL |     (y + y + y + -2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:488:5
+  --> tests/ui/cast.rs:486:5
    |
 LL |     (y + y + y + 2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:492:5
+  --> tests/ui/cast.rs:490:5
    |
 LL |     (z + -2) as u16;
    |     ^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:495:5
+  --> tests/ui/cast.rs:493:5
    |
 LL |     (z + z + 2) as u16;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:499:9
+  --> tests/ui/cast.rs:497:9
    |
 LL |         (a * a * b * b * c * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:501:9
+  --> tests/ui/cast.rs:499:9
    |
 LL |         (a * b * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:504:9
+  --> tests/ui/cast.rs:502:9
    |
 LL |         (a * -b * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:507:9
+  --> tests/ui/cast.rs:505:9
    |
 LL |         (a * b * c * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:509:9
+  --> tests/ui/cast.rs:507:9
    |
 LL |         (a * -2) as u32;
    |         ^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:512:9
+  --> tests/ui/cast.rs:510:9
    |
 LL |         (a * b * c * -2) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:515:9
+  --> tests/ui/cast.rs:513:9
    |
 LL |         (a / b) as u32;
    |         ^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:517:9
+  --> tests/ui/cast.rs:515:9
    |
 LL |         (a / b * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:520:9
+  --> tests/ui/cast.rs:518:9
    |
 LL |         (a / b + b * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:523:9
+  --> tests/ui/cast.rs:521:9
    |
 LL |         a.saturating_pow(3) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:526:9
+  --> tests/ui/cast.rs:524:9
    |
 LL |         (a.abs() * b.pow(2) / c.abs()) as u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:534:21
+  --> tests/ui/cast.rs:532:21
    |
 LL |             let _ = i32::MIN as u32; // cast_sign_loss
    |                     ^^^^^^^^^^^^^^^
@@ -679,7 +679,7 @@ LL |     m!();
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: casting `u32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:537:21
+  --> tests/ui/cast.rs:535:21
    |
 LL |             let _ = u32::MAX as u8; // cast_possible_truncation
    |                     ^^^^^^^^^^^^^^
@@ -696,7 +696,7 @@ LL +             let _ = u8::try_from(u32::MAX); // cast_possible_truncation
    |
 
 error: casting `f64` to `f32` may truncate the value
-  --> tests/ui/cast.rs:540:21
+  --> tests/ui/cast.rs:538:21
    |
 LL |             let _ = std::f64::consts::PI as f32; // cast_possible_truncation
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -708,7 +708,7 @@ LL |     m!();
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: casting `i64` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:551:5
+  --> tests/ui/cast.rs:549:5
    |
 LL |     bar.unwrap().unwrap() as usize
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -721,13 +721,13 @@ LL +     usize::try_from(bar.unwrap().unwrap())
    |
 
 error: casting `i64` to `usize` may lose the sign of the value
-  --> tests/ui/cast.rs:551:5
+  --> tests/ui/cast.rs:549:5
    |
 LL |     bar.unwrap().unwrap() as usize
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `u64` to `u8` may truncate the value
-  --> tests/ui/cast.rs:568:5
+  --> tests/ui/cast.rs:566:5
    |
 LL |     (256 & 999999u64) as u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -740,7 +740,7 @@ LL +     u8::try_from(256 & 999999u64);
    |
 
 error: casting `u64` to `u8` may truncate the value
-  --> tests/ui/cast.rs:571:5
+  --> tests/ui/cast.rs:569:5
    |
 LL |     (255 % 999999u64) as u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/crashes/auxiliary/proc_macro_crash.rs b/src/tools/clippy/tests/ui/crashes/auxiliary/proc_macro_crash.rs
index 5dffddc119aa3..cf37a4c5c4bb3 100644
--- a/src/tools/clippy/tests/ui/crashes/auxiliary/proc_macro_crash.rs
+++ b/src/tools/clippy/tests/ui/crashes/auxiliary/proc_macro_crash.rs
@@ -1,6 +1,3 @@
-#![feature(repr128)]
-#![allow(incomplete_features)]
-
 extern crate proc_macro;
 
 use proc_macro::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 1d0ddd56eec5d..3e9d79224fdde 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -939,7 +939,6 @@ ui/enum-discriminant/auxiliary/issue-41394.rs
 ui/enum-discriminant/issue-104519.rs
 ui/enum-discriminant/issue-41394-rpass.rs
 ui/enum-discriminant/issue-41394.rs
-ui/enum-discriminant/issue-43398.rs
 ui/enum-discriminant/issue-46519.rs
 ui/enum-discriminant/issue-50689.rs
 ui/enum-discriminant/issue-51582.rs
diff --git a/tests/codegen/enum/enum-u128.rs b/tests/codegen/enum/enum-u128.rs
index ecdff3c5ce31d..2676669f3e308 100644
--- a/tests/codegen/enum/enum-u128.rs
+++ b/tests/codegen/enum/enum-u128.rs
@@ -13,9 +13,6 @@
 // CHECK: {{.*}}DIEnumerator{{.*}}name: "Hi",{{.*}}value: 18446744073709551616,{{.*}}
 // CHECK: {{.*}}DIEnumerator{{.*}}name: "Bar",{{.*}}value: 18446745000000000123,{{.*}}
 
-#![allow(incomplete_features)]
-#![feature(repr128)]
-
 #[repr(u128)]
 pub enum Foo {
     Lo,
diff --git a/tests/debuginfo/msvc-pretty-enums.rs b/tests/debuginfo/msvc-pretty-enums.rs
index 06bc25dc5d59c..aa6629ef1e1be 100644
--- a/tests/debuginfo/msvc-pretty-enums.rs
+++ b/tests/debuginfo/msvc-pretty-enums.rs
@@ -231,8 +231,6 @@
 // cdb-command: dx c_style_i128_d
 // cdb-check: c_style_i128_d   : D [Type: enum2$<msvc_pretty_enums::CStyleI128>]
 #![feature(rustc_attrs)]
-#![feature(repr128)]
-#![feature(arbitrary_enum_discriminant)]
 
 use std::num::NonZero;
 
diff --git a/tests/mir-opt/enum_opt.rs b/tests/mir-opt/enum_opt.rs
index e42be8ac06dc9..81390567c2bb4 100644
--- a/tests/mir-opt/enum_opt.rs
+++ b/tests/mir-opt/enum_opt.rs
@@ -3,8 +3,6 @@
 // EMIT_MIR_FOR_EACH_BIT_WIDTH
 //@ compile-flags: -Zunsound-mir-opts -Zdump-mir-exclude-alloc-bytes
 
-#![feature(arbitrary_enum_discriminant, repr128)]
-
 // Tests that an enum with a variant with no data gets correctly transformed.
 pub enum NoData {
     Large([u8; 8196]),
diff --git a/tests/mir-opt/matches_reduce_branches.rs b/tests/mir-opt/matches_reduce_branches.rs
index 3372ae2f2a614..00131b0116db0 100644
--- a/tests/mir-opt/matches_reduce_branches.rs
+++ b/tests/mir-opt/matches_reduce_branches.rs
@@ -1,6 +1,5 @@
 //@ test-mir-pass: MatchBranchSimplification
 
-#![feature(repr128)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 #![allow(non_camel_case_types)]
diff --git a/tests/run-make/repr128-dwarf/main.rs b/tests/run-make/repr128-dwarf/main.rs
index 9842ab4a3426f..a8a414fd72e40 100644
--- a/tests/run-make/repr128-dwarf/main.rs
+++ b/tests/run-make/repr128-dwarf/main.rs
@@ -1,5 +1,3 @@
-#![feature(repr128)]
-
 // Use .to_le() to ensure that the bytes are in the same order on both little- and big-endian
 // platforms.
 
diff --git a/tests/rustdoc-json/enums/discriminant/limits.rs b/tests/rustdoc-json/enums/discriminant/limits.rs
index c84181334e35d..e98271b7c8063 100644
--- a/tests/rustdoc-json/enums/discriminant/limits.rs
+++ b/tests/rustdoc-json/enums/discriminant/limits.rs
@@ -1,6 +1,3 @@
-#![feature(repr128)]
-#![allow(incomplete_features)]
-
 #[repr(u64)]
 pub enum U64 {
     //@ is "$.index[?(@.name=='U64Min')].inner.variant.discriminant.value" '"0"'
diff --git a/tests/ui/enum-discriminant/discriminant_size.rs b/tests/ui/enum-discriminant/discriminant_size.rs
index a3ec1b28e5c76..b1feff3c59e1d 100644
--- a/tests/ui/enum-discriminant/discriminant_size.rs
+++ b/tests/ui/enum-discriminant/discriminant_size.rs
@@ -1,6 +1,5 @@
 //@ run-pass
-#![feature(core_intrinsics, repr128)]
-//~^ WARN the feature `repr128` is incomplete
+#![feature(core_intrinsics)]
 
 use std::intrinsics::discriminant_value;
 
diff --git a/tests/ui/enum-discriminant/discriminant_size.stderr b/tests/ui/enum-discriminant/discriminant_size.stderr
deleted file mode 100644
index 9b1505b5c468d..0000000000000
--- a/tests/ui/enum-discriminant/discriminant_size.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `repr128` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/discriminant_size.rs:2:29
-   |
-LL | #![feature(core_intrinsics, repr128)]
-   |                             ^^^^^^^
-   |
-   = note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/enum-discriminant/issue-43398.stderr b/tests/ui/enum-discriminant/issue-43398.stderr
deleted file mode 100644
index fc7bbd0628434..0000000000000
--- a/tests/ui/enum-discriminant/issue-43398.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `repr128` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-43398.rs:4:12
-   |
-LL | #![feature(repr128)]
-   |            ^^^^^^^
-   |
-   = note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/enum-discriminant/issue-70509-partial_eq.rs b/tests/ui/enum-discriminant/issue-70509-partial_eq.rs
index e98532c120793..5e71972c28086 100644
--- a/tests/ui/enum-discriminant/issue-70509-partial_eq.rs
+++ b/tests/ui/enum-discriminant/issue-70509-partial_eq.rs
@@ -1,6 +1,4 @@
 //@ run-pass
-#![feature(repr128)]
-//~^ WARN the feature `repr128` is incomplete
 
 #[derive(PartialEq, Debug)]
 #[repr(i128)]
diff --git a/tests/ui/enum-discriminant/issue-70509-partial_eq.stderr b/tests/ui/enum-discriminant/issue-70509-partial_eq.stderr
deleted file mode 100644
index 2eef930c39434..0000000000000
--- a/tests/ui/enum-discriminant/issue-70509-partial_eq.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `repr128` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-70509-partial_eq.rs:2:12
-   |
-LL | #![feature(repr128)]
-   |            ^^^^^^^
-   |
-   = note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/enum-discriminant/issue-43398.rs b/tests/ui/enum-discriminant/repr128-get-discriminant-issue-43398.rs
similarity index 75%
rename from tests/ui/enum-discriminant/issue-43398.rs
rename to tests/ui/enum-discriminant/repr128-get-discriminant-issue-43398.rs
index 574a4b3ad5a09..2bb9725fb77d1 100644
--- a/tests/ui/enum-discriminant/issue-43398.rs
+++ b/tests/ui/enum-discriminant/repr128-get-discriminant-issue-43398.rs
@@ -1,8 +1,6 @@
 //@ run-pass
 
 #![feature(core_intrinsics)]
-#![feature(repr128)]
-//~^ WARN the feature `repr128` is incomplete
 
 #[repr(i128)]
 enum Big { A, B }
diff --git a/tests/ui/enum-discriminant/repr128.rs b/tests/ui/enum-discriminant/repr128.rs
index 075ff7a767613..d59a5b3e256d2 100644
--- a/tests/ui/enum-discriminant/repr128.rs
+++ b/tests/ui/enum-discriminant/repr128.rs
@@ -1,6 +1,5 @@
 //@ run-pass
-#![feature(repr128, core_intrinsics, discriminant_kind)]
-//~^ WARN the feature `repr128` is incomplete
+#![feature(core_intrinsics, discriminant_kind)]
 
 use std::intrinsics::discriminant_value;
 use std::marker::DiscriminantKind;
diff --git a/tests/ui/enum-discriminant/repr128.stderr b/tests/ui/enum-discriminant/repr128.stderr
deleted file mode 100644
index da8d75c11aff2..0000000000000
--- a/tests/ui/enum-discriminant/repr128.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `repr128` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/repr128.rs:2:12
-   |
-LL | #![feature(repr128, core_intrinsics, discriminant_kind)]
-   |            ^^^^^^^
-   |
-   = note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/error-codes/E0658.rs b/tests/ui/error-codes/E0658.rs
index 9c9b95d70a7cf..e51674cdf92ed 100644
--- a/tests/ui/error-codes/E0658.rs
+++ b/tests/ui/error-codes/E0658.rs
@@ -1,6 +1,3 @@
-#[repr(u128)]
-enum Foo { //~ ERROR E0658
-    Bar(u64),
-}
+use std::intrinsics; //~ ERROR E0658
 
 fn main() {}
diff --git a/tests/ui/error-codes/E0658.stderr b/tests/ui/error-codes/E0658.stderr
index e1e812940ec54..ae7ecbbc5cb0a 100644
--- a/tests/ui/error-codes/E0658.stderr
+++ b/tests/ui/error-codes/E0658.stderr
@@ -1,11 +1,10 @@
-error[E0658]: repr with 128-bit type is unstable
-  --> $DIR/E0658.rs:2:1
+error[E0658]: use of unstable library feature `core_intrinsics`: intrinsics are unlikely to ever be stabilized, instead they should be used through stabilized interfaces in the rest of the standard library
+  --> $DIR/E0658.rs:1:5
    |
-LL | enum Foo {
-   | ^^^^^^^^
+LL | use std::intrinsics;
+   |     ^^^^^^^^^^^^^^^
    |
-   = note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
-   = help: add `#![feature(repr128)]` to the crate attributes to enable
+   = help: add `#![feature(core_intrinsics)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/feature-gates/feature-gate-repr128.rs b/tests/ui/feature-gates/feature-gate-repr128.rs
deleted file mode 100644
index 0290874dd27f8..0000000000000
--- a/tests/ui/feature-gates/feature-gate-repr128.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#[repr(u128)]
-enum A { //~ ERROR repr with 128-bit type is unstable
-    A(u64)
-}
-
-fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-repr128.stderr b/tests/ui/feature-gates/feature-gate-repr128.stderr
deleted file mode 100644
index 2607032447b39..0000000000000
--- a/tests/ui/feature-gates/feature-gate-repr128.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0658]: repr with 128-bit type is unstable
-  --> $DIR/feature-gate-repr128.rs:2:1
-   |
-LL | enum A {
-   | ^^^^^^
-   |
-   = note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
-   = help: add `#![feature(repr128)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/lint/lint-ctypes-enum.rs b/tests/ui/lint/lint-ctypes-enum.rs
index b2ef27b833bdb..612da86c9568d 100644
--- a/tests/ui/lint/lint-ctypes-enum.rs
+++ b/tests/ui/lint/lint-ctypes-enum.rs
@@ -2,8 +2,6 @@
 #![deny(improper_ctypes)]
 #![feature(ptr_internals)]
 #![feature(transparent_unions)]
-#![feature(repr128)]
-#![allow(incomplete_features)]
 
 use std::num;
 
diff --git a/tests/ui/lint/lint-ctypes-enum.stderr b/tests/ui/lint/lint-ctypes-enum.stderr
index d5fc844f75607..50a6f526f26db 100644
--- a/tests/ui/lint/lint-ctypes-enum.stderr
+++ b/tests/ui/lint/lint-ctypes-enum.stderr
@@ -1,5 +1,5 @@
 error: `extern` block uses type `U`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:84:14
+  --> $DIR/lint-ctypes-enum.rs:82:14
    |
 LL |     fn uf(x: U);
    |              ^ not FFI-safe
@@ -7,7 +7,7 @@ LL |     fn uf(x: U);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 note: the type is defined here
-  --> $DIR/lint-ctypes-enum.rs:11:1
+  --> $DIR/lint-ctypes-enum.rs:9:1
    |
 LL | enum U {
    | ^^^^^^
@@ -18,7 +18,7 @@ LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `B`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:85:14
+  --> $DIR/lint-ctypes-enum.rs:83:14
    |
 LL |     fn bf(x: B);
    |              ^ not FFI-safe
@@ -26,13 +26,13 @@ LL |     fn bf(x: B);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 note: the type is defined here
-  --> $DIR/lint-ctypes-enum.rs:14:1
+  --> $DIR/lint-ctypes-enum.rs:12:1
    |
 LL | enum B {
    | ^^^^^^
 
 error: `extern` block uses type `T`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:86:14
+  --> $DIR/lint-ctypes-enum.rs:84:14
    |
 LL |     fn tf(x: T);
    |              ^ not FFI-safe
@@ -40,39 +40,39 @@ LL |     fn tf(x: T);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 note: the type is defined here
-  --> $DIR/lint-ctypes-enum.rs:18:1
+  --> $DIR/lint-ctypes-enum.rs:16:1
    |
 LL | enum T {
    | ^^^^^^
 
 error: `extern` block uses type `U128`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:90:21
+  --> $DIR/lint-ctypes-enum.rs:88:21
    |
 LL |     fn repr_u128(x: U128);
    |                     ^^^^ not FFI-safe
    |
    = note: 128-bit integers don't currently have a known stable ABI
 note: the type is defined here
-  --> $DIR/lint-ctypes-enum.rs:46:1
+  --> $DIR/lint-ctypes-enum.rs:44:1
    |
 LL | enum U128 {
    | ^^^^^^^^^
 
 error: `extern` block uses type `I128`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:91:21
+  --> $DIR/lint-ctypes-enum.rs:89:21
    |
 LL |     fn repr_i128(x: I128);
    |                     ^^^^ not FFI-safe
    |
    = note: 128-bit integers don't currently have a known stable ABI
 note: the type is defined here
-  --> $DIR/lint-ctypes-enum.rs:53:1
+  --> $DIR/lint-ctypes-enum.rs:51:1
    |
 LL | enum I128 {
    | ^^^^^^^^^
 
 error: `extern` block uses type `u128`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:100:31
+  --> $DIR/lint-ctypes-enum.rs:98:31
    |
 LL |     fn option_nonzero_u128(x: Option<num::NonZero<u128>>);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -80,7 +80,7 @@ LL |     fn option_nonzero_u128(x: Option<num::NonZero<u128>>);
    = note: 128-bit integers don't currently have a known stable ABI
 
 error: `extern` block uses type `i128`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:107:31
+  --> $DIR/lint-ctypes-enum.rs:105:31
    |
 LL |     fn option_nonzero_i128(x: Option<num::NonZero<i128>>);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -88,7 +88,7 @@ LL |     fn option_nonzero_i128(x: Option<num::NonZero<i128>>);
    = note: 128-bit integers don't currently have a known stable ABI
 
 error: `extern` block uses type `Option<TransparentUnion<NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:112:36
+  --> $DIR/lint-ctypes-enum.rs:110:36
    |
 LL |     fn option_transparent_union(x: Option<TransparentUnion<num::NonZero<u8>>>);
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -97,7 +97,7 @@ LL |     fn option_transparent_union(x: Option<TransparentUnion<num::NonZero<u8>
    = note: enum has no representation hint
 
 error: `extern` block uses type `Option<Rust<NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:114:28
+  --> $DIR/lint-ctypes-enum.rs:112:28
    |
 LL |     fn option_repr_rust(x: Option<Rust<num::NonZero<u8>>>);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -106,7 +106,7 @@ LL |     fn option_repr_rust(x: Option<Rust<num::NonZero<u8>>>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Option<u8>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:115:21
+  --> $DIR/lint-ctypes-enum.rs:113:21
    |
 LL |     fn option_u8(x: Option<u8>);
    |                     ^^^^^^^^^^ not FFI-safe
@@ -115,7 +115,7 @@ LL |     fn option_u8(x: Option<u8>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `u128`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:125:33
+  --> $DIR/lint-ctypes-enum.rs:123:33
    |
 LL |     fn result_nonzero_u128_t(x: Result<num::NonZero<u128>, ()>);
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -123,7 +123,7 @@ LL |     fn result_nonzero_u128_t(x: Result<num::NonZero<u128>, ()>);
    = note: 128-bit integers don't currently have a known stable ABI
 
 error: `extern` block uses type `i128`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:132:33
+  --> $DIR/lint-ctypes-enum.rs:130:33
    |
 LL |     fn result_nonzero_i128_t(x: Result<num::NonZero<i128>, ()>);
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -131,7 +131,7 @@ LL |     fn result_nonzero_i128_t(x: Result<num::NonZero<i128>, ()>);
    = note: 128-bit integers don't currently have a known stable ABI
 
 error: `extern` block uses type `Result<TransparentUnion<NonZero<u8>>, ()>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:137:38
+  --> $DIR/lint-ctypes-enum.rs:135:38
    |
 LL |     fn result_transparent_union_t(x: Result<TransparentUnion<num::NonZero<u8>>, ()>);
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -140,7 +140,7 @@ LL |     fn result_transparent_union_t(x: Result<TransparentUnion<num::NonZero<u
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<Rust<NonZero<u8>>, ()>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:139:30
+  --> $DIR/lint-ctypes-enum.rs:137:30
    |
 LL |     fn result_repr_rust_t(x: Result<Rust<num::NonZero<u8>>, ()>);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -149,7 +149,7 @@ LL |     fn result_repr_rust_t(x: Result<Rust<num::NonZero<u8>>, ()>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonZero<u8>, U>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:143:51
+  --> $DIR/lint-ctypes-enum.rs:141:51
    |
 LL |     fn result_1zst_exhaustive_single_variant_t(x: Result<num::NonZero<u8>, U>);
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -158,7 +158,7 @@ LL |     fn result_1zst_exhaustive_single_variant_t(x: Result<num::NonZero<u8>,
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonZero<u8>, B>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:145:53
+  --> $DIR/lint-ctypes-enum.rs:143:53
    |
 LL |     fn result_1zst_exhaustive_multiple_variant_t(x: Result<num::NonZero<u8>, B>);
    |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -167,7 +167,7 @@ LL |     fn result_1zst_exhaustive_multiple_variant_t(x: Result<num::NonZero<u8>
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonZero<u8>, NonExhaustive>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:147:51
+  --> $DIR/lint-ctypes-enum.rs:145:51
    |
 LL |     fn result_1zst_non_exhaustive_no_variant_t(x: Result<num::NonZero<u8>, NonExhaustive>);
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -176,7 +176,7 @@ LL |     fn result_1zst_non_exhaustive_no_variant_t(x: Result<num::NonZero<u8>,
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonZero<u8>, Field>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:150:49
+  --> $DIR/lint-ctypes-enum.rs:148:49
    |
 LL |     fn result_1zst_exhaustive_single_field_t(x: Result<num::NonZero<u8>, Field>);
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -185,7 +185,7 @@ LL |     fn result_1zst_exhaustive_single_field_t(x: Result<num::NonZero<u8>, Fi
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<Result<(), NonZero<u8>>, ()>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:152:30
+  --> $DIR/lint-ctypes-enum.rs:150:30
    |
 LL |     fn result_cascading_t(x: Result<Result<(), num::NonZero<u8>>, ()>);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -194,7 +194,7 @@ LL |     fn result_cascading_t(x: Result<Result<(), num::NonZero<u8>>, ()>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `u128`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:163:33
+  --> $DIR/lint-ctypes-enum.rs:161:33
    |
 LL |     fn result_nonzero_u128_e(x: Result<(), num::NonZero<u128>>);
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -202,7 +202,7 @@ LL |     fn result_nonzero_u128_e(x: Result<(), num::NonZero<u128>>);
    = note: 128-bit integers don't currently have a known stable ABI
 
 error: `extern` block uses type `i128`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:170:33
+  --> $DIR/lint-ctypes-enum.rs:168:33
    |
 LL |     fn result_nonzero_i128_e(x: Result<(), num::NonZero<i128>>);
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -210,7 +210,7 @@ LL |     fn result_nonzero_i128_e(x: Result<(), num::NonZero<i128>>);
    = note: 128-bit integers don't currently have a known stable ABI
 
 error: `extern` block uses type `Result<(), TransparentUnion<NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:175:38
+  --> $DIR/lint-ctypes-enum.rs:173:38
    |
 LL |     fn result_transparent_union_e(x: Result<(), TransparentUnion<num::NonZero<u8>>>);
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -219,7 +219,7 @@ LL |     fn result_transparent_union_e(x: Result<(), TransparentUnion<num::NonZe
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<(), Rust<NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:177:30
+  --> $DIR/lint-ctypes-enum.rs:175:30
    |
 LL |     fn result_repr_rust_e(x: Result<(), Rust<num::NonZero<u8>>>);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -228,7 +228,7 @@ LL |     fn result_repr_rust_e(x: Result<(), Rust<num::NonZero<u8>>>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<U, NonZero<u8>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:181:51
+  --> $DIR/lint-ctypes-enum.rs:179:51
    |
 LL |     fn result_1zst_exhaustive_single_variant_e(x: Result<U, num::NonZero<u8>>);
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -237,7 +237,7 @@ LL |     fn result_1zst_exhaustive_single_variant_e(x: Result<U, num::NonZero<u8
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<B, NonZero<u8>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:183:53
+  --> $DIR/lint-ctypes-enum.rs:181:53
    |
 LL |     fn result_1zst_exhaustive_multiple_variant_e(x: Result<B, num::NonZero<u8>>);
    |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -246,7 +246,7 @@ LL |     fn result_1zst_exhaustive_multiple_variant_e(x: Result<B, num::NonZero<
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonExhaustive, NonZero<u8>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:185:51
+  --> $DIR/lint-ctypes-enum.rs:183:51
    |
 LL |     fn result_1zst_non_exhaustive_no_variant_e(x: Result<NonExhaustive, num::NonZero<u8>>);
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -255,7 +255,7 @@ LL |     fn result_1zst_non_exhaustive_no_variant_e(x: Result<NonExhaustive, num
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<Field, NonZero<u8>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:188:49
+  --> $DIR/lint-ctypes-enum.rs:186:49
    |
 LL |     fn result_1zst_exhaustive_single_field_e(x: Result<Field, num::NonZero<u8>>);
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -264,7 +264,7 @@ LL |     fn result_1zst_exhaustive_single_field_e(x: Result<Field, num::NonZero<
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<(), Result<(), NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:190:30
+  --> $DIR/lint-ctypes-enum.rs:188:30
    |
 LL |     fn result_cascading_e(x: Result<(), Result<(), num::NonZero<u8>>>);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -273,7 +273,7 @@ LL |     fn result_cascading_e(x: Result<(), Result<(), num::NonZero<u8>>>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<(), ()>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:192:27
+  --> $DIR/lint-ctypes-enum.rs:190:27
    |
 LL |     fn result_unit_t_e(x: Result<(), ()>);
    |                           ^^^^^^^^^^^^^^ not FFI-safe
diff --git a/tests/ui/transmutability/enums/repr/should_handle_all.rs b/tests/ui/transmutability/enums/repr/should_handle_all.rs
index dec0126f22d4c..192b7cdcf726f 100644
--- a/tests/ui/transmutability/enums/repr/should_handle_all.rs
+++ b/tests/ui/transmutability/enums/repr/should_handle_all.rs
@@ -1,8 +1,7 @@
 //@ check-pass
 #![crate_type = "lib"]
-#![feature(repr128)]
 #![feature(transmutability)]
-#![allow(dead_code, incomplete_features, non_camel_case_types)]
+#![allow(dead_code, non_camel_case_types)]
 
 mod assert {
     use std::mem::{Assume, TransmuteFrom};