diff --git a/library/core/src/iter/traits/double_ended.rs b/library/core/src/iter/traits/double_ended.rs
index a7c8ec9319a07..3c3db756d91ea 100644
--- a/library/core/src/iter/traits/double_ended.rs
+++ b/library/core/src/iter/traits/double_ended.rs
@@ -189,13 +189,49 @@ pub const trait DoubleEndedIterator: [const] Iterator {
     where
         Self::Item: [const] Destruct,
     {
-        for i in 0..n {
-            if self.next_back().is_none() {
-                // SAFETY: `i` is always less than `n`.
-                return Err(unsafe { NonZero::new_unchecked(n - i) });
+        /// Helper trait to specialize `advance_back_by` via `try_rfold` for `Sized` iterators.
+
+        #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+        const trait SpecAdvanceBackBy {
+            fn spec_advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>;
+        }
+
+        #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+        const impl<I: [const] DoubleEndedIterator + ?Sized> SpecAdvanceBackBy for I
+        where
+            I::Item: [const] Destruct,
+        {
+            default fn spec_advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+                for i in 0..n {
+                    if self.next_back().is_none() {
+                        // SAFETY: `i` is always less than `n`.
+                        return Err(unsafe { NonZero::new_unchecked(n - i) });
+                    }
+                }
+                Ok(())
             }
         }
-        Ok(())
+
+        #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+        const impl<I: [const] DoubleEndedIterator> SpecAdvanceBackBy for I
+        where
+            I::Item: [const] Destruct,
+        {
+            fn spec_advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+                let Some(n) = NonZero::new(n) else {
+                    return Ok(());
+                };
+
+                let res = self.try_rfold(n, const |n, _| NonZero::new(n.get() - 1));
+
+                match res {
+                    None => Ok(()),
+                    Some(n) => Err(n),
+                }
+            }
+        }
+
+        self.spec_advance_back_by(n)
     }
 
     /// Returns the `n`th element from the end of the iterator.
@@ -245,9 +281,7 @@ pub const trait DoubleEndedIterator: [const] Iterator {
     where
         Self::Item: [const] Destruct,
     {
-        if self.advance_back_by(n).is_err() {
-            return None;
-        }
+        self.advance_back_by(n).ok()?;
         self.next_back()
     }
 
diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index db05d7fdc5087..e53e4df1ea43d 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -1544,9 +1544,10 @@ impl f128 {
     /// ```
     #[inline]
     #[unstable(feature = "clamp_magnitude", issue = "148519")]
-    #[must_use = "this returns the clamped value and does not modify the original"]
+    #[rustc_const_unstable(feature = "clamp_magnitude", issue = "148519")]
+    #[must_use = "method returns a new number and does not mutate the original value"]
     #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "NaN is also invalid")]
-    pub fn clamp_magnitude(self, limit: f128) -> f128 {
+    pub const fn clamp_magnitude(self, limit: f128) -> f128 {
         assert!(limit >= 0.0, "limit must be non-negative and not NaN");
         let limit = limit.abs(); // Canonicalises -0.0 to 0.0
         self.clamp(-limit, limit)
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 273ef3688ca5f..4ad41bd6cfa4b 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -1530,9 +1530,10 @@ impl f16 {
     /// ```
     #[inline]
     #[unstable(feature = "clamp_magnitude", issue = "148519")]
-    #[must_use = "this returns the clamped value and does not modify the original"]
+    #[rustc_const_unstable(feature = "clamp_magnitude", issue = "148519")]
+    #[must_use = "method returns a new number and does not mutate the original value"]
     #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "NaN is also invalid")]
-    pub fn clamp_magnitude(self, limit: f16) -> f16 {
+    pub const fn clamp_magnitude(self, limit: f16) -> f16 {
         assert!(limit >= 0.0, "limit must be non-negative and not NaN");
         let limit = limit.abs(); // Canonicalises -0.0 to 0.0
         self.clamp(-limit, limit)
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index d3dea38dc2fcf..2dc3ddf31cac5 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1699,11 +1699,11 @@ impl f32 {
     /// assert_eq!(2.0f32.clamp_magnitude(3.0), 2.0);
     /// assert_eq!((-2.0f32).clamp_magnitude(3.0), -2.0);
     /// ```
-    #[must_use = "this returns the clamped value and does not modify the original"]
-    #[unstable(feature = "clamp_magnitude", issue = "148519")]
     #[inline]
+    #[unstable(feature = "clamp_magnitude", issue = "148519")]
+    #[must_use = "method returns a new number and does not mutate the original value"]
     #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "NaN is also invalid")]
-    pub fn clamp_magnitude(self, limit: f32) -> f32 {
+    pub const fn clamp_magnitude(self, limit: f32) -> f32 {
         assert!(limit >= 0.0, "limit must be non-negative and not NaN");
         let limit = limit.abs(); // Canonicalises -0.0 to 0.0
         self.clamp(-limit, limit)
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 7c5082749cd11..cd3cfe1bd4c60 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -1677,11 +1677,11 @@ impl f64 {
     /// assert_eq!(2.0f64.clamp_magnitude(3.0), 2.0);
     /// assert_eq!((-2.0f64).clamp_magnitude(3.0), -2.0);
     /// ```
-    #[must_use = "this returns the clamped value and does not modify the original"]
-    #[unstable(feature = "clamp_magnitude", issue = "148519")]
     #[inline]
+    #[unstable(feature = "clamp_magnitude", issue = "148519")]
+    #[must_use = "method returns a new number and does not mutate the original value"]
     #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "NaN is also invalid")]
-    pub fn clamp_magnitude(self, limit: f64) -> f64 {
+    pub const fn clamp_magnitude(self, limit: f64) -> f64 {
         assert!(limit >= 0.0, "limit must be non-negative and not NaN");
         let limit = limit.abs(); // Canonicalises -0.0 to 0.0
         self.clamp(-limit, limit)
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 4cbd012e0021b..058c0229aa530 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -3961,14 +3961,15 @@ macro_rules! int_impl {
         /// ```
         /// #![feature(clamp_magnitude)]
         #[doc = concat!("assert_eq!(120", stringify!($SelfT), ".clamp_magnitude(100), 100);")]
-        #[doc = concat!("assert_eq!(-120", stringify!($SelfT), ".clamp_magnitude(100), -100);")]
+        #[doc = concat!("assert_eq!((-120", stringify!($SelfT), ").clamp_magnitude(100), -100);")]
         #[doc = concat!("assert_eq!(80", stringify!($SelfT), ".clamp_magnitude(100), 80);")]
-        #[doc = concat!("assert_eq!(-80", stringify!($SelfT), ".clamp_magnitude(100), -80);")]
+        #[doc = concat!("assert_eq!((-80", stringify!($SelfT), ").clamp_magnitude(100), -80);")]
         /// ```
-        #[must_use = "this returns the clamped value and does not modify the original"]
-        #[unstable(feature = "clamp_magnitude", issue = "148519")]
         #[inline]
-        pub fn clamp_magnitude(self, limit: $UnsignedT) -> Self {
+        #[must_use = "method returns a new number and does not mutate the original value"]
+        #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+        #[unstable(feature = "clamp_magnitude", issue = "148519")]
+        pub const fn clamp_magnitude(self, limit: $UnsignedT) -> Self {
             if let Ok(limit) = core::convert::TryInto::<$SelfT>::try_into(limit) {
                 self.clamp(-limit, limit)
             } else {
diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs
index 355e9a3c59da7..c97e6f4c45395 100644
--- a/library/core/src/num/nonzero.rs
+++ b/library/core/src/num/nonzero.rs
@@ -2612,6 +2612,50 @@ macro_rules! nonzero_integer_signedness_dependent_methods {
             unsafe { NonZero::new_unchecked(self.get().cast_unsigned()) }
         }
 
+        /// Clamps this number to a symmetric range centred around zero.
+        ///
+        /// The method clamps the number's magnitude (absolute value) to be at most `limit`.
+        ///
+        /// This is functionally equivalent to `self.clamp(-limit, limit)`, but is more
+        /// explicit about the intent.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(clamp_magnitude)]
+        /// # use std::num::NonZero;
+        /// #
+        #[doc = concat!("let limit = NonZero::<", stringify!($Uint), ">::new(100).unwrap();")]
+        ///
+        /// assert_eq!(
+        #[doc = concat!("    NonZero::<", stringify!($Int), ">::new(120).unwrap().clamp_magnitude(limit),")]
+        #[doc = concat!("    NonZero::<", stringify!($Int), ">::new(100).unwrap(),")]
+        /// );
+        ///
+        /// assert_eq!(
+        #[doc = concat!("    NonZero::<", stringify!($Int), ">::new(-120).unwrap().clamp_magnitude(limit),")]
+        #[doc = concat!("    NonZero::<", stringify!($Int), ">::new(-100).unwrap(),")]
+        /// );
+        ///
+        /// assert_eq!(
+        #[doc = concat!("    NonZero::<", stringify!($Int), ">::new(80).unwrap().clamp_magnitude(limit),")]
+        #[doc = concat!("    NonZero::<", stringify!($Int), ">::new(80).unwrap(),")]
+        /// );
+        ///
+        /// assert_eq!(
+        #[doc = concat!("    NonZero::<", stringify!($Int), ">::new(-80).unwrap().clamp_magnitude(limit),")]
+        #[doc = concat!("    NonZero::<", stringify!($Int), ">::new(-80).unwrap(),")]
+        /// );
+        /// ```
+        #[inline]
+        #[must_use = "method returns a new number and does not mutate the original value"]
+        #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+        #[unstable(feature = "clamp_magnitude", issue = "148519")]
+        pub const fn clamp_magnitude(self, limit: NonZero<$Uint>) -> Self {
+            // SAFETY: a non-zero value clamped to the magnitude of a non-zero value is still non-zero.
+            unsafe { Self::new_unchecked(self.get().clamp_magnitude(limit.get())) }
+        }
+
     };
 }
 
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 1334b551217a8..fc2430a10edb4 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -15,6 +15,7 @@
 #![feature(cfg_overflow_checks)]
 #![feature(cfg_target_has_reliable_f16_f128)]
 #![feature(char_internals)]
+#![feature(clamp_magnitude)]
 #![feature(clamp_to)]
 #![feature(clone_to_uninit)]
 #![feature(cmp_minmax)]
diff --git a/library/coretests/tests/num/clamp_magnitude.rs b/library/coretests/tests/num/clamp_magnitude.rs
index 0f96e55f6914e..5bccc4ad45e20 100644
--- a/library/coretests/tests/num/clamp_magnitude.rs
+++ b/library/coretests/tests/num/clamp_magnitude.rs
@@ -1,3 +1,7 @@
+use core::num::*;
+
+use crate::num::assert_biteq;
+
 macro_rules! check_int_clamp {
     ($t:ty, $ut:ty) => {
         let min = <$t>::MIN;
@@ -32,6 +36,16 @@ macro_rules! check_int_clamp {
         // Limit larger than type max (uN > iN::MAX)
         assert_eq!(max.clamp_magnitude(max_u), max);
         assert_eq!(min.clamp_magnitude(max_u), min);
+
+        // Const clamping
+        const C1: $t = (100 as $t).clamp_magnitude(50);
+        assert_eq!(C1, 50);
+        const C2: $t = (-100 as $t).clamp_magnitude(50);
+        assert_eq!(C2, -50);
+        const C3: $t = (30 as $t).clamp_magnitude(50);
+        assert_eq!(C3, 30);
+        const C4: $t = (-30 as $t).clamp_magnitude(50);
+        assert_eq!(C4, -30);
     };
 }
 
@@ -65,8 +79,81 @@ fn test_clamp_magnitude_isize() {
     check_int_clamp!(isize, usize);
 }
 
+macro_rules! check_nonzero_clamp {
+    ($t:ty, $ut:ty) => {
+        let min = <$t>::MIN;
+        let max = <$t>::MAX;
+        let max_u = <$ut>::MAX;
+
+        // Basic clamping
+        let lim = <$ut>::new(50).unwrap();
+        assert_eq!(<$t>::new(100).unwrap().clamp_magnitude(lim), <$t>::new(50).unwrap());
+        assert_eq!(<$t>::new(-100).unwrap().clamp_magnitude(lim), <$t>::new(-50).unwrap());
+        assert_eq!(<$t>::new(30).unwrap().clamp_magnitude(lim), <$t>::new(30).unwrap());
+        assert_eq!(<$t>::new(-30).unwrap().clamp_magnitude(lim), <$t>::new(-30).unwrap());
+
+        // Exact boundary
+        assert_eq!(<$t>::new(50).unwrap().clamp_magnitude(lim), <$t>::new(50).unwrap());
+        assert_eq!(<$t>::new(-50).unwrap().clamp_magnitude(lim), <$t>::new(-50).unwrap());
+
+        // MIN/MAX values
+        // Symmetric range [-MAX, MAX]
+        assert_eq!(max.clamp_magnitude(max.try_into().unwrap()), max);
+        assert_eq!(min.clamp_magnitude(max.try_into().unwrap()), -max);
+
+        // Full range (limit covers MIN)
+        let min_abs = min.unsigned_abs();
+        assert_eq!(min.clamp_magnitude(min_abs), min);
+
+        // Limit larger than type max (uN > iN::MAX)
+        assert_eq!(max.clamp_magnitude(max_u), max);
+        assert_eq!(min.clamp_magnitude(max_u), min);
+
+        // Const clamping
+        const LIM: $ut = <$ut>::new(50).unwrap();
+        const C1: $t = <$t>::new(100).unwrap().clamp_magnitude(LIM);
+        assert_eq!(C1, <$t>::new(50).unwrap());
+        const C2: $t = <$t>::new(-100).unwrap().clamp_magnitude(LIM);
+        assert_eq!(C2, <$t>::new(-50).unwrap());
+        const C3: $t = <$t>::new(30).unwrap().clamp_magnitude(LIM);
+        assert_eq!(C3, <$t>::new(30).unwrap());
+        const C4: $t = <$t>::new(-30).unwrap().clamp_magnitude(LIM);
+        assert_eq!(C4, <$t>::new(-30).unwrap());
+    };
+}
+
+#[test]
+fn test_clamp_magnitude_nonzero_i8() {
+    check_nonzero_clamp!(NonZeroI8, NonZeroU8);
+}
+
+#[test]
+fn test_clamp_magnitude_nonzero_i16() {
+    check_nonzero_clamp!(NonZeroI16, NonZeroU16);
+}
+
+#[test]
+fn test_clamp_magnitude_nonzero_i32() {
+    check_nonzero_clamp!(NonZeroI32, NonZeroU32);
+}
+
+#[test]
+fn test_clamp_magnitude_nonzero_i64() {
+    check_nonzero_clamp!(NonZeroI64, NonZeroU64);
+}
+
+#[test]
+fn test_clamp_magnitude_nonzero_i128() {
+    check_nonzero_clamp!(NonZeroI128, NonZeroU128);
+}
+
+#[test]
+fn test_clamp_magnitude_nonzero_isize() {
+    check_nonzero_clamp!(NonZeroIsize, NonZeroUsize);
+}
+
 macro_rules! check_float_clamp {
-    ($t:ty) => {
+    ($t:ty, $huge: expr) => {
         // Basic clamping
         assert_eq!((5.0 as $t).clamp_magnitude(3.0), 3.0);
         assert_eq!((-5.0 as $t).clamp_magnitude(3.0), -3.0);
@@ -78,10 +165,13 @@ macro_rules! check_float_clamp {
         assert_eq!((-3.0 as $t).clamp_magnitude(3.0), -3.0);
 
         // Zero cases
-        assert_eq!((0.0 as $t).clamp_magnitude(1.0), 0.0);
-        assert_eq!((-0.0 as $t).clamp_magnitude(1.0), 0.0);
-        assert_eq!((5.0 as $t).clamp_magnitude(0.0), 0.0);
-        assert_eq!((-5.0 as $t).clamp_magnitude(0.0), 0.0);
+        type Float = $t;
+        assert_biteq!((0.0 as $t).clamp_magnitude(1.0), 0.0);
+        assert_biteq!((-0.0 as $t).clamp_magnitude(1.0), -0.0);
+        assert_biteq!((5.0 as $t).clamp_magnitude(0.0), 0.0);
+        assert_biteq!((-5.0 as $t).clamp_magnitude(0.0), -0.0);
+        assert_biteq!((5.0 as $t).clamp_magnitude(-0.0), 0.0);
+        assert_biteq!((-5.0 as $t).clamp_magnitude(-0.0), -0.0);
 
         // Special values - Infinity
         let inf = <$t>::INFINITY;
@@ -98,42 +188,89 @@ macro_rules! check_float_clamp {
         let max = <$t>::MAX;
         let min = <$t>::MIN;
         // Large limit
-        let huge = 1e30;
-        assert_eq!(max.clamp_magnitude(huge), huge);
-        assert_eq!(min.clamp_magnitude(huge), -huge);
+        assert_eq!(max.clamp_magnitude($huge), $huge);
+        assert_eq!(min.clamp_magnitude($huge), -$huge);
+
+        // NaN
+        let nan = <$t>::NAN;
+        assert!(nan.clamp_magnitude(1.0).is_nan());
+
+        // Const clamping
+        const C1: $t = (5.0 as $t).clamp_magnitude(3.0);
+        assert_eq!(C1, 3.0);
+        const C2: $t = (-5.0 as $t).clamp_magnitude(3.0);
+        assert_eq!(C2, -3.0);
+        const C3: $t = (2.0 as $t).clamp_magnitude(3.0);
+        assert_eq!(C3, 2.0);
+        const C4: $t = (-2.0 as $t).clamp_magnitude(3.0);
+        assert_eq!(C4, -2.0);
     };
 }
 
+#[test]
+fn test_clamp_magnitude_f16() {
+    check_float_clamp!(f16, 1e3);
+}
+
 #[test]
 fn test_clamp_magnitude_f32() {
-    check_float_clamp!(f32);
+    check_float_clamp!(f32, 1e30);
 }
 
 #[test]
 fn test_clamp_magnitude_f64() {
-    check_float_clamp!(f64);
+    check_float_clamp!(f64, 1e300);
+}
+
+#[test]
+fn test_clamp_magnitude_f128() {
+    check_float_clamp!(f128, 1e3000);
 }
 
 #[test]
-#[should_panic(expected = "limit must be non-negative")]
+#[should_panic(expected = "limit must be non-negative and not NaN")]
+fn test_clamp_magnitude_f16_panic_negative_limit() {
+    let _ = 1.0f16.clamp_magnitude(-1.0);
+}
+
+#[test]
+#[should_panic(expected = "limit must be non-negative and not NaN")]
 fn test_clamp_magnitude_f32_panic_negative_limit() {
     let _ = 1.0f32.clamp_magnitude(-1.0);
 }
 
 #[test]
-#[should_panic(expected = "limit must be non-negative")]
+#[should_panic(expected = "limit must be non-negative and not NaN")]
 fn test_clamp_magnitude_f64_panic_negative_limit() {
     let _ = 1.0f64.clamp_magnitude(-1.0);
 }
 
 #[test]
-#[should_panic]
+#[should_panic(expected = "limit must be non-negative and not NaN")]
+fn test_clamp_magnitude_f128_panic_negative_limit() {
+    let _ = 1.0f128.clamp_magnitude(-1.0);
+}
+
+#[test]
+#[should_panic(expected = "limit must be non-negative and not NaN")]
+fn test_clamp_magnitude_f16_panic_nan_limit() {
+    let _ = 1.0f16.clamp_magnitude(f16::NAN);
+}
+
+#[test]
+#[should_panic(expected = "limit must be non-negative and not NaN")]
 fn test_clamp_magnitude_f32_panic_nan_limit() {
     let _ = 1.0f32.clamp_magnitude(f32::NAN);
 }
 
 #[test]
-#[should_panic]
+#[should_panic(expected = "limit must be non-negative and not NaN")]
 fn test_clamp_magnitude_f64_panic_nan_limit() {
     let _ = 1.0f64.clamp_magnitude(f64::NAN);
 }
+
+#[test]
+#[should_panic(expected = "limit must be non-negative and not NaN")]
+fn test_clamp_magnitude_f128_panic_nan_limit() {
+    let _ = 1.0f128.clamp_magnitude(f128::NAN);
+}
diff --git a/library/coretests/tests/num/mod.rs b/library/coretests/tests/num/mod.rs
index b1c3001790f07..f892734d8b95d 100644
--- a/library/coretests/tests/num/mod.rs
+++ b/library/coretests/tests/num/mod.rs
@@ -24,6 +24,7 @@ mod u8;
 mod bignum;
 mod carryless_mul;
 mod cast;
+mod clamp_magnitude;
 mod complex;
 mod const_from;
 mod dec2flt;
diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs
index 65b8ed634bc05..3f0f276551b45 100644
--- a/library/std/src/fs.rs
+++ b/library/std/src/fs.rs
@@ -1637,6 +1637,8 @@ impl Dir {
 
     /// Queries metadata about the underlying directory.
     ///
+    /// This is equivalent to `dir.metadata(".")` but can be more efficient.
+    ///
     /// # Examples
     ///
     /// ```no_run
@@ -1645,13 +1647,13 @@ impl Dir {
     ///
     /// fn main() -> std::io::Result<()> {
     ///     let dir = Dir::open("foo")?;
-    ///     let metadata = dir.metadata()?;
+    ///     let metadata = dir.self_metadata()?;
     ///     Ok(())
     /// }
     /// ```
     #[unstable(feature = "dirfd", issue = "120426")]
-    pub fn metadata(&self) -> io::Result<Metadata> {
-        self.inner.metadata().map(Metadata)
+    pub fn self_metadata(&self) -> io::Result<Metadata> {
+        self.inner.self_metadata().map(Metadata)
     }
 
     /// Attempts to open a file in read-only mode relative to this directory.
@@ -1891,6 +1893,54 @@ impl Dir {
     pub fn try_clone(&self) -> io::Result<Self> {
         Ok(Dir { inner: self.inner.duplicate()? })
     }
+
+    /// Queries the file system to get information about a file, directory, etc. relative to this
+    /// directory.
+    ///
+    /// This function will traverse symbolic links to query information about the destination file.
+    /// To query metadata about the path itself without following symbolic links, use
+    /// [`symlink_metadata`][Self::symlink_metadata].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(dirfd)]
+    /// use std::fs::Dir;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let dir = Dir::open("foo")?;
+    ///     let metadata = dir.metadata("subdir/file.txt")?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "dirfd", issue = "120426")]
+    pub fn metadata<P: AsRef<Path>>(&self, path: P) -> io::Result<Metadata> {
+        self.inner.metadata(path.as_ref()).map(Metadata)
+    }
+
+    /// Queries the file system to get information about a file, directory, etc. relative to this
+    /// directory.
+    ///
+    /// This function will return the [`Metadata`] of the exact path without traversing symbolic
+    /// links to a resolved destination file. Using this function on a path that is a file or
+    /// directory (not a symbolic link) will behave the same as [`metadata`][Self::metadata].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(dirfd)]
+    /// use std::fs::Dir;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let dir = Dir::open("foo")?;
+    ///     let metadata = dir.symlink_metadata("subdir/file.txt")?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "dirfd", issue = "120426")]
+    pub fn symlink_metadata<P: AsRef<Path>>(&self, path: P) -> io::Result<Metadata> {
+        self.inner.symlink_metadata(path.as_ref()).map(Metadata)
+    }
 }
 
 impl AsInner<fs_imp::Dir> for Dir {
diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs
index db9a9f3f20b88..2760cd6b13f2a 100644
--- a/library/std/src/fs/tests.rs
+++ b/library/std/src/fs/tests.rs
@@ -13,7 +13,7 @@ use crate::os::unix::fs::symlink as symlink_file;
 use crate::os::unix::fs::symlink as junction_point;
 #[cfg(windows)]
 use crate::os::windows::fs::{OpenOptionsExt, junction_point, symlink_dir, symlink_file};
-use crate::path::Path;
+use crate::path::{Path, PathBuf};
 use crate::sync::Arc;
 use crate::test_helpers::{TempDir, tmpdir};
 use crate::time::{Duration, Instant, SystemTime};
@@ -655,11 +655,6 @@ fn set_get_permissions_nofollows() {
     not(any(target_os = "espidf", target_os = "horizon", target_os = "wasi"))
 ))]
 fn set_get_permissions_nofollows_symlink() {
-    #[cfg(not(windows))]
-    use crate::os::unix::fs::symlink as symlink_file;
-    #[cfg(windows)]
-    use crate::os::windows::fs::symlink_file;
-
     let tmpdir = tmpdir();
     let filename = tmpdir.join("set_get_unix_permissions_file");
     let symlink_name = tmpdir.join("set_get_unix_permissions");
@@ -3052,10 +3047,10 @@ fn test_dir_clone() {
 }
 
 #[test]
-fn test_dir_metadata() {
+fn test_dir_self_metadata() {
     let tmpdir = tmpdir();
     let dir = check!(Dir::open(tmpdir.path()));
-    let metadata = check!(dir.metadata());
+    let metadata = check!(dir.self_metadata());
     assert!(metadata.is_dir());
 }
 
@@ -3143,3 +3138,27 @@ fn test_dir_open_dir() {
     check!(f.read_exact(&mut buf));
     assert_eq!(b"baz", &buf);
 }
+
+#[test]
+fn test_dir_metadata() {
+    let tmpdir = tmpdir();
+    let dir = check!(Dir::open(tmpdir.path()));
+    check!(dir.create_dir("subdir"));
+    // FIXME: `/` does not work as path separator on Windows.
+    let barpath = PathBuf::from("subdir").join("bar.txt");
+    drop(check!(dir.open_file_with(&barpath, &OpenOptions::new().create(true).write(true))));
+    check!(symlink_file(&tmpdir.join("subdir/bar.txt"), &tmpdir.join("link")));
+
+    let metadata = check!(dir.metadata(&barpath));
+    assert!(metadata.is_file());
+    let metadata = check!(dir.metadata("subdir"));
+    assert!(metadata.is_dir());
+    dir.metadata("does-not-exist").unwrap_err();
+
+    let metadata = check!(dir.metadata("link"));
+    assert!(metadata.is_file());
+    assert!(!metadata.is_symlink());
+    let metadata = check!(dir.symlink_metadata("link"));
+    assert!(!metadata.is_file());
+    assert!(metadata.is_symlink());
+}
diff --git a/library/std/src/sys/fs/common.rs b/library/std/src/sys/fs/common.rs
index b2472665fe465..1724e6115462e 100644
--- a/library/std/src/sys/fs/common.rs
+++ b/library/std/src/sys/fs/common.rs
@@ -85,7 +85,7 @@ impl Dir {
         File::open(&self.path.join(path), opts)
     }
 
-    pub fn metadata(&self) -> io::Result<FileAttr> {
+    pub fn self_metadata(&self) -> io::Result<FileAttr> {
         self.path.metadata().map(|m| m.into_inner())
     }
 
@@ -108,6 +108,14 @@ impl Dir {
     pub fn remove_dir(&self, path: &Path) -> io::Result<()> {
         remove_dir(self.path.join(path))
     }
+
+    pub fn metadata(&self, path: &Path) -> io::Result<FileAttr> {
+        self.path.join(path).metadata().map(|m| m.into_inner())
+    }
+
+    pub fn symlink_metadata(&self, path: &Path) -> io::Result<FileAttr> {
+        self.path.join(path).symlink_metadata().map(|m| m.into_inner())
+    }
 }
 
 impl fmt::Debug for Dir {
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index 46d5d33d23ac2..6d1c01be6078f 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -6,6 +6,39 @@
 #[cfg(test)]
 mod tests;
 
+// Import the file operations under consistent names.
+cfg_select! {
+    not(any(
+        all(target_os = "linux", not(target_env = "musl")),
+        target_os = "android",
+        target_os = "hurd",
+        target_os = "l4re",
+    )) => {
+        use libc::{
+            dirent as dirent64, fstat as fstat64, ftruncate as ftruncate64, lseek as lseek64,
+            lstat as lstat64, off_t as off64_t, open as open64, stat as stat64,
+        };
+    }
+    target_os = "android" => {
+        // Android's `stat`, `dirent`, and related functions are always 64-bit LFS compatible, and
+        // `open` already implies `O_LARGEFILE`, so all those don't need to follow Linux.
+        // However, we still need off64_t, ftruncate64, and lseek64.
+        use libc::{
+            dirent as dirent64, fstat as fstat64, ftruncate64, lseek64, lstat as lstat64, off64_t,
+            open as open64, stat as stat64,
+        };
+    }
+    target_os = "l4re" => {
+        use libc::{
+            dirent64, fstat as fstat64, ftruncate as ftruncate64, lseek as lseek64,
+            lstat as lstat64, off_t as off64_t, open as open64, stat as stat64,
+        };
+    }
+    _ => {
+        use libc::{dirent64, fstat64, ftruncate64, lseek64, lstat64, off64_t, open64, stat64};
+    }
+}
+
 #[cfg(all(target_os = "linux", target_env = "gnu"))]
 use libc::c_char;
 #[cfg(any(
@@ -17,33 +50,7 @@ use libc::c_char;
     target_vendor = "apple",
 ))]
 use libc::dirfd;
-#[cfg(any(target_os = "fuchsia", target_os = "illumos", target_vendor = "apple"))]
-use libc::fstatat as fstatat64;
-#[cfg(any(all(target_os = "linux", not(target_env = "musl")), target_os = "hurd"))]
-use libc::fstatat64;
 use libc::{c_int, mode_t};
-#[cfg(target_os = "android")]
-use libc::{
-    dirent as dirent64, fstat as fstat64, fstatat as fstatat64, ftruncate64, lseek64,
-    lstat as lstat64, off64_t, open as open64, stat as stat64,
-};
-#[cfg(not(any(
-    all(target_os = "linux", not(target_env = "musl")),
-    target_os = "android",
-    target_os = "hurd",
-    target_os = "l4re",
-)))]
-use libc::{
-    dirent as dirent64, fstat as fstat64, ftruncate as ftruncate64, lseek as lseek64,
-    lstat as lstat64, off_t as off64_t, open as open64, stat as stat64,
-};
-#[cfg(target_os = "l4re")]
-use libc::{
-    dirent64, fstat as fstat64, ftruncate as ftruncate64, lseek as lseek64, lstat as lstat64,
-    off_t as off64_t, open as open64, stat as stat64,
-};
-#[cfg(any(all(target_os = "linux", not(target_env = "musl")), target_os = "hurd"))]
-use libc::{dirent64, fstat64, ftruncate64, lseek64, lstat64, off64_t, open64, stat64};
 
 use crate::ffi::{CStr, OsStr, OsString};
 use crate::fmt::{self, Write as _};
@@ -1016,89 +1023,61 @@ impl DirEntry {
         self.file_name_os_str().to_os_string()
     }
 
-    #[cfg(all(
-        any(
-            all(target_os = "linux", not(target_env = "musl")),
-            target_os = "android",
-            target_os = "fuchsia",
-            target_os = "hurd",
-            target_os = "illumos",
-            target_vendor = "apple",
-        ),
-        not(miri) // no dirfd on Miri
-    ))]
     pub fn metadata(&self) -> io::Result<FileAttr> {
-        let fd = cvt(unsafe { dirfd(self.dir.dirp.0) })?;
-        let name = self.name.as_ptr();
-
-        cfg_has_statx! {
-            if let Some(ret) = unsafe { try_statx(
-                fd,
-                name,
-                libc::AT_SYMLINK_NOFOLLOW | libc::AT_STATX_SYNC_AS_STAT,
-                libc::STATX_BASIC_STATS | libc::STATX_BTIME,
-            ) } {
-                return ret;
-            }
-        }
+        cfg_select! {
+            // Use directory handle where possible
+            all(
+                any(
+                    all(target_os = "linux", not(target_env = "musl")),
+                    target_os = "android",
+                    target_os = "fuchsia",
+                    target_os = "hurd",
+                    target_os = "illumos",
+                    target_vendor = "apple",
+                ),
+                not(miri) // no dirfd on Miri
+            ) => {
+                let fd = cvt(unsafe { dirfd(self.dir.dirp.0) })?;
 
-        let mut stat: stat64 = unsafe { mem::zeroed() };
-        cvt(unsafe { fstatat64(fd, name, &mut stat, libc::AT_SYMLINK_NOFOLLOW) })?;
-        Ok(FileAttr::from_stat64(stat))
-    }
+                // Make this FD into a directory handle. We don't actually drop it,
+                // so having an `OwnedFd` is fine.
+                let dir_handle =
+                    mem::ManuallyDrop::new(dir::Dir(unsafe { OwnedFd::from_raw_fd(fd) }));
 
-    #[cfg(any(
-        not(any(
-            all(target_os = "linux", not(target_env = "musl")),
-            target_os = "android",
-            target_os = "fuchsia",
-            target_os = "hurd",
-            target_os = "illumos",
-            target_vendor = "apple",
-        )),
-        miri // no dirfd on Miri
-    ))]
-    pub fn metadata(&self) -> io::Result<FileAttr> {
-        run_path_with_cstr(&self.path(), &lstat)
-    }
+                dir_handle.metadata_c(&self.name, /* symlink_nofollow */ true)
+            }
 
-    #[cfg(any(
-        target_os = "solaris",
-        target_os = "illumos",
-        target_os = "haiku",
-        target_os = "vxworks",
-        target_os = "aix",
-        target_os = "nto",
-        target_os = "qnx",
-        target_os = "vita",
-        target_os = "l4re",
-    ))]
-    pub fn file_type(&self) -> io::Result<FileType> {
-        self.metadata().map(|m| m.file_type())
+            // Fallback based on path
+            _ => run_path_with_cstr(&self.path(), &lstat),
+        }
     }
 
-    #[cfg(not(any(
-        target_os = "solaris",
-        target_os = "illumos",
-        target_os = "haiku",
-        target_os = "vxworks",
-        target_os = "aix",
-        target_os = "nto",
-        target_os = "qnx",
-        target_os = "vita",
-        target_os = "l4re",
-    )))]
     pub fn file_type(&self) -> io::Result<FileType> {
+        // Use `entry.d_type` if available.
+        #[cfg(not(any(
+            target_os = "solaris",
+            target_os = "illumos",
+            target_os = "haiku",
+            target_os = "vxworks",
+            target_os = "aix",
+            target_os = "nto",
+            target_os = "qnx",
+            target_os = "vita",
+            target_os = "l4re",
+        )))]
         match self.entry.d_type {
-            libc::DT_CHR => Ok(FileType { mode: libc::S_IFCHR }),
-            libc::DT_FIFO => Ok(FileType { mode: libc::S_IFIFO }),
-            libc::DT_LNK => Ok(FileType { mode: libc::S_IFLNK }),
-            libc::DT_REG => Ok(FileType { mode: libc::S_IFREG }),
-            libc::DT_SOCK => Ok(FileType { mode: libc::S_IFSOCK }),
-            libc::DT_DIR => Ok(FileType { mode: libc::S_IFDIR }),
-            libc::DT_BLK => Ok(FileType { mode: libc::S_IFBLK }),
-            _ => self.metadata().map(|m| m.file_type()),
+            libc::DT_CHR => return Ok(FileType { mode: libc::S_IFCHR }),
+            libc::DT_FIFO => return Ok(FileType { mode: libc::S_IFIFO }),
+            libc::DT_LNK => return Ok(FileType { mode: libc::S_IFLNK }),
+            libc::DT_REG => return Ok(FileType { mode: libc::S_IFREG }),
+            libc::DT_SOCK => return Ok(FileType { mode: libc::S_IFSOCK }),
+            libc::DT_DIR => return Ok(FileType { mode: libc::S_IFDIR }),
+            libc::DT_BLK => return Ok(FileType { mode: libc::S_IFBLK }),
+            _ => {}
         }
+
+        // Fall back to loading the metadata.
+        self.metadata().map(|m| m.file_type())
     }
 
     pub fn ino(&self) -> u64 {
diff --git a/library/std/src/sys/fs/unix/dir.rs b/library/std/src/sys/fs/unix/dir.rs
index cf0dece265054..dd01db58c600d 100644
--- a/library/std/src/sys/fs/unix/dir.rs
+++ b/library/std/src/sys/fs/unix/dir.rs
@@ -4,16 +4,16 @@ cfg_select! {
     not(any(
         all(target_os = "linux", not(target_env = "musl")),
         target_os = "l4re",
-        target_os = "android",
         target_os = "hurd",
     )) => {
-        use libc::{open as open64, openat as openat64};
+        use libc::{fstatat as fstatat64, openat as openat64};
     }
     _ => {
-        use libc::{open64, openat64};
+        use libc::{fstatat64, openat64};
     }
 }
 
+use super::{open64, stat64};
 use crate::ffi::CStr;
 use crate::os::fd::{AsFd, BorrowedFd, IntoRawFd, OwnedFd, RawFd};
 #[cfg(target_family = "unix")]
@@ -26,7 +26,7 @@ use crate::sys::fs::OpenOptions;
 use crate::sys::fs::unix::{File, FileAttr, debug_path_fd};
 use crate::sys::helpers::run_path_with_cstr;
 use crate::sys::{AsInner, FromInner, IntoInner, cvt, cvt_r};
-use crate::{fmt, fs, io};
+use crate::{fmt, fs, io, mem};
 
 const TRAVERSE_DIRECTORY: i32 =
     cfg_select! {
@@ -36,7 +36,7 @@ const TRAVERSE_DIRECTORY: i32 =
         _ => libc::O_RDONLY,
     };
 
-pub struct Dir(OwnedFd);
+pub struct Dir(pub(super) OwnedFd);
 
 impl Dir {
     pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<Self> {
@@ -57,7 +57,7 @@ impl Dir {
             .map(File)
     }
 
-    pub fn metadata(&self) -> io::Result<FileAttr> {
+    pub fn self_metadata(&self) -> io::Result<FileAttr> {
         // Reuse the implementation for files, which should work for all FDs.
         let fd = self.0.as_raw_fd();
         let f = core::mem::ManuallyDrop::new(File(
@@ -68,7 +68,7 @@ impl Dir {
     }
 
     pub fn remove_file(&self, path: &Path) -> io::Result<()> {
-        run_path_with_cstr(path, &|path| self.remove_c(path, false))
+        run_path_with_cstr(path, &|path| self.remove_c(path, /* remove_dir */ false))
     }
 
     pub fn rename(&self, from: &Path, to_dir: &Self, to: &Path) -> io::Result<()> {
@@ -86,7 +86,17 @@ impl Dir {
     }
 
     pub fn remove_dir(&self, path: &Path) -> io::Result<()> {
-        run_path_with_cstr(path, &|path| self.remove_c(path, true))
+        run_path_with_cstr(path, &|path| self.remove_c(path, /* remove_dir */ true))
+    }
+
+    pub fn metadata(&self, path: &Path) -> io::Result<FileAttr> {
+        run_path_with_cstr(path, &|path| {
+            self.metadata_c(path, /* symlink_nofollow */ false)
+        })
+    }
+
+    pub fn symlink_metadata(&self, path: &Path) -> io::Result<FileAttr> {
+        run_path_with_cstr(path, &|path| self.metadata_c(path, /* symlink_nofollow */ true))
     }
 
     fn open_with_c(path: &CStr, opts: &OpenOptions) -> io::Result<Self> {
@@ -143,6 +153,26 @@ impl Dir {
     fn create_dir_c(&self, path: &CStr) -> io::Result<()> {
         cvt(unsafe { mkdirat(self.0.as_raw_fd(), path.as_ptr(), 0o777) }).map(|_| ())
     }
+
+    pub(super) fn metadata_c(&self, path: &CStr, symlink_nofollow: bool) -> io::Result<FileAttr> {
+        let fd = self.0.as_raw_fd();
+        let flag = if symlink_nofollow { libc::AT_SYMLINK_NOFOLLOW } else { 0 };
+
+        cfg_has_statx! {
+            if let Some(ret) = unsafe { super::try_statx(
+                fd,
+                path.as_ptr(),
+                flag | libc::AT_STATX_SYNC_AS_STAT,
+                libc::STATX_BASIC_STATS | libc::STATX_BTIME,
+            ) } {
+                return ret;
+            }
+        }
+
+        let mut stat: stat64 = unsafe { mem::zeroed() };
+        cvt(unsafe { fstatat64(fd, path.as_ptr(), &mut stat, flag) })?;
+        Ok(FileAttr::from_stat64(stat))
+    }
 }
 
 impl fmt::Debug for Dir {
diff --git a/library/std/src/sys/fs/windows.rs b/library/std/src/sys/fs/windows.rs
index 399c0749bc21e..473d92aface26 100644
--- a/library/std/src/sys/fs/windows.rs
+++ b/library/std/src/sys/fs/windows.rs
@@ -1454,7 +1454,9 @@ pub fn link(_original: &WCStr, _link: &WCStr) -> io::Result<()> {
 pub fn stat(path: &WCStr) -> io::Result<FileAttr> {
     match metadata(path, ReparsePoint::Follow) {
         Err(err) if err.raw_os_error() == Some(c::ERROR_CANT_ACCESS_FILE as i32) => {
-            if let Ok(attrs) = lstat(path) {
+            // Fallback to opening reparse points when following fails. Needed for UNIX domain
+            // sockets. See <https://github.com/rust-lang/rust/issues/109106>.
+            if let Ok(attrs) = metadata(path, ReparsePoint::Open) {
                 if !attrs.file_type().is_symlink() {
                     return Ok(attrs);
                 }
diff --git a/library/std/src/sys/fs/windows/dir.rs b/library/std/src/sys/fs/windows/dir.rs
index 6f6d59af31628..60f8c2522de26 100644
--- a/library/std/src/sys/fs/windows/dir.rs
+++ b/library/std/src/sys/fs/windows/dir.rs
@@ -7,7 +7,7 @@ use crate::os::windows::io::{
 };
 use crate::path::Path;
 use crate::sys::api::{UnicodeStrRef, WinError};
-use crate::sys::fs::windows::debug_path_handle;
+use crate::sys::fs::windows::{ReparsePoint, debug_path_handle};
 use crate::sys::fs::{File, FileAttr, OpenOptions};
 use crate::sys::handle::Handle;
 use crate::sys::path::{WCStr, with_native_path};
@@ -165,6 +165,7 @@ impl Dir {
     fn rename_native(&self, from: &[u16], to_dir: &Self, to: &[u16]) -> io::Result<()> {
         let mut opts = OpenOptions::new();
         opts.access_mode(c::DELETE);
+        // FIXME: custom_flags is ignored by `open_file_native`!
         opts.custom_flags(c::FILE_FLAG_OPEN_REPARSE_POINT | c::FILE_FLAG_BACKUP_SEMANTICS);
         let handle = self.open_file_native(from, &opts, /* create_opt */ 0)?;
         // Calculate the layout of the `FILE_RENAME_INFORMATION` we pass to `NtSetInformationFile`
@@ -222,7 +223,7 @@ impl Dir {
         .io_result()
     }
 
-    pub fn metadata(&self) -> io::Result<FileAttr> {
+    pub fn self_metadata(&self) -> io::Result<FileAttr> {
         // Reuse the implementation for files, which should work for all handles.
         let handle = self.handle.as_raw_handle();
         let f = core::mem::ManuallyDrop::new(File {
@@ -231,6 +232,45 @@ impl Dir {
         });
         f.file_attr()
     }
+
+    pub fn metadata(&self, path: &Path) -> io::Result<FileAttr> {
+        let path = to_u16s_without_nul(path)?;
+        // Same as the `stat` logic used for `fs::metadata`
+        match self.metadata_native(&path, ReparsePoint::Follow) {
+            Err(err) if err.raw_os_error() == Some(c::ERROR_CANT_ACCESS_FILE as i32) => {
+                // Fallback to opening reparse points when following fails. Needed for UNIX domain
+                // sockets. See <https://github.com/rust-lang/rust/issues/109106>.
+                if let Ok(attrs) = self.metadata_native(&path, ReparsePoint::Open) {
+                    if !attrs.file_type().is_symlink() {
+                        return Ok(attrs);
+                    }
+                }
+                Err(err)
+            }
+            result => result,
+        }
+    }
+
+    pub fn symlink_metadata(&self, path: &Path) -> io::Result<FileAttr> {
+        let path = to_u16s_without_nul(path)?;
+        self.metadata_native(&path, ReparsePoint::Open)
+    }
+
+    fn metadata_native(&self, path: &[u16], reparse: ReparsePoint) -> io::Result<FileAttr> {
+        let mut opts = OpenOptions::new();
+        // the NT functions need at least c::FILE_READ_ATTRIBUTES
+        opts.access_mode(c::FILE_READ_ATTRIBUTES);
+        let create_opt = if reparse == ReparsePoint::Open { c::FILE_OPEN_REPARSE_POINT } else { 0 };
+
+        let name = UnicodeStrRef::from_slice(path);
+        let object_attributes = c::OBJECT_ATTRIBUTES {
+            RootDirectory: self.handle.as_raw_handle(),
+            ObjectName: name.as_ptr().cast_mut(),
+            ..c::OBJECT_ATTRIBUTES::with_length()
+        };
+        let handle = unsafe { nt_create_file(&opts, &object_attributes, create_opt)? };
+        File { handle }.file_attr()
+    }
 }
 
 impl fmt::Debug for Dir {
diff --git a/src/tools/miri/src/shims/files.rs b/src/tools/miri/src/shims/files.rs
index d73ce57f64f19..cd7a7f4f0250b 100644
--- a/src/tools/miri/src/shims/files.rs
+++ b/src/tools/miri/src/shims/files.rs
@@ -524,7 +524,10 @@ impl FileDescription for DirHandle {
     fn metadata<'tcx>(
         &self,
     ) -> InterpResult<'tcx, Either<io::Result<std::fs::Metadata>, &'static str>> {
-        interp_ok(Either::Left(self.dir.metadata()))
+        #[cfg(bootstrap)]
+        return interp_ok(Either::Left(self.dir.metadata()));
+        #[cfg(not(bootstrap))]
+        return interp_ok(Either::Left(self.dir.self_metadata()));
     }
 }
 
diff --git a/src/tools/miri/src/shims/windows/fs.rs b/src/tools/miri/src/shims/windows/fs.rs
index 9aae6677faeb2..bab26d80dee70 100644
--- a/src/tools/miri/src/shims/windows/fs.rs
+++ b/src/tools/miri/src/shims/windows/fs.rs
@@ -225,7 +225,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                         return interp_ok(Handle::Invalid);
                     }
                 };
-                if !dir.metadata().unwrap().is_dir() {
+                #[cfg(bootstrap)]
+                let metadata = dir.metadata();
+                #[cfg(not(bootstrap))]
+                let metadata = dir.self_metadata();
+                if !metadata.unwrap().is_dir() {
                     // This changed from a directory to a file. Retry.
                     continue;
                 }