about summary refs log tree commit diff
path: root/library/std
diff options
context:
space:
mode:
Diffstat (limited to 'library/std')
-rw-r--r--library/std/Cargo.toml2
-rw-r--r--library/std/src/collections/hash/map.rs10
-rw-r--r--library/std/src/collections/hash/set.rs10
-rw-r--r--library/std/src/f128.rs225
-rw-r--r--library/std/src/f16.rs225
-rw-r--r--library/std/src/ffi/mod.rs2
-rw-r--r--library/std/src/io/error.rs2
-rw-r--r--library/std/src/lib.rs1
-rw-r--r--library/std/src/prelude/v1.rs1
-rw-r--r--library/std/src/thread/mod.rs2
-rw-r--r--library/std/tests/floats/f128.rs32
-rw-r--r--library/std/tests/floats/f16.rs30
-rw-r--r--library/std/tests/floats/lib.rs4
13 files changed, 196 insertions, 350 deletions
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 7915196e8e8..4ff4895ecde 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -18,7 +18,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
 panic_unwind = { path = "../panic_unwind", optional = true }
 panic_abort = { path = "../panic_abort" }
 core = { path = "../core", public = true }
-compiler_builtins = { version = "=0.1.158" }
+compiler_builtins = { version = "=0.1.159" }
 unwind = { path = "../unwind" }
 hashbrown = { version = "0.15", default-features = false, features = [
     'rustc-dep-of-std',
diff --git a/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs
index 961d6ee0665..3530f890f52 100644
--- a/library/std/src/collections/hash/map.rs
+++ b/library/std/src/collections/hash/map.rs
@@ -683,7 +683,7 @@ impl<K, V, S> HashMap<K, V, S> {
     /// ```
     #[inline]
     #[rustc_lint_query_instability]
-    #[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "hash_extract_if", since = "1.88.0")]
     pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, K, V, F>
     where
         F: FnMut(&K, &mut V) -> bool,
@@ -1680,7 +1680,7 @@ impl<'a, K, V> Drain<'a, K, V> {
 /// ]);
 /// let iter = map.extract_if(|_k, v| *v % 2 == 0);
 /// ```
-#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "hash_extract_if", since = "1.88.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ExtractIf<'a, K, V, F> {
     base: base::ExtractIf<'a, K, V, F>,
@@ -2294,7 +2294,7 @@ where
     }
 }
 
-#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "hash_extract_if", since = "1.88.0")]
 impl<K, V, F> Iterator for ExtractIf<'_, K, V, F>
 where
     F: FnMut(&K, &mut V) -> bool,
@@ -2311,10 +2311,10 @@ where
     }
 }
 
-#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "hash_extract_if", since = "1.88.0")]
 impl<K, V, F> FusedIterator for ExtractIf<'_, K, V, F> where F: FnMut(&K, &mut V) -> bool {}
 
-#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "hash_extract_if", since = "1.88.0")]
 impl<K, V, F> fmt::Debug for ExtractIf<'_, K, V, F>
 where
     K: fmt::Debug,
diff --git a/library/std/src/collections/hash/set.rs b/library/std/src/collections/hash/set.rs
index fa2f4f0a58f..8514dfd9a98 100644
--- a/library/std/src/collections/hash/set.rs
+++ b/library/std/src/collections/hash/set.rs
@@ -308,7 +308,7 @@ impl<T, S> HashSet<T, S> {
     /// ```
     #[inline]
     #[rustc_lint_query_instability]
-    #[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "hash_extract_if", since = "1.88.0")]
     pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, T, F>
     where
         F: FnMut(&T) -> bool,
@@ -1390,7 +1390,7 @@ pub struct Drain<'a, K: 'a> {
 ///
 /// let mut extract_ifed = a.extract_if(|v| v % 2 == 0);
 /// ```
-#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "hash_extract_if", since = "1.88.0")]
 pub struct ExtractIf<'a, K, F> {
     base: base::ExtractIf<'a, K, F>,
 }
@@ -1670,7 +1670,7 @@ impl<K: fmt::Debug> fmt::Debug for Drain<'_, K> {
     }
 }
 
-#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "hash_extract_if", since = "1.88.0")]
 impl<K, F> Iterator for ExtractIf<'_, K, F>
 where
     F: FnMut(&K) -> bool,
@@ -1687,10 +1687,10 @@ where
     }
 }
 
-#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "hash_extract_if", since = "1.88.0")]
 impl<K, F> FusedIterator for ExtractIf<'_, K, F> where F: FnMut(&K) -> bool {}
 
-#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "hash_extract_if", since = "1.88.0")]
 impl<K, F> fmt::Debug for ExtractIf<'_, K, F>
 where
     K: fmt::Debug,
diff --git a/library/std/src/f128.rs b/library/std/src/f128.rs
index 2b416b13fa5..6b2ba2e714c 100644
--- a/library/std/src/f128.rs
+++ b/library/std/src/f128.rs
@@ -22,10 +22,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let f = 3.7_f128;
@@ -53,10 +52,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let f = 3.01_f128;
@@ -84,10 +82,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let f = 3.3_f128;
@@ -120,10 +117,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let f = 3.3_f128;
@@ -154,10 +150,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let f = 3.7_f128;
@@ -186,10 +181,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 3.6_f128;
@@ -227,10 +221,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let m = 10.0_f128;
@@ -275,10 +268,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let a: f128 = 7.0;
@@ -321,10 +313,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let a: f128 = 7.0;
@@ -362,10 +353,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 2.0_f128;
@@ -394,10 +384,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 2.0_f128;
@@ -430,10 +419,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let positive = 4.0_f128;
@@ -465,10 +453,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let one = 1.0f128;
@@ -500,10 +487,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let f = 2.0f128;
@@ -535,10 +521,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let one = 1.0f128;
@@ -555,10 +540,9 @@ impl f128 {
     /// Non-positive values:
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// assert_eq!(0_f128.ln(), f128::NEG_INFINITY);
@@ -590,10 +574,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let five = 5.0f128;
@@ -608,10 +591,9 @@ impl f128 {
     /// Non-positive values:
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// assert_eq!(0_f128.log(10.0), f128::NEG_INFINITY);
@@ -639,10 +621,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let two = 2.0f128;
@@ -657,10 +638,9 @@ impl f128 {
     /// Non-positive values:
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// assert_eq!(0_f128.log2(), f128::NEG_INFINITY);
@@ -688,10 +668,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let ten = 10.0f128;
@@ -706,10 +685,9 @@ impl f128 {
     /// Non-positive values:
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// assert_eq!(0_f128.log10(), f128::NEG_INFINITY);
@@ -739,10 +717,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 8.0f128;
@@ -779,10 +756,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 2.0f128;
@@ -813,10 +789,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = std::f128::consts::FRAC_PI_2;
@@ -845,10 +820,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 2.0 * std::f128::consts::PI;
@@ -880,10 +854,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = std::f128::consts::FRAC_PI_4;
@@ -916,10 +889,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let f = std::f128::consts::FRAC_PI_2;
@@ -955,10 +927,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let f = std::f128::consts::FRAC_PI_4;
@@ -993,10 +964,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let f = 1.0f128;
@@ -1035,10 +1005,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// // Positive angles measured counter-clockwise
@@ -1081,10 +1050,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = std::f128::consts::FRAC_PI_4;
@@ -1120,10 +1088,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 1e-8_f128;
@@ -1160,10 +1127,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 1e-8_f128;
@@ -1179,10 +1145,9 @@ impl f128 {
     /// Out-of-range values:
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// assert_eq!((-1.0_f128).ln_1p(), f128::NEG_INFINITY);
@@ -1212,10 +1177,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let e = std::f128::consts::E;
@@ -1251,10 +1215,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let e = std::f128::consts::E;
@@ -1290,10 +1253,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let e = std::f128::consts::E;
@@ -1326,10 +1288,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 1.0f128;
@@ -1362,10 +1323,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 1.0f128;
@@ -1400,10 +1360,9 @@ impl f128 {
     ///
     /// ```
     /// #![feature(f128)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let e = std::f128::consts::E;
@@ -1438,10 +1397,9 @@ impl f128 {
     /// ```
     /// #![feature(f128)]
     /// #![feature(float_gamma)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 5.0f128;
@@ -1477,10 +1435,9 @@ impl f128 {
     /// ```
     /// #![feature(f128)]
     /// #![feature(float_gamma)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
     /// let x = 2.0f128;
@@ -1516,10 +1473,9 @@ impl f128 {
     /// ```
     /// #![feature(f128)]
     /// #![feature(float_erf)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     /// /// The error function relates what percent of a normal distribution lies
     /// /// within `x` standard deviations (scaled by `1/sqrt(2)`).
@@ -1559,10 +1515,9 @@ impl f128 {
     /// ```
     /// #![feature(f128)]
     /// #![feature(float_erf)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     /// let x: f128 = 0.123;
     ///
diff --git a/library/std/src/f16.rs b/library/std/src/f16.rs
index 3f88ab2d400..d6bc1d3118a 100644
--- a/library/std/src/f16.rs
+++ b/library/std/src/f16.rs
@@ -22,10 +22,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let f = 3.7_f16;
@@ -53,10 +52,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let f = 3.01_f16;
@@ -84,10 +82,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let f = 3.3_f16;
@@ -120,10 +117,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let f = 3.3_f16;
@@ -154,10 +150,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let f = 3.7_f16;
@@ -186,10 +181,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 3.6_f16;
@@ -227,10 +221,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let m = 10.0_f16;
@@ -275,10 +268,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let a: f16 = 7.0;
@@ -321,10 +313,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let a: f16 = 7.0;
@@ -362,10 +353,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 2.0_f16;
@@ -394,10 +384,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 2.0_f16;
@@ -430,10 +419,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let positive = 4.0_f16;
@@ -465,10 +453,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let one = 1.0f16;
@@ -500,10 +487,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let f = 2.0f16;
@@ -535,10 +521,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let one = 1.0f16;
@@ -555,10 +540,9 @@ impl f16 {
     /// Non-positive values:
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// assert_eq!(0_f16.ln(), f16::NEG_INFINITY);
@@ -590,10 +574,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let five = 5.0f16;
@@ -608,10 +591,9 @@ impl f16 {
     /// Non-positive values:
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// assert_eq!(0_f16.log(10.0), f16::NEG_INFINITY);
@@ -639,10 +621,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let two = 2.0f16;
@@ -657,10 +638,9 @@ impl f16 {
     /// Non-positive values:
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// assert_eq!(0_f16.log2(), f16::NEG_INFINITY);
@@ -688,10 +668,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let ten = 10.0f16;
@@ -706,10 +685,9 @@ impl f16 {
     /// Non-positive values:
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// assert_eq!(0_f16.log10(), f16::NEG_INFINITY);
@@ -738,10 +716,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 8.0f16;
@@ -777,10 +754,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 2.0f16;
@@ -811,10 +787,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = std::f16::consts::FRAC_PI_2;
@@ -843,10 +818,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 2.0 * std::f16::consts::PI;
@@ -878,10 +852,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = std::f16::consts::FRAC_PI_4;
@@ -914,10 +887,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let f = std::f16::consts::FRAC_PI_2;
@@ -953,10 +925,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let f = std::f16::consts::FRAC_PI_4;
@@ -991,10 +962,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let f = 1.0f16;
@@ -1033,10 +1003,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// // Positive angles measured counter-clockwise
@@ -1079,10 +1048,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = std::f16::consts::FRAC_PI_4;
@@ -1118,10 +1086,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 1e-4_f16;
@@ -1158,10 +1125,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 1e-4_f16;
@@ -1177,10 +1143,9 @@ impl f16 {
     /// Out-of-range values:
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// assert_eq!((-1.0_f16).ln_1p(), f16::NEG_INFINITY);
@@ -1210,10 +1175,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let e = std::f16::consts::E;
@@ -1249,10 +1213,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let e = std::f16::consts::E;
@@ -1288,10 +1251,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let e = std::f16::consts::E;
@@ -1324,10 +1286,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 1.0f16;
@@ -1360,10 +1321,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 1.0f16;
@@ -1398,10 +1358,9 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let e = std::f16::consts::E;
@@ -1436,10 +1395,9 @@ impl f16 {
     /// ```
     /// #![feature(f16)]
     /// #![feature(float_gamma)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 5.0f16;
@@ -1475,10 +1433,9 @@ impl f16 {
     /// ```
     /// #![feature(f16)]
     /// #![feature(float_gamma)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
     /// let x = 2.0f16;
@@ -1514,10 +1471,9 @@ impl f16 {
     /// ```
     /// #![feature(f16)]
     /// #![feature(float_erf)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     /// /// The error function relates what percent of a normal distribution lies
     /// /// within `x` standard deviations (scaled by `1/sqrt(2)`).
@@ -1557,10 +1513,9 @@ impl f16 {
     /// ```
     /// #![feature(f16)]
     /// #![feature(float_erf)]
-    /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-    /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+    /// # #![feature(cfg_target_has_reliable_f16_f128)]
+    /// # #![expect(internal_features)]
     /// # #[cfg(not(miri))]
-    /// # #[cfg(not(bootstrap))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     /// let x: f16 = 0.123;
     ///
diff --git a/library/std/src/ffi/mod.rs b/library/std/src/ffi/mod.rs
index bd9446f5aba..56791609910 100644
--- a/library/std/src/ffi/mod.rs
+++ b/library/std/src/ffi/mod.rs
@@ -161,7 +161,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[stable(feature = "c_str_module", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "c_str_module", since = "1.88.0")]
 pub mod c_str;
 
 #[stable(feature = "core_c_void", since = "1.30.0")]
diff --git a/library/std/src/io/error.rs b/library/std/src/io/error.rs
index cf3778bd290..ba765a6203f 100644
--- a/library/std/src/io/error.rs
+++ b/library/std/src/io/error.rs
@@ -48,7 +48,7 @@ use crate::{error, fmt, result, sys};
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(bootstrap), doc(search_unbox))]
+#[doc(search_unbox)]
 pub type Result<T> = result::Result<T, Error>;
 
 /// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index c011f9661ae..0bb40ee4b31 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -718,7 +718,6 @@ pub use core::todo;
 // Re-export built-in macros defined through core.
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
 #[allow(deprecated)]
-#[cfg_attr(bootstrap, allow(deprecated_in_future))]
 pub use core::{
     assert, assert_matches, cfg, column, compile_error, concat, concat_idents, const_format_args,
     env, file, format_args, format_args_nl, include, include_bytes, include_str, line, log_syntax,
diff --git a/library/std/src/prelude/v1.rs b/library/std/src/prelude/v1.rs
index 68c9ac1e414..c15d8c40085 100644
--- a/library/std/src/prelude/v1.rs
+++ b/library/std/src/prelude/v1.rs
@@ -46,7 +46,6 @@ pub use crate::result::Result::{self, Err, Ok};
 // Re-exported built-in macros
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
 #[allow(deprecated)]
-#[cfg_attr(bootstrap, allow(deprecated_in_future))]
 #[doc(no_inline)]
 pub use core::prelude::v1::{
     assert, cfg, column, compile_error, concat, concat_idents, env, file, format_args,
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index 6838f15e174..26b2fb44724 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -1676,7 +1676,7 @@ impl fmt::Debug for Thread {
 /// [`Result`]: crate::result::Result
 /// [`std::panic::resume_unwind`]: crate::panic::resume_unwind
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(bootstrap), doc(search_unbox))]
+#[doc(search_unbox)]
 pub type Result<T> = crate::result::Result<T, Box<dyn Any + Send + 'static>>;
 
 // This packet is used to communicate the return value between the spawned
diff --git a/library/std/tests/floats/f128.rs b/library/std/tests/floats/f128.rs
index 8b13d6e6558..c2618f3b315 100644
--- a/library/std/tests/floats/f128.rs
+++ b/library/std/tests/floats/f128.rs
@@ -1,11 +1,9 @@
 // FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
-#![cfg(not(bootstrap))]
 #![cfg(target_has_reliable_f128)]
 
 use std::f128::consts;
 use std::num::FpCategory as Fp;
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 use std::ops::Rem;
 use std::ops::{Add, Div, Mul, Sub};
@@ -23,7 +21,6 @@ const TOL: f128 = 1e-12;
 /// Tolerances for math that is allowed to be imprecise, usually due to multiple chained
 /// operations.
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 const TOL_IMPR: f128 = 1e-10;
 
@@ -76,7 +73,6 @@ fn test_num_f128() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_num_f128_rem() {
     let ten = 10f128;
@@ -86,7 +82,6 @@ fn test_num_f128_rem() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_min_nan() {
     assert_eq!(f128::NAN.min(2.0), 2.0);
@@ -95,7 +90,6 @@ fn test_min_nan() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_max_nan() {
     assert_eq!(f128::NAN.max(2.0), 2.0);
@@ -104,7 +98,6 @@ fn test_max_nan() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_minimum() {
     assert!(f128::NAN.minimum(2.0).is_nan());
@@ -113,7 +106,6 @@ fn test_minimum() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_maximum() {
     assert!(f128::NAN.maximum(2.0).is_nan());
@@ -272,7 +264,6 @@ fn test_classify() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_floor() {
     assert_approx_eq!(1.0f128.floor(), 1.0f128, TOL_PRECISE);
@@ -289,7 +280,6 @@ fn test_floor() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_ceil() {
     assert_approx_eq!(1.0f128.ceil(), 1.0f128, TOL_PRECISE);
@@ -306,7 +296,6 @@ fn test_ceil() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_round() {
     assert_approx_eq!(2.5f128.round(), 3.0f128, TOL_PRECISE);
@@ -324,7 +313,6 @@ fn test_round() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_round_ties_even() {
     assert_approx_eq!(2.5f128.round_ties_even(), 2.0f128, TOL_PRECISE);
@@ -342,7 +330,6 @@ fn test_round_ties_even() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_trunc() {
     assert_approx_eq!(1.0f128.trunc(), 1.0f128, TOL_PRECISE);
@@ -359,7 +346,6 @@ fn test_trunc() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_fract() {
     assert_approx_eq!(1.0f128.fract(), 0.0f128, TOL_PRECISE);
@@ -376,7 +362,6 @@ fn test_fract() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_abs() {
     assert_eq!(f128::INFINITY.abs(), f128::INFINITY);
@@ -478,7 +463,6 @@ fn test_next_down() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_mul_add() {
     let nan: f128 = f128::NAN;
@@ -497,7 +481,6 @@ fn test_mul_add() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_recip() {
     let nan: f128 = f128::NAN;
@@ -521,7 +504,6 @@ fn test_recip() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_powi() {
     let nan: f128 = f128::NAN;
@@ -538,7 +520,6 @@ fn test_powi() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_powf() {
     let nan: f128 = f128::NAN;
@@ -557,7 +538,6 @@ fn test_powf() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_sqrt_domain() {
     assert!(f128::NAN.sqrt().is_nan());
@@ -571,7 +551,6 @@ fn test_sqrt_domain() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_exp() {
     assert_eq!(1.0, 0.0f128.exp());
@@ -588,7 +567,6 @@ fn test_exp() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_exp2() {
     assert_eq!(32.0, 5.0f128.exp2());
@@ -604,7 +582,6 @@ fn test_exp2() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_ln() {
     let nan: f128 = f128::NAN;
@@ -622,7 +599,6 @@ fn test_ln() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_log() {
     let nan: f128 = f128::NAN;
@@ -643,7 +619,6 @@ fn test_log() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_log2() {
     let nan: f128 = f128::NAN;
@@ -662,7 +637,6 @@ fn test_log2() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_log10() {
     let nan: f128 = f128::NAN;
@@ -714,7 +688,6 @@ fn test_to_radians() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_asinh() {
     // Lower accuracy results are allowed, use increased tolerances
@@ -747,7 +720,6 @@ fn test_asinh() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_acosh() {
     assert_eq!(1.0f128.acosh(), 0.0f128);
@@ -768,7 +740,6 @@ fn test_acosh() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_atanh() {
     assert_eq!(0.0f128.atanh(), 0.0f128);
@@ -790,7 +761,6 @@ fn test_atanh() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_gamma() {
     // precision can differ among platforms
@@ -813,7 +783,6 @@ fn test_gamma() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f128_math)]
 fn test_ln_gamma() {
     assert_approx_eq!(1.0f128.ln_gamma().0, 0.0f128, TOL_IMPR);
@@ -846,7 +815,6 @@ fn test_real_consts() {
     assert_approx_eq!(frac_2_pi, 2f128 / pi, TOL_PRECISE);
 
     #[cfg(not(miri))]
-    #[cfg(not(bootstrap))]
     #[cfg(target_has_reliable_f128_math)]
     {
         let frac_2_sqrtpi: f128 = consts::FRAC_2_SQRT_PI;
diff --git a/library/std/tests/floats/f16.rs b/library/std/tests/floats/f16.rs
index 8b3b344dd46..70bbcd07160 100644
--- a/library/std/tests/floats/f16.rs
+++ b/library/std/tests/floats/f16.rs
@@ -1,5 +1,4 @@
 // FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
-#![cfg(not(bootstrap))]
 #![cfg(target_has_reliable_f16)]
 
 use std::f16::consts;
@@ -63,7 +62,6 @@ fn test_num_f16() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_min_nan() {
     assert_eq!(f16::NAN.min(2.0), 2.0);
@@ -72,7 +70,6 @@ fn test_min_nan() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_max_nan() {
     assert_eq!(f16::NAN.max(2.0), 2.0);
@@ -81,7 +78,6 @@ fn test_max_nan() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_minimum() {
     assert!(f16::NAN.minimum(2.0).is_nan());
@@ -90,7 +86,6 @@ fn test_minimum() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_maximum() {
     assert!(f16::NAN.maximum(2.0).is_nan());
@@ -249,7 +244,6 @@ fn test_classify() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_floor() {
     assert_approx_eq!(1.0f16.floor(), 1.0f16, TOL_0);
@@ -266,7 +260,6 @@ fn test_floor() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_ceil() {
     assert_approx_eq!(1.0f16.ceil(), 1.0f16, TOL_0);
@@ -283,7 +276,6 @@ fn test_ceil() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_round() {
     assert_approx_eq!(2.5f16.round(), 3.0f16, TOL_0);
@@ -301,7 +293,6 @@ fn test_round() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_round_ties_even() {
     assert_approx_eq!(2.5f16.round_ties_even(), 2.0f16, TOL_0);
@@ -319,7 +310,6 @@ fn test_round_ties_even() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_trunc() {
     assert_approx_eq!(1.0f16.trunc(), 1.0f16, TOL_0);
@@ -336,7 +326,6 @@ fn test_trunc() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_fract() {
     assert_approx_eq!(1.0f16.fract(), 0.0f16, TOL_0);
@@ -353,7 +342,6 @@ fn test_fract() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_abs() {
     assert_eq!(f16::INFINITY.abs(), f16::INFINITY);
@@ -455,7 +443,6 @@ fn test_next_down() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_mul_add() {
     let nan: f16 = f16::NAN;
@@ -474,7 +461,6 @@ fn test_mul_add() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_recip() {
     let nan: f16 = f16::NAN;
@@ -492,7 +478,6 @@ fn test_recip() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_powi() {
     let nan: f16 = f16::NAN;
@@ -509,7 +494,6 @@ fn test_powi() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_powf() {
     let nan: f16 = f16::NAN;
@@ -528,7 +512,6 @@ fn test_powf() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_sqrt_domain() {
     assert!(f16::NAN.sqrt().is_nan());
@@ -542,7 +525,6 @@ fn test_sqrt_domain() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_exp() {
     assert_eq!(1.0, 0.0f16.exp());
@@ -559,7 +541,6 @@ fn test_exp() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_exp2() {
     assert_eq!(32.0, 5.0f16.exp2());
@@ -575,7 +556,6 @@ fn test_exp2() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_ln() {
     let nan: f16 = f16::NAN;
@@ -593,7 +573,6 @@ fn test_ln() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_log() {
     let nan: f16 = f16::NAN;
@@ -614,7 +593,6 @@ fn test_log() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_log2() {
     let nan: f16 = f16::NAN;
@@ -633,7 +611,6 @@ fn test_log2() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_log10() {
     let nan: f16 = f16::NAN;
@@ -683,7 +660,6 @@ fn test_to_radians() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_asinh() {
     assert_eq!(0.0f16.asinh(), 0.0f16);
@@ -710,7 +686,6 @@ fn test_asinh() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_acosh() {
     assert_eq!(1.0f16.acosh(), 0.0f16);
@@ -731,7 +706,6 @@ fn test_acosh() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_atanh() {
     assert_eq!(0.0f16.atanh(), 0.0f16);
@@ -753,7 +727,6 @@ fn test_atanh() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_gamma() {
     // precision can differ among platforms
@@ -776,7 +749,6 @@ fn test_gamma() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_ln_gamma() {
     assert_approx_eq!(1.0f16.ln_gamma().0, 0.0f16, TOL_0);
@@ -811,7 +783,6 @@ fn test_real_consts() {
     assert_approx_eq!(frac_2_pi, 2f16 / pi, TOL_0);
 
     #[cfg(not(miri))]
-    #[cfg(not(bootstrap))]
     #[cfg(target_has_reliable_f16_math)]
     {
         let frac_2_sqrtpi: f16 = consts::FRAC_2_SQRT_PI;
@@ -874,7 +845,6 @@ fn test_clamp_max_is_nan() {
 
 #[test]
 #[cfg(not(miri))]
-#[cfg(not(bootstrap))]
 #[cfg(target_has_reliable_f16_math)]
 fn test_total_cmp() {
     use core::cmp::Ordering;
diff --git a/library/std/tests/floats/lib.rs b/library/std/tests/floats/lib.rs
index 7884fc9239e..453a2d533ab 100644
--- a/library/std/tests/floats/lib.rs
+++ b/library/std/tests/floats/lib.rs
@@ -1,6 +1,6 @@
 #![feature(f16, f128, float_algebraic, float_gamma, float_minimum_maximum)]
-#![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
-#![cfg_attr(not(bootstrap), expect(internal_features))] // for reliable_f16_f128
+#![feature(cfg_target_has_reliable_f16_f128)]
+#![expect(internal_features)] // for reliable_f16_f128
 
 use std::fmt;
 use std::ops::{Add, Div, Mul, Rem, Sub};
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-10-29 14:55:33 +0000