introduce HasField

gherrit-pr-id: G2238bc341570838db412d880017b3f0c25ac09fa

Author: jswrenn

src/lib.rs

@@ -1087,6 +1087,25 @@ const _: () = unsafe {
     unsafe_impl_known_layout!(T: ?Sized + KnownLayout => #[repr(T::MaybeUninit)] MaybeUninit<T>)
 };
 
+/// Denotes that `Self` has a given field.
+///
+/// # Safety
+///
+/// For a field `f`:
+/// - if `f` is named, `FIELD_ID` is a hash of `f`'s identifier
+/// - if `f` is anonymous, `FIELD_ID` is the index of `f`
+/// - `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 FIELD_ID: u128> {
+    fn only_derive_is_allowed_to_implement_this_trait()
+    where
+        Self: Sized;
+
+    /// The type of the field.
+    type Type: ?Sized;
+}
+
 /// Analyzes whether a type is [`FromZeros`].
 ///
 /// This derive analyzes, at compile time, whether the annotated type satisfies

src/util/macro_util.rs

@@ -529,6 +529,62 @@ macro_rules! assert_size_eq {
     }};
 }
 
+#[doc(hidden)] // `#[macro_export]` bypasses this module's `#[doc(hidden)]`.
+#[macro_export]
+macro_rules! ident_id {
+    ($field:ident) => {
+        $crate::util::macro_util::hash_name(stringify!($field))
+    };
+    ($field:literal) => {
+        $field
+    };
+}
+
+/// Computes the hash of a string.
+///
+/// NOTE(#2749) on hash collisions: This function's output only needs to be
+/// deterministic within a particular compilation. Thus, if a user ever reports
+/// a hash collision (very unlikely given the <= 16-byte special case), we can
+/// strengthen the hash function at that point and publish a new version. Since
+/// this is computed at compile time on small strings, we can easily use more
+/// expensive and higher-quality hash functions if need be.
+#[inline(always)]
+#[must_use]
+#[allow(clippy::as_conversions, clippy::indexing_slicing, clippy::arithmetic_side_effects)]
+pub const fn hash_name(name: &str) -> u128 {
+    let name = name.as_bytes();
+
+    // We guarantee freedom from hash collisions between any two strings of
+    // length 16 or less by having the hashes of such strings be equal to
+    // their value. There is still a possibility that such strings will have
+    // the same value as the hash of a string of length > 16.
+    if name.len() <= size_of::<u128>() {
+        let mut bytes = [0u8; 16];
+
+        let mut i = 0;
+        while i < name.len() {
+            bytes[i] = name[i];
+            i += 1;
+        }
+
+        return u128::from_ne_bytes(bytes);
+    };
+
+    // An implementation of FxHasher, although returning a u128. Probably
+    // not as strong as it could be, but probably more collision resistant
+    // than normal 64-bit FxHasher.
+    let mut hash = 0u128;
+    let mut i = 0;
+    while i < name.len() {
+        // This is just FxHasher's `0x517cc1b727220a95` constant
+        // concatenated back-to-back.
+        const K: u128 = 0x517cc1b727220a95517cc1b727220a95;
+        hash = (hash.rotate_left(5) ^ (name[i] as u128)).wrapping_mul(K);
+        i += 1;
+    }
+    hash
+}
+
 /// Is a given source a valid instance of `Dst`?
 ///
 /// If so, returns `src` casted to a `Ptr<Dst, _>`. Otherwise returns `None`.

zerocopy-derive/src/lib.rs

@@ -41,11 +41,12 @@ mod ext;
 mod output_tests;
 mod repr;
 
-use proc_macro2::{Span, TokenStream, TokenTree};
+use proc_macro2::{Span, TokenStream};
 use quote::{quote, ToTokens};
 use syn::{
-    parse_quote, Attribute, Data, DataEnum, DataStruct, DataUnion, DeriveInput, Error, Expr,
-    ExprLit, ExprUnary, GenericParam, Ident, Lit, Meta, Path, Type, UnOp, WherePredicate,
+    parse_quote, spanned::Spanned as _, Attribute, Data, DataEnum, DataStruct, DataUnion,
+    DeriveInput, Error, Expr, ExprLit, ExprUnary, GenericParam, Ident, Lit, Meta, Path, Type, UnOp,
+    WherePredicate,
 };
 
 use crate::{ext::*, repr::*};
@@ -464,11 +465,12 @@ fn derive_known_layout_inner(
 
     Ok(match &ast.data {
         Data::Struct(strct) => {
-            let require_trait_bound_on_field_types = if self_bounds == SelfBounds::SIZED {
-                FieldBounds::None
-            } else {
-                FieldBounds::TRAILING_SELF
-            };
+            let require_trait_bound_on_field_types =
+                if matches!(self_bounds, SelfBounds::All(&[Trait::Sized])) {
+                    FieldBounds::None
+                } else {
+                    FieldBounds::TRAILING_SELF
+                };
 
             // A bound on the trailing field is required, since structs are
             // unsized if their trailing field is unsized. Reflecting the layout
@@ -737,6 +739,51 @@ fn derive_split_at_inner(
     .build())
 }
 
+fn derive_has_field_variant(
+    ast: &DeriveInput,
+    data: &dyn DataExt,
+    zerocopy_crate: &Path,
+) -> TokenStream {
+    let fields = ast.data.fields();
+
+    if fields.is_empty() {
+        return quote! {};
+    }
+
+    let field_tokens = fields.iter().map(|(vis, ident, _)| {
+        let ident = Ident::new(&format!("ẕ{ident}"), ident.span());
+        quote!(
+            #vis enum #ident {}
+        )
+    });
+
+    let has_fields = fields.iter().map(|(_, ident, ty)| {
+        let field_token = Ident::new(&format!("ẕ{ident}"), ident.span());
+        ImplBlockBuilder::new(
+            ast,
+            data,
+            Trait::HasField {
+                field: parse_quote!(#field_token),
+                field_id: parse_quote!({ #zerocopy_crate::ident_id!(#ident) }),
+            },
+            FieldBounds::None,
+            zerocopy_crate,
+        )
+        .inner_extras(quote! {
+            type Type = #ty;
+        })
+        .build()
+    });
+
+    quote! {
+        #[allow(non_camel_case_types)]
+        const _: () = {
+            #(#field_tokens)*
+            #(#has_fields)*
+        };
+    }
+}
+
 /// A struct is `TryFromBytes` if:
 /// - all fields are `TryFromBytes`
 fn derive_try_from_bytes_struct(
@@ -815,6 +862,7 @@ fn derive_try_from_bytes_struct(
         zerocopy_crate,
     )
     .inner_extras(extras)
+    .outer_extras(derive_has_field_variant(ast, strct, zerocopy_crate))
     .build())
 }
 
@@ -894,6 +942,7 @@ fn derive_try_from_bytes_union(
         });
     ImplBlockBuilder::new(ast, unn, Trait::TryFromBytes, field_type_trait_bounds, zerocopy_crate)
         .inner_extras(extras)
+        .outer_extras(derive_has_field_variant(ast, unn, zerocopy_crate))
         .build()
 }
 
@@ -964,7 +1013,7 @@ fn try_gen_trivial_is_bit_valid(
     // make this no longer true. To hedge against these, we include an explicit
     // `Self: FromBytes` check in the generated `is_bit_valid`, which is
     // bulletproof.
-    if top_level == Trait::FromBytes && ast.generics.params.is_empty() {
+    if matches!(top_level, Trait::FromBytes) && ast.generics.params.is_empty() {
         Some(quote!(
             // SAFETY: See inline.
             fn is_bit_valid<___ZerocopyAliasing>(
@@ -1533,9 +1582,10 @@ impl PaddingCheck {
     }
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Clone)]
 enum Trait {
     KnownLayout,
+    HasField { field: Type, field_id: Expr },
     Immutable,
     TryFromBytes,
     FromZeros,
@@ -1560,6 +1610,7 @@ impl ToTokens for Trait {
         // [1] https://doc.rust-lang.org/1.81.0/std/fmt/trait.Debug.html#stability
         // [2] https://doc.rust-lang.org/beta/unstable-book/compiler-flags/fmt-debug.html
         let s = match self {
+            Trait::HasField { .. } => "HasField",
             Trait::KnownLayout => "KnownLayout",
             Trait::Immutable => "Immutable",
             Trait::TryFromBytes => "TryFromBytes",
@@ -1573,7 +1624,25 @@ impl ToTokens for Trait {
             Trait::SplitAt => "SplitAt",
         };
         let ident = Ident::new(s, Span::call_site());
-        tokens.extend(core::iter::once(TokenTree::Ident(ident)));
+        let empty_args: syn::AngleBracketedGenericArguments = parse_quote!(<>);
+        let arguments: syn::AngleBracketedGenericArguments = match self {
+            Trait::HasField { field, field_id } => {
+                parse_quote!(<#field, #field_id>)
+            }
+            Trait::KnownLayout => empty_args,
+            Trait::Immutable => empty_args,
+            Trait::TryFromBytes => empty_args,
+            Trait::FromZeros => empty_args,
+            Trait::FromBytes => empty_args,
+            Trait::IntoBytes => empty_args,
+            Trait::Unaligned => empty_args,
+            Trait::Sized => empty_args,
+            Trait::ByteHash => empty_args,
+            Trait::ByteEq => empty_args,
+            Trait::SplitAt => empty_args,
+        };
+
+        tokens.extend(quote!(#ident #arguments));
     }
 }
 
@@ -1588,7 +1657,6 @@ impl Trait {
     }
 }
 
-#[derive(Debug, Eq, PartialEq)]
 enum TraitBound {
     Slf,
     Other(Trait),
@@ -1606,7 +1674,6 @@ impl<'a> FieldBounds<'a> {
     const TRAILING_SELF: FieldBounds<'a> = FieldBounds::Trailing(&[TraitBound::Slf]);
 }
 
-#[derive(Debug, Eq, PartialEq)]
 enum SelfBounds<'a> {
     None,
     All(&'a [Trait]),
@@ -1620,16 +1687,19 @@ impl<'a> SelfBounds<'a> {
 }
 
 /// Normalizes a slice of bounds by replacing [`TraitBound::Slf`] with `slf`.
-fn normalize_bounds(slf: Trait, bounds: &[TraitBound]) -> impl '_ + Iterator<Item = Trait> {
+fn normalize_bounds<'a>(
+    slf: &'a Trait,
+    bounds: &'a [TraitBound],
+) -> impl 'a + Iterator<Item = Trait> {
     bounds.iter().map(move |bound| match bound {
-        TraitBound::Slf => slf,
-        TraitBound::Other(trt) => *trt,
+        TraitBound::Slf => slf.clone(),
+        TraitBound::Other(trt) => trt.clone(),
     })
 }
 
-struct ImplBlockBuilder<'a, D: DataExt> {
+struct ImplBlockBuilder<'a> {
     input: &'a DeriveInput,
-    data: &'a D,
+    data: &'a dyn DataExt,
     trt: Trait,
     field_type_trait_bounds: FieldBounds<'a>,
     zerocopy_crate: &'a Path,
@@ -1639,10 +1709,10 @@ struct ImplBlockBuilder<'a, D: DataExt> {
     outer_extras: Option<TokenStream>,
 }
 
-impl<'a, D: DataExt> ImplBlockBuilder<'a, D> {
+impl<'a> ImplBlockBuilder<'a> {
     fn new(
         input: &'a DeriveInput,
-        data: &'a D,
+        data: &'a dyn DataExt,
         trt: Trait,
         field_type_trait_bounds: FieldBounds<'a>,
         zerocopy_crate: &'a Path,
@@ -1759,12 +1829,12 @@ impl<'a, D: DataExt> ImplBlockBuilder<'a, D> {
             (FieldBounds::All(traits), _) => fields
                 .iter()
                 .map(|(_vis, _name, ty)| {
-                    bound_tt(ty, normalize_bounds(self.trt, traits), zerocopy_crate)
+                    bound_tt(ty, normalize_bounds(&self.trt, traits), zerocopy_crate)
                 })
                 .collect(),
             (FieldBounds::None, _) | (FieldBounds::Trailing(..), []) => vec![],
             (FieldBounds::Trailing(traits), [.., last]) => {
-                vec![bound_tt(last.2, normalize_bounds(self.trt, traits), zerocopy_crate)]
+                vec![bound_tt(last.2, normalize_bounds(&self.trt, traits), zerocopy_crate)]
             }
             (FieldBounds::Explicit(bounds), _) => bounds,
         };
@@ -1796,7 +1866,7 @@ impl<'a, D: DataExt> ImplBlockBuilder<'a, D> {
         let self_bounds: Option<WherePredicate> = match self.self_type_trait_bounds {
             SelfBounds::None => None,
             SelfBounds::All(traits) => {
-                Some(bound_tt(&parse_quote!(Self), traits.iter().copied(), zerocopy_crate))
+                Some(bound_tt(&parse_quote!(Self), traits.iter().cloned(), zerocopy_crate))
             }
         };
 
@@ -1855,7 +1925,7 @@ impl<'a, D: DataExt> ImplBlockBuilder<'a, D> {
             }
         };
 
-        if let Some(outer_extras) = self.outer_extras {
+        if let Some(outer_extras) = self.outer_extras.filter(|e| !e.is_empty()) {
             // So that any items defined in `#outer_extras` don't conflict with
             // existing names defined in this scope.
             quote! {