[project] Distinguish structs/union/enums

For the `HasField` `VARIANT_ID` and `FIELD_ID` constants, use `i128`
instead of `u128`. For structs and unions, set `VARIANT_ID = -1` and
`VARIANT_ID = -2` (respectively) instead of 0. This ensures that we will
never accidentally confuse the first (ie, 0th) variant of an enum with a
struct or union. It also paves the way for us to define methods which
only support a subset of structs/unions/enums.

Makes progress on #196, #2856

gherrit-pr-id: G03596047b3e8a9931799295d1e707540561c4e46

Author: joshlf

src/impls.rs

@@ -818,7 +818,9 @@ const _: () = {
     // private field, and because it is the name it is referred to in the public
     // documentation of `ManuallyDrop::new`, `ManuallyDrop::into_inner`,
     // `ManuallyDrop::take` and `ManuallyDrop::drop`.
-    unsafe impl<T> HasField<value, 0, { crate::ident_id!(value) }> for ManuallyDrop<T> {
+    unsafe impl<T> HasField<value, { crate::STRUCT_VARIANT_ID }, { crate::ident_id!(value) }>
+        for ManuallyDrop<T>
+    {
         type Type = T;
 
         #[inline]

src/lib.rs

@@ -1089,6 +1089,17 @@ const _: () = unsafe {
     unsafe_impl_known_layout!(T: ?Sized + KnownLayout => #[repr(T::MaybeUninit)] MaybeUninit<T>)
 };
 
+// FIXME(#196, #2856): Eventually, we'll want to support enums variants and
+// union fields being treated uniformly since they behave similarly to each
+// other in terms of projecting validity – specifically, for a type `T` with
+// validity `V`, if `T` is a struct type, then its fields straightforwardly also
+// have validity `V`. By contrast, if `T` is an enum or union type, then
+// validity is not straightforwardly recursive in this way.
+#[doc(hidden)]
+pub const STRUCT_VARIANT_ID: i128 = -1;
+#[doc(hidden)]
+pub const UNION_VARIANT_ID: i128 = -2;
+
 /// Projects a given field from `Self`.
 ///
 /// All implementations of `HasField` for a particular field `f` in `Self`
@@ -1099,12 +1110,16 @@ const _: () = unsafe {
 ///
 /// A field `f` is `HasField` for `Self` if and only if:
 ///
-/// - if `f` has name `n`, `FIELD_ID` is `zerocopy::ident_id!(n)`; otherwise, if
-///   `f` is at index `i`, `FIELD_ID` is `zerocopy::ident_id!(i)`.
+/// - If `Self` is a struct or union type, then `VARIANT_ID` is
+///   `STRUCT_VARIANT_ID` or `UNION_VARIANT_ID` respectively; otherwise, if
+///   `Self` is an enum type, `VARIANT_ID` is the numerical index of the enum
+///   variant in which `f` appears.
+/// - If `f` has name `n`, `FIELD_ID` is `zerocopy::ident_id!(n)`; otherwise,
+///   if `f` is at index `i`, `FIELD_ID` is `zerocopy::ident_id!(i)`.
 /// - `Field` is a type with the same visibility as `f`.
 /// - `Type` has the same type as `f`.
 #[doc(hidden)]
-pub unsafe trait HasField<Field, const VARIANT_ID: u128, const FIELD_ID: u128> {
+pub unsafe trait HasField<Field, const VARIANT_ID: i128, const FIELD_ID: i128> {
     fn only_derive_is_allowed_to_implement_this_trait()
     where
         Self: Sized;

src/pointer/inner.rs

@@ -200,7 +200,7 @@ impl<'a, T: ?Sized> PtrInner<'a, T> {
     /// Projects a field.
     #[must_use]
     #[inline(always)]
-    pub fn project<F, const VARIANT_ID: u128, const FIELD_ID: u128>(self) -> PtrInner<'a, T::Type>
+    pub fn project<F, const VARIANT_ID: i128, const FIELD_ID: i128>(self) -> PtrInner<'a, T::Type>
     where
         T: HasField<F, VARIANT_ID, FIELD_ID>,
     {

src/util/macro_util.rs

@@ -553,7 +553,7 @@ macro_rules! ident_id {
 #[inline(always)]
 #[must_use]
 #[allow(clippy::as_conversions, clippy::indexing_slicing, clippy::arithmetic_side_effects)]
-pub const fn hash_name(name: &str) -> u128 {
+pub const fn hash_name(name: &str) -> i128 {
     let name = name.as_bytes();
 
     // We guarantee freedom from hash collisions between any two strings of
@@ -569,7 +569,7 @@ pub const fn hash_name(name: &str) -> u128 {
             i += 1;
         }
 
-        return u128::from_ne_bytes(bytes);
+        return i128::from_ne_bytes(bytes);
     };
 
     // An implementation of FxHasher, although returning a u128. Probably
@@ -584,7 +584,7 @@ pub const fn hash_name(name: &str) -> u128 {
         hash = (hash.rotate_left(5) ^ (name[i] as u128)).wrapping_mul(K);
         i += 1;
     }
-    hash
+    i128::from_ne_bytes(hash.to_ne_bytes())
 }
 
 /// Is a given source a valid instance of `Dst`?

zerocopy-derive/src/enum.rs

@@ -301,10 +301,10 @@ pub(crate) fn derive_is_bit_valid(
                     // `___ZerocopyRawEnum` has the same layout as `Self`.
                     let slf = unsafe { slf.cast::<___ZerocopyRawEnum #ty_generics>() };
 
-                    slf.project::<_, 0, { #zerocopy_crate::ident_id!(variants) }>()
-                        .project::<_, 0, { #zerocopy_crate::ident_id!(#variants_union_field_ident) }>()
-                        .project::<_, 0, { #zerocopy_crate::ident_id!(value) }>()
-                        .project::<_, 0, { #zerocopy_crate::ident_id!(#variant_struct_field_index) }>()
+                    slf.project::<_, { #zerocopy_crate::STRUCT_VARIANT_ID }, { #zerocopy_crate::ident_id!(variants) }>()
+                        .project::<_, { #zerocopy_crate::UNION_VARIANT_ID }, { #zerocopy_crate::ident_id!(#variants_union_field_ident) }>()
+                        .project::<_, { #zerocopy_crate::STRUCT_VARIANT_ID }, { #zerocopy_crate::ident_id!(value) }>()
+                        .project::<_, { #zerocopy_crate::STRUCT_VARIANT_ID }, { #zerocopy_crate::ident_id!(#variant_struct_field_index) }>()
                 }
             })
             .build()
@@ -455,7 +455,7 @@ pub(crate) fn derive_is_bit_valid(
             //   overall struct.
             let project = #zerocopy_crate::pointer::PtrInner::project::<
                 _,
-                0,
+                { #zerocopy_crate::STRUCT_VARIANT_ID },
                 { #zerocopy_crate::ident_id!(variants) }
             >;
             let variants = unsafe {

zerocopy-derive/src/lib.rs

@@ -758,14 +758,19 @@ fn derive_has_field_struct_union(
         )
     });
 
-    let has_fields = fields.iter().map(|(_, ident, ty)| {
+    let variant_id: Box<Expr> = match &ast.data {
+        Data::Struct(_) => parse_quote!({ #zerocopy_crate::STRUCT_VARIANT_ID }),
+        Data::Union(_) => parse_quote!({ #zerocopy_crate::UNION_VARIANT_ID }),
+        _ => unreachable!(),
+    };
+
+    let has_fields = fields.iter().map(move |(_, ident, ty)| {
         let field_token = Ident::new(&format!("ẕ{}", ident), ident.span());
         ImplBlockBuilder::new(
             ast,
             data,
             Trait::HasField {
-                // Use `0` to denote the sole 'variant' of structs and unions.
-                variant_id: parse_quote!({ #zerocopy_crate::ident_id!(0) }),
+                variant_id: variant_id.clone(),
                 field: parse_quote!(#field_token),
                 field_id: parse_quote!({ #zerocopy_crate::ident_id!(#ident) }),
             },
@@ -844,7 +849,11 @@ fn derive_try_from_bytes_struct(
                     use #zerocopy_crate::pointer::PtrInner;
 
                     true #(&& {
-                        let project = <Self as #zerocopy_crate::HasField<_, 0, { #zerocopy_crate::ident_id!(#field_names) }>>::project;
+                        let project = <Self as #zerocopy_crate::HasField<
+                            _,
+                            { #zerocopy_crate::STRUCT_VARIANT_ID },
+                            { #zerocopy_crate::ident_id!(#field_names) }
+                        >>::project;
                         // SAFETY:
                         // - `project` is a field projection, and so it
                         //   addresses a subset of the bytes addressed by `slf`
@@ -905,7 +914,11 @@ fn derive_try_from_bytes_union(
                     use #zerocopy_crate::pointer::PtrInner;
 
                     false #(|| {
-                        let project = <Self as #zerocopy_crate::HasField<_, 0, { #zerocopy_crate::ident_id!(#field_names) }>>::project;
+                        let project = <Self as #zerocopy_crate::HasField<
+                            _,
+                            { #zerocopy_crate::UNION_VARIANT_ID },
+                            { #zerocopy_crate::ident_id!(#field_names) }
+                        >>::project;
                         // SAFETY:
                         // - `project` is a field projection, and so it
                         //   addresses a subset of the bytes addressed by `slf`