html-to-markdown 2.23.4 → 2.24.1

data/rust-vendor/zerocopy/src/util/macro_util.rs

@@ -29,10 +29,11 @@ use core::{
 
 use crate::{
     pointer::{
-        invariant::{self, BecauseExclusive, BecauseImmutable, Invariants},
-        BecauseInvariantsEq, InvariantsEq, SizeEq, TryTransmuteFromPtr,
+        cast::CastSized,
+        invariant::{Aligned, Initialized, Valid},
+        BecauseInvariantsEq,
     },
-    FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout, Ptr, TryFromBytes, ValidityError,
+    FromBytes, Immutable, IntoBytes, KnownLayout, Ptr, ReadOnly, TryFromBytes, ValidityError,
 };
 
 /// Projects the type of the field at `Index` in `Self` without regard for field
@@ -530,6 +531,18 @@ macro_rules! assert_size_eq {
     }};
 }
 
+/// Unwraps an infallible `Result`.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! into_inner {
+    ($e:expr) => {
+        match $e {
+            $crate::util::macro_util::core_reexport::result::Result::Ok(e) => e,
+            $crate::util::macro_util::core_reexport::result::Result::Err(i) => match i {},
+        }
+    };
+}
+
 /// Translates an identifier or tuple index into a numeric identifier.
 #[doc(hidden)] // `#[macro_export]` bypasses this module's `#[doc(hidden)]`.
 #[macro_export]
@@ -587,65 +600,6 @@ pub const fn hash_name(name: &str) -> i128 {
     i128::from_ne_bytes(hash.to_ne_bytes())
 }
 
-/// Is a given source a valid instance of `Dst`?
-///
-/// If so, returns `src` casted to a `Ptr<Dst, _>`. Otherwise returns `None`.
-///
-/// # Safety
-///
-/// Unsafe code may assume that, if `try_cast_or_pme(src)` returns `Ok`,
-/// `*src` is a bit-valid instance of `Dst`, and that the size of `Src` is
-/// greater than or equal to the size of `Dst`.
-///
-/// Unsafe code may assume that, if `try_cast_or_pme(src)` returns `Err`, the
-/// encapsulated `Ptr` value is the original `src`. `try_cast_or_pme` cannot
-/// guarantee that the referent has not been modified, as it calls user-defined
-/// code (`TryFromBytes::is_bit_valid`).
-///
-/// # Panics
-///
-/// `try_cast_or_pme` may either produce a post-monomorphization error or a
-/// panic if `Dst` not the same size as `Src`. Otherwise, `try_cast_or_pme`
-/// panics under the same circumstances as [`is_bit_valid`].
-///
-/// [`is_bit_valid`]: TryFromBytes::is_bit_valid
-#[doc(hidden)]
-#[inline]
-fn try_cast_or_pme<Src, Dst, I, R, S>(
-    src: Ptr<'_, Src, I>,
-) -> Result<
-    Ptr<'_, Dst, (I::Aliasing, invariant::Unaligned, invariant::Valid)>,
-    ValidityError<Ptr<'_, Src, I>, Dst>,
->
-where
-    // FIXME(#2226): There should be a `Src: FromBytes` bound here, but doing so
-    // requires deeper surgery.
-    Src: invariant::Read<I::Aliasing, R>,
-    Dst: TryFromBytes
-        + invariant::Read<I::Aliasing, R>
-        + TryTransmuteFromPtr<Dst, I::Aliasing, invariant::Initialized, invariant::Valid, S>,
-    I: Invariants<Validity = invariant::Initialized>,
-    I::Aliasing: invariant::Reference,
-{
-    static_assert!(Src, Dst => mem::size_of::<Dst>() == mem::size_of::<Src>());
-
-    let c_ptr = src.cast::<_, crate::pointer::cast::CastSized, _>();
-
-    match c_ptr.try_into_valid() {
-        Ok(ptr) => Ok(ptr),
-        Err(err) => {
-            // Re-cast `Ptr<Dst>` to `Ptr<Src>`.
-            let ptr = err.into_src();
-            let ptr = ptr.cast::<_, crate::pointer::cast::CastSized, _>();
-            // SAFETY: `ptr` is `src`, and has the same alignment invariant.
-            let ptr = unsafe { ptr.assume_alignment::<I::Alignment>() };
-            // SAFETY: `ptr` is `src` and has the same validity invariant.
-            let ptr = unsafe { ptr.assume_validity::<I::Validity>() };
-            Err(ValidityError::new(ptr.unify_invariants()))
-        }
-    }
-}
-
 /// Attempts to transmute `Src` into `Dst`.
 ///
 /// A helper for `try_transmute!`.
@@ -666,32 +620,28 @@ where
     static_assert!(Src, Dst => mem::size_of::<Dst>() == mem::size_of::<Src>());
 
     let mu_src = mem::MaybeUninit::new(src);
-    // SAFETY: By invariant on `&`, the following are satisfied:
-    // - `&mu_src` is valid for reads
-    // - `&mu_src` is properly aligned
-    // - `&mu_src`'s referent is bit-valid
-    let mu_src_copy = unsafe { core::ptr::read(&mu_src) };
-    // SAFETY: `MaybeUninit` has no validity constraints.
-    let mut mu_dst: mem::MaybeUninit<Dst> =
-        unsafe { crate::util::transmute_unchecked(mu_src_copy) };
+    // SAFETY: `MaybeUninit` has no validity requirements.
+    let mu_dst: mem::MaybeUninit<ReadOnly<Dst>> =
+        unsafe { crate::util::transmute_unchecked(mu_src) };
 
-    let ptr = Ptr::from_mut(&mut mu_dst);
+    let ptr = Ptr::from_ref(&mu_dst);
 
     // SAFETY: Since `Src: IntoBytes`, and since `size_of::<Src>() ==
     // size_of::<Dst>()` by the preceding assertion, all of `mu_dst`'s bytes are
-    // initialized.
-    let ptr = unsafe { ptr.assume_validity::<invariant::Initialized>() };
-
-    let ptr: Ptr<'_, Dst, _> = ptr.cast::<_, crate::pointer::cast::CastSized, _>();
-
-    if Dst::is_bit_valid(ptr.forget_aligned()) {
+    // initialized. `MaybeUninit` has no validity requirements, so even if
+    // `ptr` is used to mutate its referent (which it actually can't be - it's
+    // a shared `ReadOnly` pointer), that won't violate its referent's validity.
+    let ptr = unsafe { ptr.assume_validity::<Initialized>() };
+    if Dst::is_bit_valid(ptr.cast::<_, CastSized, _>()) {
         // SAFETY: Since `Dst::is_bit_valid`, we know that `ptr`'s referent is
         // bit-valid for `Dst`. `ptr` points to `mu_dst`, and no intervening
         // operations have mutated it, so it is a bit-valid `Dst`.
-        Ok(unsafe { mu_dst.assume_init() })
+        Ok(ReadOnly::into_inner(unsafe { mu_dst.assume_init() }))
     } else {
-        // SAFETY: `mu_src` was constructed from `src` and never modified, so it
-        // is still bit-valid.
+        // SAFETY: `MaybeUninit` has no validity requirements.
+        let mu_src: mem::MaybeUninit<Src> = unsafe { crate::util::transmute_unchecked(mu_dst) };
+        // SAFETY: `mu_dst`/`mu_src` was constructed from `src` and never
+        // modified, so it is still bit-valid.
         Err(ValidityError::new(unsafe { mu_src.assume_init() }))
     }
 }
@@ -715,23 +665,28 @@ where
     Dst: TryFromBytes + Immutable,
 {
     let ptr = Ptr::from_ref(src);
-    let ptr = ptr.bikeshed_recall_initialized_immutable();
-    match try_cast_or_pme::<Src, Dst, _, BecauseImmutable, _>(ptr) {
+    let ptr = ptr.recall_validity::<Initialized, _>();
+    let ptr = ptr.cast::<_, CastSized, _>();
+    match ptr.try_into_valid() {
         Ok(ptr) => {
             static_assert!(Src, Dst => mem::align_of::<Dst>() <= mem::align_of::<Src>());
             // SAFETY: We have checked that `Dst` does not have a stricter
             // alignment requirement than `Src`.
-            let ptr = unsafe { ptr.assume_alignment::<invariant::Aligned>() };
+            let ptr = unsafe { ptr.assume_alignment::<Aligned>() };
             Ok(ptr.as_ref())
         }
         Err(err) => Err(err.map_src(|ptr| {
+            let ptr = ptr.cast::<_, CastSized, _>();
+            // SAFETY: `ptr` has the same address as `src: &Src`, which is
+            // aligned by invariant on `&Src`.
+            let ptr = unsafe { ptr.assume_alignment::<Aligned>() };
             // SAFETY: Because `Src: Immutable` and we create a `Ptr` via
             // `Ptr::from_ref`, the resulting `Ptr` is a shared-and-`Immutable`
             // `Ptr`, which does not permit mutation of its referent. Therefore,
             // no mutation could have happened during the call to
-            // `try_cast_or_pme` (any such mutation would be unsound).
+            // `try_into_valid` (any such mutation would be unsound).
             //
-            // `try_cast_or_pme` promises to return its original argument, and
+            // `try_into_valid` promises to return its original argument, and
             // so we know that we are getting back the same `ptr` that we
             // originally passed, and that `ptr` was a bit-valid `Src`.
             let ptr = unsafe { ptr.assume_valid() };
@@ -759,17 +714,24 @@ where
     Dst: TryFromBytes + IntoBytes,
 {
     let ptr = Ptr::from_mut(src);
-    let ptr = ptr.bikeshed_recall_initialized_from_bytes();
-    match try_cast_or_pme::<Src, Dst, _, BecauseExclusive, _>(ptr) {
+    let ptr = ptr.recall_validity::<Initialized, (_, (_, _))>();
+    let ptr = ptr.cast::<_, CastSized, _>();
+    match ptr.try_into_valid() {
         Ok(ptr) => {
             static_assert!(Src, Dst => mem::align_of::<Dst>() <= mem::align_of::<Src>());
             // SAFETY: We have checked that `Dst` does not have a stricter
             // alignment requirement than `Src`.
-            let ptr = unsafe { ptr.assume_alignment::<invariant::Aligned>() };
+            let ptr = unsafe { ptr.assume_alignment::<Aligned>() };
             Ok(ptr.as_mut())
         }
         Err(err) => {
-            Err(err.map_src(|ptr| ptr.recall_validity::<_, (_, BecauseInvariantsEq)>().as_mut()))
+            Err(err.map_src(|ptr| {
+                let ptr = ptr.cast::<_, CastSized, _>();
+                // SAFETY: `ptr` has the same address as `src: &mut Src`, which
+                // is aligned by invariant on `&mut Src`.
+                let ptr = unsafe { ptr.assume_alignment::<Aligned>() };
+                ptr.recall_validity::<_, (_, BecauseInvariantsEq)>().as_mut()
+            }))
         }
     }
 }
@@ -884,29 +846,21 @@ where
 
     #[inline(always)]
     fn transmute_ref(self) -> &'a Dst {
+        let ptr = Ptr::from_ref(self.0)
+            .recall_validity::<Initialized, _>()
+            .transmute_with::<Dst, Initialized, crate::layout::CastFrom<Dst>, (crate::pointer::BecauseMutationCompatible, _)>()
+            .recall_validity::<Valid, _>();
+
         static_assert!(Src: ?Sized + KnownLayout, Dst: ?Sized + KnownLayout => {
             Src::LAYOUT.align.get() >= Dst::LAYOUT.align.get()
         }, "cannot transmute reference when destination type has higher alignment than source type");
 
-        // SAFETY: We only use `S` as `S<Src>` and `D` as `D<Dst>`.
-        #[allow(clippy::multiple_unsafe_ops_per_block)]
-        unsafe {
-            unsafe_with_size_eq!(<S<Src>, D<Dst>> {
-                let ptr = Ptr::from_ref(self.0)
-                    .transmute::<S<Src>, invariant::Valid, BecauseImmutable>()
-                    .recall_validity::<invariant::Initialized, _>()
-                    .transmute::<D<Dst>, invariant::Initialized, (crate::pointer::BecauseMutationCompatible, _)>()
-                    .recall_validity::<invariant::Valid, _>();
-
-                #[allow(unused_unsafe)]
-                // SAFETY: The preceding `static_assert!` ensures that
-                // `T::LAYOUT.align >= U::LAYOUT.align`. Since `self.0` is
-                // validly-aligned for `T`, it is also validly-aligned for `U`.
-                let ptr = unsafe { ptr.assume_alignment() };
-
-                &ptr.as_ref().0
-            })
-        }
+        // SAFETY: The preceding `static_assert!` ensures that
+        // `Src::LAYOUT.align >= Dst::LAYOUT.align`. Since `self` is
+        // validly-aligned for `Src`, it is also validly-aligned for `Dst`.
+        let ptr = unsafe { ptr.assume_alignment() };
+
+        ptr.as_ref()
     }
 }
 
@@ -925,29 +879,21 @@ where
 
     #[inline(always)]
     fn transmute_mut(self) -> &'a mut Dst {
+        let ptr = Ptr::from_mut(self.0)
+            .recall_validity::<Initialized, (_, (_, _))>()
+            .transmute_with::<Dst, Initialized, crate::layout::CastFrom<Dst>, _>()
+            .recall_validity::<Valid, (_, (_, _))>();
+
         static_assert!(Src: ?Sized + KnownLayout, Dst: ?Sized + KnownLayout => {
             Src::LAYOUT.align.get() >= Dst::LAYOUT.align.get()
         }, "cannot transmute reference when destination type has higher alignment than source type");
 
-        // SAFETY: We only use `S` as `S<Src>` and `D` as `D<Dst>`.
-        #[allow(clippy::multiple_unsafe_ops_per_block)]
-        unsafe {
-            unsafe_with_size_eq!(<S<Src>, D<Dst>> {
-                let ptr = Ptr::from_mut(self.0)
-                    .transmute::<S<Src>, invariant::Valid, _>()
-                    .recall_validity::<invariant::Initialized, (_, (_, _))>()
-                    .transmute::<D<Dst>, invariant::Initialized, _>()
-                    .recall_validity::<invariant::Valid, (_, (_, _))>();
-
-                #[allow(unused_unsafe)]
-                // SAFETY: The preceding `static_assert!` ensures that
-                // `T::LAYOUT.align >= U::LAYOUT.align`. Since `self.0` is
-                // validly-aligned for `T`, it is also validly-aligned for `U`.
-                let ptr = unsafe { ptr.assume_alignment() };
-
-                &mut ptr.as_mut().0
-            })
-        }
+        // SAFETY: The preceding `static_assert!` ensures that
+        // `Src::LAYOUT.align >= Dst::LAYOUT.align`. Since `self` is
+        // validly-aligned for `Src`, it is also validly-aligned for `Dst`.
+        let ptr = unsafe { ptr.assume_alignment() };
+
+        ptr.as_mut()
     }
 }
 

data/rust-vendor/zerocopy/src/util/macros.rs

@@ -135,7 +135,7 @@ macro_rules! unsafe_impl {
         fn only_derive_is_allowed_to_implement_this_trait() {}
 
         #[inline]
-        fn is_bit_valid<AA: crate::pointer::invariant::Reference>($candidate: Maybe<'_, Self, AA>) -> bool {
+        fn is_bit_valid($candidate: Maybe<'_, Self>) -> bool {
             $is_bit_valid
         }
     };
@@ -143,7 +143,7 @@ macro_rules! unsafe_impl {
         #[allow(clippy::missing_inline_in_public_items)]
         #[cfg_attr(all(coverage_nightly, __ZEROCOPY_INTERNAL_USE_ONLY_NIGHTLY_FEATURES_IN_TESTS), coverage(off))]
         fn only_derive_is_allowed_to_implement_this_trait() {}
-        #[inline(always)] fn is_bit_valid<AA: crate::pointer::invariant::Reference>(_: Maybe<'_, Self, AA>) -> bool { true }
+        #[inline(always)] fn is_bit_valid(_candidate: Maybe<'_, Self>) -> bool { true }
     };
     (@method $trait:ident) => {
         #[allow(clippy::missing_inline_in_public_items, dead_code)]
@@ -164,7 +164,7 @@ macro_rules! impl_for_transmute_from {
     (
         $(#[$attr:meta])*
         $($tyvar:ident $(: $(? $optbound:ident $(+)?)* $($bound:ident $(+)?)* )?)?
-        => $trait:ident for $ty:ty [$($unsafe_cell:ident)? <$repr:ty>]
+        => $trait:ident for $ty:ty [$repr:ty]
     ) => {
         const _: () = {
             $(#[$attr])*
@@ -203,7 +203,7 @@ macro_rules! impl_for_transmute_from {
                 impl_for_transmute_from!(
                     @is_bit_valid
                     $(<$tyvar $(: $(? $optbound +)* $($bound +)*)?>)?
-                    $trait for $ty [$($unsafe_cell)? <$repr>]
+                    $trait for $ty [$repr]
                 );
             }
         };
@@ -215,35 +215,20 @@ macro_rules! impl_for_transmute_from {
     (
         @is_bit_valid
         $(<$tyvar:ident $(: $(? $optbound:ident $(+)?)* $($bound:ident $(+)?)* )?>)?
-        TryFromBytes for $ty:ty [UnsafeCell<$repr:ty>]
+        TryFromBytes for $ty:ty [$repr:ty]
     ) => {
         #[inline]
-        fn is_bit_valid<A: crate::pointer::invariant::Reference>(candidate: Maybe<'_, Self, A>) -> bool {
-            let c: Maybe<'_, Self, crate::pointer::invariant::Exclusive> = candidate.into_exclusive_or_pme();
-            let c: Maybe<'_, $repr, _> = c.transmute::<_, _, (_, (_, (BecauseExclusive, BecauseExclusive)))>();
+        fn is_bit_valid(candidate: $crate::Maybe<'_, Self>) -> bool {
             // SAFETY: This macro ensures that `$repr` and `Self` have the same
             // size and bit validity. Thus, a bit-valid instance of `$repr` is
             // also a bit-valid instance of `Self`.
-            <$repr as TryFromBytes>::is_bit_valid(c)
+            <$repr as TryFromBytes>::is_bit_valid(candidate.transmute::<_, _, BecauseImmutable>())
         }
     };
     (
         @is_bit_valid
         $(<$tyvar:ident $(: $(? $optbound:ident $(+)?)* $($bound:ident $(+)?)* )?>)?
-        TryFromBytes for $ty:ty [<$repr:ty>]
-    ) => {
-        #[inline]
-        fn is_bit_valid<A: crate::pointer::invariant::Reference>(candidate: $crate::Maybe<'_, Self, A>) -> bool {
-            // SAFETY: This macro ensures that `$repr` and `Self` have the same
-            // size and bit validity. Thus, a bit-valid instance of `$repr` is
-            // also a bit-valid instance of `Self`.
-            <$repr as TryFromBytes>::is_bit_valid(candidate.transmute())
-        }
-    };
-    (
-        @is_bit_valid
-        $(<$tyvar:ident $(: $(? $optbound:ident $(+)?)* $($bound:ident $(+)?)* )?>)?
-        $trait:ident for $ty:ty [$($unsafe_cell:ident)? <$repr:ty>]
+        $trait:ident for $ty:ty [$repr:ty]
     ) => {
         // Trait other than `TryFromBytes`; no `is_bit_valid` impl.
     };
@@ -732,28 +717,69 @@ macro_rules! define_cast {
 /// # Safety
 ///
 /// `T` and `$wrapper<T>` must have the same bit validity, and must have the
-/// same size in the sense of `SizeEq`.
+/// same size in the sense of `CastExact` (specifically, both a
+/// `T`-to-`$wrapper<T>` cast and a `$wrapper<T>`-to-`T` cast must be
+/// size-preserving).
 macro_rules! unsafe_impl_for_transparent_wrapper {
     ($vis:vis T $(: ?$optbound:ident)? => $wrapper:ident<T>) => {{
         crate::util::macros::__unsafe();
 
-        use crate::pointer::{TransmuteFrom, SizeEq, invariant::Valid};
+        use crate::pointer::{TransmuteFrom, cast::{CastExact, TransitiveProject}, SizeEq, invariant::Valid};
+        use crate::wrappers::ReadOnly;
 
         // SAFETY: The caller promises that `T` and `$wrapper<T>` have the same
         // bit validity.
         unsafe impl<T $(: ?$optbound)?> TransmuteFrom<T, Valid, Valid> for $wrapper<T> {}
         // SAFETY: See previous safety comment.
         unsafe impl<T $(: ?$optbound)?> TransmuteFrom<$wrapper<T>, Valid, Valid> for T {}
-        define_cast!(unsafe { $vis CastA<T $(: ?$optbound)? > = T => $wrapper<T> });
-        // SAFETY: The caller promises that `T` and `$wrapper<T>` satisfy
-        // `SizeEq`.
-        unsafe impl<T $(: ?$optbound)?> SizeEq<T> for $wrapper<T> {
-            type CastFrom = CastA;
+        // SAFETY: The caller promises that a `T` to `$wrapper<T>` cast is
+        // size-preserving.
+        define_cast!(unsafe { $vis CastToWrapper<T $(: ?$optbound)? > = T => $wrapper<T> });
+        // SAFETY: The caller promises that a `T` to `$wrapper<T>` cast is
+        // size-preserving.
+        unsafe impl<T $(: ?$optbound)?> CastExact<T, $wrapper<T>> for CastToWrapper {}
+        // SAFETY: The caller promises that a `$wrapper<T>` to `T` cast is
+        // size-preserving.
+        define_cast!(unsafe { $vis CastFromWrapper<T $(: ?$optbound)? > = $wrapper<T> => T });
+        // SAFETY: The caller promises that a `$wrapper<T>` to `T` cast is
+        // size-preserving.
+        unsafe impl<T $(: ?$optbound)?> CastExact<$wrapper<T>, T> for CastFromWrapper {}
+
+        impl<T $(: ?$optbound)?> SizeEq<T> for $wrapper<T> {
+            type CastFrom = CastToWrapper;
         }
-        define_cast!(unsafe { $vis CastB<T $(: ?$optbound)? > = $wrapper<T> => T });
-        // SAFETY: See previous safety comment.
-        unsafe impl<T $(: ?$optbound)?> SizeEq<$wrapper<T>> for T {
-            type CastFrom = CastB;
+        impl<T $(: ?$optbound)?> SizeEq<$wrapper<T>> for T {
+            type CastFrom = CastFromWrapper;
+        }
+
+        impl<T $(: ?$optbound)?> SizeEq<ReadOnly<T>> for $wrapper<T> {
+            type CastFrom = TransitiveProject<
+                T,
+                <T as SizeEq<ReadOnly<T>>>::CastFrom,
+                CastToWrapper,
+            >;
+        }
+        impl<T $(: ?$optbound)?> SizeEq<$wrapper<T>> for ReadOnly<T> {
+            type CastFrom = TransitiveProject<
+                T,
+                CastFromWrapper,
+                <ReadOnly<T> as SizeEq<T>>::CastFrom,
+            >;
+        }
+
+        impl<T $(: ?$optbound)?> SizeEq<ReadOnly<T>> for ReadOnly<$wrapper<T>> {
+            type CastFrom = TransitiveProject<
+                $wrapper<T>,
+                <$wrapper<T> as SizeEq<ReadOnly<T>>>::CastFrom,
+                <ReadOnly<$wrapper<T>> as SizeEq<$wrapper<T>>>::CastFrom,
+            >;
+        }
+        impl<T $(: ?$optbound)?> SizeEq<ReadOnly<$wrapper<T>>> for ReadOnly<T> {
+            type CastFrom = TransitiveProject<
+                $wrapper<T>,
+                <$wrapper<T> as SizeEq<ReadOnly<$wrapper<T>>>>::CastFrom,
+                <ReadOnly<T> as SizeEq<$wrapper<T>>>::CastFrom,
+            >;
         }
     }};
 }
@@ -763,9 +789,7 @@ macro_rules! impl_transitive_transmute_from {
         const _: () = {
             use crate::pointer::{TransmuteFrom, SizeEq, invariant::Valid};
 
-            // SAFETY: Since `$u: SizeEq<$t>` and `$v: SizeEq<U>`, this impl is
-            // transitively sound.
-            unsafe impl<$($tyvar $(: ?$optbound)?)?> SizeEq<$t> for $v
+            impl<$($tyvar $(: ?$optbound)?)?> SizeEq<$t> for $v
             where
                 $u: SizeEq<$t>,
                 $v: SizeEq<$u>,
@@ -790,119 +814,6 @@ macro_rules! impl_transitive_transmute_from {
     };
 }
 
-#[rustfmt::skip]
-macro_rules! impl_size_eq {
-    ($t:ty, $u:ty) => {
-        const _: () = {
-            use $crate::{pointer::{cast::CastUnsized, SizeEq}};
-
-            // SAFETY: See inline.
-            unsafe impl SizeEq<$t> for $u {
-                type CastFrom = CastUnsized;
-            }
-            // SAFETY: See previous safety comment.
-            unsafe impl SizeEq<$u> for $t {
-                type CastFrom = CastUnsized;
-            }
-        };
-    };
-}
-
-/// Invokes `$blk` in a context in which `$src<$t>` and `$dst<$u>` implement
-/// `SizeEq`.
-///
-/// This macro emits code which implements `SizeEq`, and ensures that the impl
-/// is sound via PME.
-///
-/// # Safety
-///
-/// Inside of `$blk`, the caller must only use `$src` and `$dst` as `$src<$t>`
-/// and `$dst<$u>`. The caller must not use `$src` or `$dst` to wrap any other
-/// types.
-macro_rules! unsafe_with_size_eq {
-    (<$src:ident<$t:ident>, $dst:ident<$u:ident>> $blk:expr) => {{
-        crate::util::macros::__unsafe();
-
-        use crate::{KnownLayout, pointer::cast::TransitiveProject};
-
-        #[repr(transparent)]
-        struct $src<T: ?Sized>(T);
-
-        #[repr(transparent)]
-        struct $dst<U: ?Sized>(U);
-
-        // SAFETY: Since `$src<T>` is a `#[repr(transparent)]` wrapper around
-        // `T`, it has the same bit validity and size as `T`.
-        unsafe_impl_for_transparent_wrapper!(T: ?Sized => $src<T>);
-
-        // SAFETY: Since `$dst<T>` is a `#[repr(transparent)]` wrapper around
-        // `T`, it has the same bit validity and size as `T`.
-        unsafe_impl_for_transparent_wrapper!(T: ?Sized => $dst<T>);
-
-        // SAFETY: `$src<T>` is a `#[repr(transparent)]` wrapper around `T` with
-        // no added semantics.
-        unsafe impl<T: ?Sized> InvariantsEq<$src<T>> for T {}
-
-        // SAFETY: `$dst<T>` is a `#[repr(transparent)]` wrapper around `T` with
-        // no added semantics.
-        unsafe impl<T: ?Sized> InvariantsEq<$dst<T>> for T {}
-
-        define_cast!(unsafe { SrcCast<T: ?Sized> = $src<T> => T });
-        define_cast!(unsafe { DstCast<U: ?Sized> = U => $dst<U> });
-
-        // SAFETY: See inline for the soundness of this impl when
-        // `CastFrom::project` is actually instantiated (otherwise, PMEs may not
-        // be triggered).
-        //
-        // We manually instantiate `CastFrom::project` below to ensure that this
-        // PME can be triggered, and the caller promises not to use `$src` and
-        // `$dst` with any wrapped types other than `$t` and `$u` respectively.
-        unsafe impl<T: ?Sized, U: ?Sized> SizeEq<$src<T>> for $dst<U>
-        where
-            T: KnownLayout<PointerMetadata = usize>,
-            U: KnownLayout<PointerMetadata = usize>,
-        {
-            type CastFrom = TransitiveProject<U, TransitiveProject<
-                T,
-                SrcCast,
-                crate::layout::CastFrom<U>,
-            >, DstCast>;
-        }
-
-        // See safety comment on the preceding `unsafe impl` block for an
-        // explanation of why we need this block.
-        if 1 == 0 {
-            use crate::pointer::cast::Project as _;
-
-            let ptr = <$t as KnownLayout>::raw_dangling();
-            // SAFETY: This call is never executed.
-            #[allow(unused_unsafe, clippy::missing_transmute_annotations)]
-            let ptr = unsafe { core::mem::transmute(ptr) };
-            let _ = <$dst<$u> as SizeEq<$src<$t>>>::CastFrom::project(ptr);
-        }
-
-        impl_for_transmute_from!(T: ?Sized + TryFromBytes => TryFromBytes for $src<T>[<T>]);
-        impl_for_transmute_from!(T: ?Sized + FromBytes => FromBytes for $src<T>[<T>]);
-        impl_for_transmute_from!(T: ?Sized + FromZeros => FromZeros for $src<T>[<T>]);
-        impl_for_transmute_from!(T: ?Sized + IntoBytes => IntoBytes for $src<T>[<T>]);
-
-        impl_for_transmute_from!(U: ?Sized + TryFromBytes => TryFromBytes for $dst<U>[<U>]);
-        impl_for_transmute_from!(U: ?Sized + FromBytes => FromBytes for $dst<U>[<U>]);
-        impl_for_transmute_from!(U: ?Sized + FromZeros => FromZeros for $dst<U>[<U>]);
-        impl_for_transmute_from!(U: ?Sized + IntoBytes => IntoBytes for $dst<U>[<U>]);
-
-        // SAFETY: `$src<T>` is a `#[repr(transparent)]` wrapper around `T`, and
-        // so permits interior mutation exactly when `T` does.
-        unsafe_impl!(T: ?Sized + Immutable => Immutable for $src<T>);
-
-        // SAFETY: `$dst<T>` is a `#[repr(transparent)]` wrapper around `T`, and
-        // so permits interior mutation exactly when `T` does.
-        unsafe_impl!(T: ?Sized + Immutable => Immutable for $dst<T>);
-
-        $blk
-    }};
-}
-
 /// A no-op `unsafe fn` for use in macro expansions.
 ///
 /// Calling this function in a macro expansion ensures that the macro's caller