[WIP] Experimenting with invariant conversion

Author: joshlf

src/macro_util.rs

@@ -436,7 +436,10 @@ pub unsafe fn transmute_mut<'dst, 'src: 'dst, Src: 'src, Dst: 'dst>(
 #[inline]
 fn try_transmute_ptr<Src, Dst, I, R>(
     mut src: Ptr<'_, Src, I>,
-) -> Result<Ptr<'_, Dst, (I::Aliasing, invariant::Any, invariant::Valid)>, Ptr<'_, Src, I>>
+) -> Result<
+    Ptr<'_, Dst, (I::Aliasing, invariant::Any, invariant::Valid)>,
+    ValidityError<Ptr<'_, Src, I>, Dst>,
+>
 where
     Src: IntoBytes,
     Dst: TryFromBytes + AliasingSafe<Src, I::Aliasing, R>,
@@ -463,14 +466,28 @@ where
     // initialized bytes.
     let mut c_ptr = unsafe { c_ptr.assume_initialized() };
 
-    if Dst::is_bit_valid(c_ptr) {
-        // SAFETY: TODO
-        let ptr = unsafe { c_ptr.assume_valid() };
+    c_ptr.try_into_valid().map_err(|err| {
+        err.map_src(|src| {
+            // SAFETY: TODO
+            let src = unsafe { src.cast_unsized(|p| p as *mut Src) };
+            // SAFETY: `src` is the same pointer that was passed to this method,
+            // which had validity `invariant::Valid`. `try_into_valid` promises not
+            // to modify its receiver's referent, so `src`'s referent is still a
+            // valid `Src`.
+            let src = unsafe { src.assume_valid() };
+
+            src.foobar()
+        })
+    })
 
-        Ok(ptr)
-    } else {
-        Err(src)
-    }
+    // if Dst::is_bit_valid(c_ptr.reborrow()) {
+    //     // SAFETY: TODO
+    //     let ptr = unsafe { c_ptr.assume_valid() };
+
+    //     Ok(ptr)
+    // } else {
+    //     Err(src)
+    // }
 }
 
 /// Attempts to transmute `Src` into `Dst`.

src/pointer/ptr.rs

@@ -159,7 +159,7 @@ macro_rules! define_system {
         )]
         /// This trait is implemented for such tuples, and can be used to
         /// project out the components of these tuples via its associated types.
-        pub trait $system: sealed::Sealed {
+        pub trait $system: sealed::Sealed + From<($(Self::$set),*)> {
             $(
                 $(#[$set_attr])*
                 type $set: $set;
@@ -637,6 +637,19 @@ mod _transitions {
         T: 'a + ?Sized,
         I: Invariants,
     {
+        pub(crate) fn foobar<II>(self) -> Ptr<'a, T, II>
+        where
+            II: Invariants<
+                Aliasing = I::Aliasing,
+                Alignment = I::Alignment,
+                Validity = I::Validity,
+            >,
+        {
+            // SAFETY: All of the invariants in `II` are the same as those in
+            // `I`.
+            unsafe { self.assume_invariants() }
+        }
+
         /// Returns a `Ptr` with [`Exclusive`] aliasing if `self` already has
         /// `Exclusive` aliasing.
         ///