[WIP] Transmute

gherrit-pr-id: I8d5d162c1b6fe43e3dcb90a6dc5bf58a7a203bf8

src/lib.rs

@@ -367,7 +367,10 @@ use core::{
 #[cfg(feature = "std")]
 use std::io;
 
-use crate::pointer::invariant::{self, BecauseExclusive};
+use crate::pointer::{
+    invariant::{self, BecauseExclusive},
+    transmute::BecauseRead,
+};
 
 #[cfg(any(feature = "alloc", test))]
 extern crate alloc;
@@ -1782,7 +1785,7 @@ pub unsafe trait TryFromBytes {
                 // calling `try_into_valid` (and thus `is_bit_valid`) with a shared
                 // pointer when `Self: !Immutable`. Since `Self: Immutable`, this panic
                 // condition will not happen.
-                match source.try_into_valid() {
+                match source.try_into_valid::<(pointer::transmute::BecauseRead, _)>() {
                     Ok(source) => Ok(source.as_mut()),
                     Err(e) => {
                         Err(e.map_src(|src| src.as_bytes::<BecauseExclusive>().as_mut()).into())
@@ -2364,7 +2367,7 @@ pub unsafe trait TryFromBytes {
                 // calling `try_into_valid` (and thus `is_bit_valid`) with a shared
                 // pointer when `Self: !Immutable`. Since `Self: Immutable`, this panic
                 // condition will not happen.
-                match source.try_into_valid() {
+                match source.try_into_valid::<(BecauseRead, _)>() {
                     Ok(source) => Ok(source.as_mut()),
                     Err(e) => {
                         Err(e.map_src(|src| src.as_bytes::<BecauseExclusive>().as_mut()).into())
@@ -2771,7 +2774,7 @@ fn try_ref_from_prefix_suffix<T: TryFromBytes + KnownLayout + Immutable + ?Sized
 }
 
 #[inline(always)]
-fn try_mut_from_prefix_suffix<T: IntoBytes + TryFromBytes + KnownLayout + ?Sized>(
+fn try_mut_from_prefix_suffix<T: TryFromBytes + IntoBytes + KnownLayout + ?Sized>(
     candidate: &mut [u8],
     cast_type: CastType,
     meta: Option<T::PointerMetadata>,
@@ -2786,7 +2789,7 @@ fn try_mut_from_prefix_suffix<T: IntoBytes + TryFromBytes + KnownLayout + ?Sized
             // calling `try_into_valid` (and thus `is_bit_valid`) with a shared
             // pointer when `Self: !Immutable`. Since `Self: Immutable`, this panic
             // condition will not happen.
-            match candidate.try_into_valid() {
+            match candidate.try_into_valid::<(pointer::transmute::BecauseRead, _)>() {
                 Ok(valid) => Ok((valid.as_mut(), prefix_suffix.as_mut())),
                 Err(e) => Err(e.map_src(|src| src.as_bytes::<BecauseExclusive>().as_mut()).into()),
             }
@@ -3500,7 +3503,7 @@ pub unsafe trait FromBytes: FromZeros {
     {
         static_assert_dst_is_not_zst!(Self);
         match Ptr::from_ref(source).try_cast_into_no_leftover::<_, BecauseImmutable>(None) {
-            Ok(ptr) => Ok(ptr.bikeshed_recall_valid().as_ref()),
+            Ok(ptr) => Ok(ptr.transmute().as_ref()),
             Err(err) => Err(err.map_src(|src| src.as_ref())),
         }
     }
@@ -3975,7 +3978,7 @@ pub unsafe trait FromBytes: FromZeros {
         let source = Ptr::from_ref(source);
         let maybe_slf = source.try_cast_into_no_leftover::<_, BecauseImmutable>(Some(count));
         match maybe_slf {
-            Ok(slf) => Ok(slf.bikeshed_recall_valid().as_ref()),
+            Ok(slf) => Ok(slf.transmute().as_ref()),
             Err(err) => Err(err.map_src(|s| s.as_ref())),
         }
     }
@@ -4574,7 +4577,7 @@ fn ref_from_prefix_suffix<T: FromBytes + KnownLayout + Immutable + ?Sized>(
     let (slf, prefix_suffix) = Ptr::from_ref(source)
         .try_cast_into::<_, BecauseImmutable>(cast_type, meta)
         .map_err(|err| err.map_src(|s| s.as_ref()))?;
-    Ok((slf.bikeshed_recall_valid().as_ref(), prefix_suffix.as_ref()))
+    Ok((slf.transmute().as_ref(), prefix_suffix.as_ref()))
 }
 
 /// Interprets the given affix of the given bytes as a `&mut Self` without
@@ -4586,15 +4589,18 @@ fn ref_from_prefix_suffix<T: FromBytes + KnownLayout + Immutable + ?Sized>(
 /// If there are insufficient bytes, or if that affix of `source` is not
 /// appropriately aligned, this returns `Err`.
 #[inline(always)]
-fn mut_from_prefix_suffix<T: FromBytes + KnownLayout + ?Sized>(
+fn mut_from_prefix_suffix<T: FromBytes + IntoBytes + KnownLayout + ?Sized>(
     source: &mut [u8],
     meta: Option<T::PointerMetadata>,
     cast_type: CastType,
 ) -> Result<(&mut T, &mut [u8]), CastError<&mut [u8], T>> {
     let (slf, prefix_suffix) = Ptr::from_mut(source)
         .try_cast_into::<_, BecauseExclusive>(cast_type, meta)
         .map_err(|err| err.map_src(|s| s.as_mut()))?;
-    Ok((slf.bikeshed_recall_valid().as_mut(), prefix_suffix.as_mut()))
+    Ok((
+        slf.transmute::<_, _, (pointer::transmute::BecauseRead, _), _>().as_mut(),
+        prefix_suffix.as_mut(),
+    ))
 }
 
 /// Analyzes whether a type is [`IntoBytes`].

src/pointer/mod.rs

@@ -12,6 +12,7 @@ mod inner;
 #[doc(hidden)]
 pub mod invariant;
 mod ptr;
+pub(crate) mod transmute;
 
 #[doc(hidden)]
 pub use invariant::{BecauseExclusive, BecauseImmutable, Read};

src/pointer/ptr.rs

@@ -172,7 +172,10 @@ mod _external {
 /// Methods for converting to and from `Ptr` and Rust's safe reference types.
 mod _conversions {
     use super::*;
-    use crate::util::{AlignmentVariance, Covariant, TransparentWrapper, ValidityVariance};
+    use crate::{
+        pointer::transmute::{CastFrom, TransmuteFromAlignment, TransmuteFromPtr},
+        util::{AlignmentVariance, Covariant, TransparentWrapper, ValidityVariance},
+    };
 
     /// `&'a T` → `Ptr<'a, T>`
     impl<'a, T: ?Sized> Ptr<'a, Valid<T>, (Shared, Aligned)> {
@@ -338,6 +341,54 @@ mod _conversions {
         }
     }
 
+    /// `Ptr<'a, T>` → `Ptr<'a, U>`
+    impl<'a, V, I> Ptr<'a, V, I>
+    where
+        V: Validity,
+        I: Invariants,
+    {
+        /// # Safety
+        /// - TODO: `UnsafeCell` agreement
+        /// - The caller promises that the returned `Ptr` satisfies alignment
+        ///   `A`
+        /// - The caller promises that the returned `Ptr` satisfies validity `V`
+        pub(crate) unsafe fn transmute_unchecked<U, A>(self) -> Ptr<'a, U, (I::Aliasing, A)>
+        where
+            A: Alignment,
+            U: Validity,
+            U::Inner: CastFrom<V::Inner>,
+        {
+            // SAFETY:
+            // - By invariant on `CastFrom::cast_from`:
+            //   - This cast preserves address and referent size, and thus the
+            //     returned pointer addresses the same bytes as `p`
+            //   - This cast preserves provenance
+            // - TODO: `UnsafeCell` agreement
+            let ptr =
+                unsafe { self.cast_unsized_unchecked::<U::Inner, _>(|p| U::Inner::cast_from(p)) };
+            // SAFETY: The caller promises that alignment is satisfied.
+            let ptr = unsafe { ptr.assume_alignment() };
+            // SAFETY: The caller promises that validity is satisfied.
+            let ptr = unsafe { ptr.assume_validity::<U>() };
+            ptr.unify_validity()
+        }
+
+        pub(crate) fn transmute<U, A, RT, RA>(self) -> Ptr<'a, U, (I::Aliasing, A)>
+        where
+            A: Alignment,
+            U: TransmuteFromPtr<V, I::Aliasing, RT>,
+            U::Inner: TransmuteFromAlignment<U::Inner, I::Alignment, A, RA> + CastFrom<V::Inner>,
+        {
+            // SAFETY:
+            // - TODO: `UnsafeCell` agreement
+            // - By invariant on `TransmuteFromPtr`, it is sound to treat the
+            //   resulting pointer as having alignment `A`
+            // - By invariant on `TransmuteFromPtr`, it is sound to treat the
+            //   resulting pointer as having validity `V`
+            unsafe { self.transmute_unchecked() }
+        }
+    }
+
     /// `Ptr<'a, T = Wrapper<U>>` → `Ptr<'a, U>`
     impl<'a, V, I> Ptr<'a, V, I>
     where
@@ -429,7 +480,11 @@ mod _conversions {
 /// State transitions between invariants.
 mod _transitions {
     use super::*;
-    use crate::{AlignmentError, TryFromBytes, ValidityError};
+    use crate::{
+        error::TryCastError,
+        pointer::transmute::{CastFrom, TransmuteFromPtr, TryTransmuteFromPtr},
+        AlignmentError, TryFromBytes, ValidityError,
+    };
 
     impl<'a, V, I> Ptr<'a, V, I>
     where
@@ -650,6 +705,22 @@ mod _transitions {
         }
     }
 
+    impl<'a, V, I> Ptr<'a, V, I>
+    where
+        V: Validity,
+        I: Invariants,
+        I::Aliasing: Reference,
+    {
+        /// Forgets that `self` is an `Exclusive` pointer, downgrading it to a
+        /// `Shared` pointer.
+        #[doc(hidden)]
+        #[must_use]
+        #[inline]
+        pub const fn forget_exclusive(self) -> Ptr<'a, V, I::WithAliasing<Shared>> {
+            unsafe { self.assume_invariants() }
+        }
+    }
+
     impl<'a, T, I> Ptr<'a, Initialized<T>, I>
     where
         T: ?Sized,
@@ -661,14 +732,11 @@ mod _transitions {
         #[inline]
         // TODO(#859): Reconsider the name of this method before making it
         // public.
-        pub const fn bikeshed_recall_valid(self) -> Ptr<'a, Valid<T>, I>
+        pub fn bikeshed_recall_valid(self) -> Ptr<'a, Valid<T>, I>
         where
-            T: crate::FromBytes,
+            T: crate::FromBytes + crate::IntoBytes,
         {
-            // SAFETY: The bound `T: FromBytes` ensures that any initialized
-            // sequence of bytes is bit-valid for `T`. `V = Initialized<T>`
-            // ensures that all of the referent bytes are initialized.
-            unsafe { self.assume_valid() }
+            self.transmute().unify_invariants()
         }
 
         /// Checks that `self`'s referent is validly initialized for `T`,
@@ -688,7 +756,12 @@ mod _transitions {
             mut self,
         ) -> Result<Ptr<'a, Valid<T>, I>, ValidityError<Self, T>>
         where
-            T: TryFromBytes + Read<I::Aliasing, R>,
+            T: TryFromBytes, // + Read<I::Aliasing, R>,
+            Valid<T>: TryTransmuteFromPtr<Initialized<T>, I::Aliasing, R>,
+            // NOTE: This bound ought to be implied, but leaving it out causes
+            // Rust to infinite loop during trait solving.
+            <Valid<T> as Validity>::Inner:
+                crate::pointer::transmute::CastFrom<<Initialized<T> as Validity>::Inner>,
             I::Aliasing: Reference,
         {
             // This call may panic. If that happens, it doesn't cause any soundness
@@ -703,6 +776,64 @@ mod _transitions {
             }
         }
     }
+
+    impl<'a, V, I> Ptr<'a, V, I>
+    where
+        V: Validity,
+        I: Invariants,
+    {
+        /// Attempts to transmute a `Ptr<T>` into a `Ptr<U>`.
+        ///
+        /// # Panics
+        ///
+        /// This method will panic if
+        /// [`U::is_bit_valid`][TryFromBytes::is_bit_valid] panics.
+        ///
+        /// # Safety
+        ///
+        /// On error, unsafe code may rely on this method's returned
+        /// `ValidityError` containing `self`.
+        #[inline]
+        pub(crate) fn try_transmute<U, A, R, RR>(
+            mut self,
+        ) -> Result<Ptr<'a, U, I::WithAlignment<A>>, TryCastError<Self, U::Inner>>
+        where
+            U: Validity + TryTransmuteFromPtr<V, I::Aliasing, R>,
+            U::Inner: TryFromBytes + CastFrom<V::Inner>,
+            Initialized<U::Inner>: TransmuteFromPtr<V, I::Aliasing, RR>,
+            // TODO: The `Sized` bound here is only required in order to call
+            // `.bikeshed_try_into_aligned`. There are other ways of getting the
+            // alignment of a type, and we could use these if we need to drop
+            // this bound.
+            <Initialized<U::Inner> as Validity>::Inner: Sized + CastFrom<V::Inner>,
+            I::Aliasing: Reference,
+            A: Alignment,
+        {
+            // TODO: Validate alignment
+            if true {
+                todo!()
+            }
+
+            let is_bit_valid = {
+                let ptr = self.reborrow();
+                let mut ptr = ptr.transmute::<Initialized<U::Inner>, Unknown, _, _>();
+                if let Err(err) = ptr.reborrow().bikeshed_try_into_aligned() {
+                    return Err(todo!());
+                }
+                // This call may panic. If that happens, it doesn't cause any
+                // soundness issues, as we have not generated any invalid state
+                // which we need to fix before returning.
+                <U::Inner as TryFromBytes>::is_bit_valid(ptr)
+            };
+
+            if is_bit_valid {
+                let ptr = unsafe { self.transmute_unchecked() };
+                Ok(ptr.unify_invariants())
+            } else {
+                Err(ValidityError::new(self).into())
+            }
+        }
+    }
 }
 
 /// Casts of the referent type.