[project] Support projecting enum tags

gherrit-pr-id: G06bb22c59364654d5c0b44cdcb9b70ad58fe8092

Author: joshlf

src/impls.rs

@@ -781,6 +781,20 @@ const _: () = {
     {
         type Type = T;
 
+        type Tag = ();
+
+        // SAFETY: It is trivially sound to project any pointer to a pointer to
+        // a type of size zero and alignment 1 (which `()` is [1]). Such a
+        // pointer will trivially satisfy its aliasing and validity requirements
+        // (since it has a zero-sized referent), and its alignment requirement
+        // (since it is aligned to 1).
+        //
+        // [1] Per https://doc.rust-lang.org/1.92.0/reference/type-layout.html#r-layout.tuple.unit:
+        //
+        //     [T]he unit tuple (`()`)... is guaranteed as a zero-sized type to
+        //     have a size of 0 and an alignment of 1.
+        type ProjectToTag = crate::pointer::cast::CastToUnit;
+
         #[inline]
         fn only_derive_is_allowed_to_implement_this_trait()
         where
@@ -1058,6 +1072,20 @@ mod tuples {
 
                 type Type = $CurrT;
 
+                type Tag = ();
+
+                // SAFETY: It is trivially sound to project any pointer to a
+                // pointer to a type of size zero and alignment 1 (which `()` is
+                // [1]). Such a pointer will trivially satisfy its aliasing and
+                // validity requirements (since it has a zero-sized referent),
+                // and its alignment requirement (since it is aligned to 1).
+                //
+                // [1] Per https://doc.rust-lang.org/1.92.0/reference/type-layout.html#r-layout.tuple.unit:
+                //
+                //     [T]he unit tuple (`()`)... is guaranteed as a zero-sized
+                //     type to have a size of 0 and an alignment of 1.
+                type ProjectToTag = crate::pointer::cast::CastToUnit;
+
                 #[inline(always)]
                 fn project(slf: crate::PtrInner<'_, Self>) -> *mut Self::Type {
                     let slf = slf.as_non_null().as_ptr();

src/lib.rs

@@ -1139,6 +1139,17 @@ pub unsafe trait HasField<Field, const VARIANT_ID: i128, const FIELD_ID: i128> {
     /// The type of the field.
     type Type: ?Sized;
 
+    /// The type's enum tag, or `()` for non-enum types.
+    type Tag: Immutable;
+
+    /// A pointer projection from `Self` to its tag.
+    ///
+    /// # Safety
+    ///
+    /// It must be the case that, for all `slf: Ptr<'_, Self, I>`, it is sound
+    /// to project from `slf` to `Ptr<'_, Self::Tag, I>` using this projection.
+    type ProjectToTag: pointer::cast::Project<Self, Self::Tag>;
+
     /// Projects from `slf` to the field.
     ///
     /// Users should generally not call `project` directly, and instead should
@@ -1185,6 +1196,18 @@ where
     /// otherwise [`core::convert::Infallible`].
     type Error;
 
+    #[must_use]
+    #[inline(always)]
+    fn project_tag<'a>(ptr: Ptr<'a, Self, I>) -> Ptr<'a, Self::Tag, I> {
+        // SAFETY: By invariant on `Self::ProjectToTag`, this is a sound
+        // projection.
+        let tag = unsafe { ptr.project_transmute_unchecked::<_, _, Self::ProjectToTag>() };
+        // SAFETY: By invariant on `Self::ProjectToTag`, the projected pointer
+        // has the same alignment as `ptr`.
+        let tag = unsafe { tag.assume_alignment() };
+        tag.unify_invariants()
+    }
+
     /// Is the given field projectable from `ptr`?
     ///
     /// If a field with [`Self::Invariants`] is projectable from the referent,
@@ -1194,7 +1217,7 @@ where
     /// This method must be overriden if the field's projectability depends on
     /// the value of the bytes in `ptr`.
     #[inline(always)]
-    fn is_projectable<'a>(ptr: Ptr<'a, Self, I>) -> Result<Ptr<'a, Self, I>, Self::Error> {
+    fn is_projectable<'a>(_ptr: Ptr<'a, Self::Tag, I>) -> Result<(), Self::Error> {
         trait IsInfallible {
             const IS_INFALLIBLE: bool;
         }
@@ -1248,7 +1271,7 @@ where
             <Projection<Self, Field, I, VARIANT_ID, FIELD_ID> as IsInfallible>::IS_INFALLIBLE
         );
 
-        Ok(ptr)
+        Ok(())
     }
 }
 

src/pointer/mod.rs

@@ -347,4 +347,20 @@ pub mod cast {
 
     // SAFETY: The `Project::project` impl preserves the set of referent bytes.
     unsafe impl<T: ?Sized + KnownLayout> CastExact<T, [u8]> for AsBytesCast {}
+
+    /// A cast from any type to `()`.
+    #[allow(missing_copy_implementations, missing_debug_implementations)]
+    pub struct CastToUnit;
+
+    // SAFETY: The `project` implementation projects to a subset of its
+    // argument's referent using provenance-preserving operations.
+    unsafe impl<T: ?Sized> Project<T, ()> for CastToUnit {
+        #[inline(always)]
+        fn project(src: PtrInner<'_, T>) -> *mut () {
+            src.as_ptr().cast::<()>()
+        }
+    }
+
+    // SAFETY: The `project` implementation preserves referent address.
+    unsafe impl<T: ?Sized> Cast<T, ()> for CastToUnit {}
 }

src/pointer/ptr.rs

@@ -886,15 +886,16 @@ mod _casts {
 
         #[inline(always)]
         pub fn project<F, const VARIANT_ID: i128, const FIELD_ID: i128>(
-            self,
+            mut self,
         ) -> Result<Ptr<'a, T::Type, T::Invariants>, T::Error>
         where
             T: ProjectField<F, I, VARIANT_ID, FIELD_ID>,
+            I::Aliasing: Reference,
         {
             use crate::pointer::cast::Projection;
-            match T::is_projectable(self) {
-                Ok(ptr) => {
-                    let inner = ptr.as_inner();
+            match T::is_projectable(T::project_tag(self.reborrow())) {
+                Ok(()) => {
+                    let inner = self.as_inner();
                     let projected = inner.project::<_, Projection<F, VARIANT_ID, FIELD_ID>>();
                     // SAFETY: By `T: ProjectField<F, I, VARIANT_ID, FIELD_ID>`,
                     // for `self: Ptr<'_, T, I>` such that `T::is_projectable`

zerocopy-derive/src/derive/try_from_bytes.rs

@@ -247,6 +247,10 @@ pub(crate) fn derive_is_bit_valid(
             .inner_extras(quote! {
                 type Type = #ty;
 
+                type Tag = ___ZerocopyTag;
+
+                type ProjectToTag = #zerocopy_crate::pointer::cast::CastSized;
+
                 #[inline(always)]
                 fn project(slf: #zerocopy_crate::pointer::PtrInner<'_, Self>) -> *mut <Self as #has_field_path>::Type {
                     use #zerocopy_crate::pointer::cast::{CastSized, Projection};
@@ -483,6 +487,10 @@ fn derive_has_field_struct_union(ctx: &Ctx, data: &dyn DataExt) -> TokenStream {
             .inner_extras(quote! {
                 type Type = #ty;
 
+                type Tag = ();
+
+                type ProjectToTag = #zerocopy_crate::pointer::cast::CastToUnit;
+
                 #[inline(always)]
                 fn project(slf: #zerocopy_crate::pointer::PtrInner<'_, Self>) -> *mut <Self as #has_field_path>::Type {
                     let slf = slf.as_ptr();

zerocopy-derive/src/output_tests/expected/from_bytes_union.expected.rs

@@ -67,6 +67,8 @@ const _: () = {
             > for Foo {
                 fn only_derive_is_allowed_to_implement_this_trait() {}
                 type Type = u8;
+                type Tag = ();
+                type ProjectToTag = ::zerocopy::pointer::cast::CastToUnit;
                 #[inline(always)]
                 fn project(
                     slf: ::zerocopy::pointer::PtrInner<'_, Self>,