[derive] Automatically derive super-traits

`#[derive(FromBytes)]` implies `#[derive(FromZeros)]`, which implies
`#[derive(TryFromBytes)]`.

Closes #925

src/byteorder.rs

@@ -35,10 +35,10 @@
 //!
 //! ```rust,edition2021
 //! # #[cfg(feature = "derive")] { // This example uses derives, and won't compile without them
-//! use zerocopy::{IntoBytes, ByteSlice, FromBytes, FromZeros, NoCell, Ref, Unaligned};
+//! use zerocopy::{IntoBytes, ByteSlice, FromBytes, NoCell, Ref, Unaligned};
 //! use zerocopy::byteorder::network_endian::U16;
 //!
-//! #[derive(FromZeros, FromBytes, IntoBytes, NoCell, Unaligned)]
+//! #[derive(FromBytes, IntoBytes, NoCell, Unaligned)]
 //! #[repr(C)]
 //! struct UdpHeader {
 //! src_port: U16,
@@ -357,7 +357,7 @@ example of how it can be used for parsing UDP packets.
 [`IntoBytes`]: crate::IntoBytes
 [`Unaligned`]: crate::Unaligned"),
  #[derive(Copy, Clone, Eq, PartialEq, Hash)]
- #[cfg_attr(any(feature = "derive", test), derive(KnownLayout, NoCell, TryFromBytes, FromZeros, FromBytes, IntoBytes, Unaligned))]
+ #[cfg_attr(any(feature = "derive", test), derive(KnownLayout, NoCell, FromBytes, IntoBytes, Unaligned))]
  #[repr(transparent)]
  pub struct $name<O>([u8; $bytes], PhantomData<O>);
  }

src/lib.rs

@@ -5766,9 +5766,7 @@ mod tests {
  //
  // This is used to test the custom derives of our traits. The `[u8]` type
  // gets a hand-rolled impl, so it doesn't exercise our custom derives.
- #[derive(
- Debug, Eq, PartialEq, TryFromBytes, FromZeros, FromBytes, IntoBytes, Unaligned, NoCell,
- )]
+ #[derive(Debug, Eq, PartialEq, FromBytes, IntoBytes, Unaligned, NoCell)]
  #[repr(transparent)]
  struct Unsized([u8]);
 
@@ -7896,7 +7894,7 @@ mod tests {
  assert_eq!(too_many_bytes[0], 123);
  }
 
- #[derive(Debug, Eq, PartialEq, TryFromBytes, FromZeros, FromBytes, IntoBytes, NoCell)]
+ #[derive(Debug, Eq, PartialEq, FromBytes, IntoBytes, NoCell)]
  #[repr(C)]
  struct Foo {
  a: u32,
@@ -7925,7 +7923,7 @@ mod tests {
 
  #[test]
  fn test_array() {
- #[derive(TryFromBytes, FromZeros, FromBytes, IntoBytes, NoCell)]
+ #[derive(FromBytes, IntoBytes, NoCell)]
  #[repr(C)]
  struct Foo {
  a: [u16; 33],
@@ -7989,7 +7987,7 @@ mod tests {
 
  #[test]
  fn test_transparent_packed_generic_struct() {
- #[derive(IntoBytes, TryFromBytes, FromZeros, FromBytes, Unaligned)]
+ #[derive(IntoBytes, FromBytes, Unaligned)]
  #[repr(transparent)]
  struct Foo<T> {
  _t: T,
@@ -7999,7 +7997,7 @@ mod tests {
  assert_impl_all!(Foo<u32>: FromZeros, FromBytes, IntoBytes);
  assert_impl_all!(Foo<u8>: Unaligned);
 
- #[derive(IntoBytes, TryFromBytes, FromZeros, FromBytes, Unaligned)]
+ #[derive(IntoBytes, FromBytes, Unaligned)]
  #[repr(packed)]
  struct Bar<T, U> {
  _t: T,

src/util.rs

@@ -220,8 +220,6 @@ pub(crate) mod testutil {
  #[derive(
  KnownLayout,
  NoCell,
- TryFromBytes,
- FromZeros,
  FromBytes,
  IntoBytes,
  Eq,
@@ -249,9 +247,7 @@ pub(crate) mod testutil {
  }
  }
 
- #[derive(
- NoCell, FromZeros, FromBytes, Eq, PartialEq, Ord, PartialOrd, Default, Debug, Copy, Clone,
- )]
+ #[derive(NoCell, FromBytes, Eq, PartialEq, Ord, PartialOrd, Default, Debug, Copy, Clone)]
  #[repr(C)]
  pub(crate) struct Nested<T, U: ?Sized> {
  _t: T,

src/wrappers.rs

@@ -53,7 +53,7 @@ use super::*;
 #[derive(Default, Copy)]
 #[cfg_attr(
  any(feature = "derive", test),
- derive(NoCell, KnownLayout, TryFromBytes, FromZeros, FromBytes, IntoBytes, Unaligned)
+ derive(NoCell, KnownLayout, FromBytes, IntoBytes, Unaligned)
 )]
 #[repr(C, packed)]
 pub struct Unalign<T>(T);

zerocopy-derive/src/lib.rs

@@ -295,13 +295,16 @@ pub fn derive_try_from_bytes(ts: proc_macro::TokenStream) -> proc_macro::TokenSt
 
 #[proc_macro_derive(FromZeros)]
 pub fn derive_from_zeros(ts: proc_macro::TokenStream) -> proc_macro::TokenStream {
+ let try_from_bytes = derive_try_from_bytes(ts.clone());
+
  let ast = syn::parse_macro_input!(ts as DeriveInput);
- match &ast.data {
+ let from_zeros = match &ast.data {
  Data::Struct(strct) => derive_from_zeros_struct(&ast, strct),
  Data::Enum(enm) => derive_from_zeros_enum(&ast, enm),
  Data::Union(unn) => derive_from_zeros_union(&ast, unn),
  }
- .into()
+ .into();
+ IntoIterator::into_iter([try_from_bytes, from_zeros]).collect()
 }
 
 /// Deprecated: prefer [`FromZeros`] instead.
@@ -314,13 +317,17 @@ pub fn derive_from_zeroes(ts: proc_macro::TokenStream) -> proc_macro::TokenStrea
 
 #[proc_macro_derive(FromBytes)]
 pub fn derive_from_bytes(ts: proc_macro::TokenStream) -> proc_macro::TokenStream {
+ let from_zeros = derive_from_zeros(ts.clone());
+
  let ast = syn::parse_macro_input!(ts as DeriveInput);
- match &ast.data {
+ let from_bytes = match &ast.data {
  Data::Struct(strct) => derive_from_bytes_struct(&ast, strct),
  Data::Enum(enm) => derive_from_bytes_enum(&ast, enm),
  Data::Union(unn) => derive_from_bytes_union(&ast, unn),
  }
- .into()
+ .into();
+
+ IntoIterator::into_iter([from_zeros, from_bytes]).collect()
 }
 
 #[proc_macro_derive(IntoBytes)]
@@ -447,25 +454,33 @@ fn derive_try_from_bytes_enum(ast: &DeriveInput, enm: &DataEnum) -> proc_macro2:
  .to_compile_error();
  }
 
- // We don't actually care what the repr is; we just care that it's one of
- // the allowed ones.
- try_or_print!(ENUM_TRY_FROM_BYTES_CFG.validate_reprs(ast));
+ let reprs = try_or_print!(ENUM_TRY_FROM_BYTES_CFG.validate_reprs(ast));
+
+ // Figure out whether the enum could in theory implement `FromBytes`.
+ let from_bytes = enum_size_from_repr(reprs.as_slice())
+ .map(|size| {
+ // As of this writing, `enm.is_fieldless()` is redundant since we've
+ // already checked for it and returned if the check failed. However, if
+ // we ever remove that check, then without a similar check here, this
+ // code would become unsound.
+ enm.is_fieldless() && enm.variants.len() == 1usize << size
+ })
+ .unwrap_or(false);
+
  let variant_names = enm.variants.iter().map(|v| &v.ident);
- let extras = Some(quote!(
- // SAFETY: We use `is_bit_valid` to validate that the bit pattern
- // corresponds to one of the field-less enum's variant discriminants.
- // Thus, this is a sound implementation of `is_bit_valid`.
- fn is_bit_valid(
- candidate: ::zerocopy::Ptr<
- '_,
- Self,
- (
- ::zerocopy::pointer::invariant::Shared,
- ::zerocopy::pointer::invariant::AnyAlignment,
- ::zerocopy::pointer::invariant::Initialized,
- ),
- >,
- ) -> ::zerocopy::macro_util::core_reexport::primitive::bool {
+ let is_bit_valid_body = if from_bytes {
+ // If the enum could implement `FromBytes`, we can avoid emitting a
+ // match statement. This is faster to compile, and generates code which
+ // performs better.
+ quote!({
+ // Prevent an "unused" warning.
+ let _ = candidate;
+ // SAFETY: If the enum could implement `FromBytes`, then all bit
+ // patterns are valid. Thus, this is a sound implementation.
+ true
+ })
+ } else {
+ quote!(
  use ::zerocopy::macro_util::core_reexport;
  // SAFETY:
  // - `cast` is implemented as required.
@@ -499,6 +514,25 @@ fn derive_try_from_bytes_enum(ast: &DeriveInput, enm: &DataEnum) -> proc_macro2:
  // `candidate` refers to a bit-valid `Self`.
  discriminant == d
  })*
+ )
+ };
+
+ let extras = Some(quote!(
+ // SAFETY: We use `is_bit_valid` to validate that the bit pattern
+ // corresponds to one of the field-less enum's variant discriminants.
+ // Thus, this is a sound implementation of `is_bit_valid`.
+ fn is_bit_valid(
+ candidate: ::zerocopy::Ptr<
+ '_,
+ Self,
+ (
+ ::zerocopy::pointer::invariant::Shared,
+ ::zerocopy::pointer::invariant::AnyAlignment,
+ ::zerocopy::pointer::invariant::Initialized,
+ ),
+ >,
+ ) -> ::zerocopy::macro_util::core_reexport::primitive::bool {
+ #is_bit_valid_body
  }
  ));
  impl_block(ast, enm, Trait::TryFromBytes, FieldBounds::ALL_SELF, SelfBounds::None, None, extras)
@@ -608,13 +642,9 @@ fn derive_from_bytes_enum(ast: &DeriveInput, enm: &DataEnum) -> proc_macro2::Tok
 
  let reprs = try_or_print!(ENUM_FROM_BYTES_CFG.validate_reprs(ast));
 
- let variants_required = match reprs.as_slice() {
- [EnumRepr::U8] | [EnumRepr::I8] => 1usize << 8,
- [EnumRepr::U16] | [EnumRepr::I16] => 1usize << 16,
- // `validate_reprs` has already validated that it's one of the preceding
- // patterns.
- _ => unreachable!(),
- };
+ let variants_required = 1usize
+ << enum_size_from_repr(reprs.as_slice())
+ .expect("internal error: `validate_reprs` has already validated that the reprs guarantee the enum's size");
  if enm.variants.len() != variants_required {
  return Error::new_spanned(
  ast,
@@ -629,6 +659,15 @@ fn derive_from_bytes_enum(ast: &DeriveInput, enm: &DataEnum) -> proc_macro2::Tok
  impl_block(ast, enm, Trait::FromBytes, FieldBounds::ALL_SELF, SelfBounds::None, None, None)
 }
 
+// Returns `None` if the enum's size is not guaranteed by the repr.
+fn enum_size_from_repr(reprs: &[EnumRepr]) -> Option<usize> {
+ match reprs {
+ [EnumRepr::U8] | [EnumRepr::I8] => Some(8),
+ [EnumRepr::U16] | [EnumRepr::I16] => Some(16),
+ _ => None,
+ }
+}
+
 #[rustfmt::skip]
 const ENUM_FROM_BYTES_CFG: Config<EnumRepr> = {
  use EnumRepr::*;

zerocopy-derive/tests/enum_from_bytes.rs

@@ -29,7 +29,7 @@ include!("include.rs");
 // `Variant128` has a discriminant of -128) since Rust won't automatically wrap
 // a signed discriminant around without you explicitly telling it to.
 
-#[derive(imp::FromZeros, imp::FromBytes)]
+#[derive(imp::FromBytes)]
 #[repr(u8)]
 enum FooU8 {
  Variant0,
@@ -292,7 +292,7 @@ enum FooU8 {
 
 util_assert_impl_all!(FooU8: imp::FromBytes);
 
-#[derive(imp::FromZeros, imp::FromBytes)]
+#[derive(imp::FromBytes)]
 #[repr(i8)]
 enum FooI8 {
  Variant0,
@@ -555,7 +555,7 @@ enum FooI8 {
 
 util_assert_impl_all!(FooI8: imp::FromBytes);
 
-#[derive(imp::FromZeros, imp::FromBytes)]
+#[derive(imp::FromBytes)]
 #[repr(u8, align(2))]
 enum FooU8Align {
  Variant0,
@@ -818,7 +818,7 @@ enum FooU8Align {
 
 util_assert_impl_all!(FooU8Align: imp::FromBytes);
 
-#[derive(imp::FromZeros, imp::FromBytes)]
+#[derive(imp::FromBytes)]
 #[repr(i8, align(2))]
 enum FooI8Align {
  Variant0,
@@ -1081,7 +1081,7 @@ enum FooI8Align {
 
 util_assert_impl_all!(FooI8Align: imp::FromBytes);
 
-#[derive(imp::FromZeros, imp::FromBytes)]
+#[derive(imp::FromBytes)]
 #[repr(u16)]
 enum FooU16 {
  Variant0,
@@ -66624,7 +66624,7 @@ enum FooU16 {
 
 util_assert_impl_all!(FooU16: imp::FromBytes);
 
-#[derive(imp::FromZeros, imp::FromBytes)]
+#[derive(imp::FromBytes)]
 #[repr(i16)]
 enum FooI16 {
  Variant0,

zerocopy-derive/tests/hygiene.rs

@@ -18,14 +18,7 @@ include!("include.rs");
 
 extern crate zerocopy as _zerocopy;
 
-// #[macro_use]
-// mod util;
-
-// use std::{marker::PhantomData, option::IntoIter};
-
-#[derive(
- _zerocopy::KnownLayout, _zerocopy::FromZeros, _zerocopy::FromBytes, _zerocopy::Unaligned,
-)]
+#[derive(_zerocopy::KnownLayout, _zerocopy::FromBytes, _zerocopy::Unaligned)]
 #[repr(C)]
 struct TypeParams<'a, T, I: imp::Iterator> {
  a: T,

zerocopy-derive/tests/include.rs

@@ -47,8 +47,6 @@ pub mod util {
  #[derive(
  super::imp::KnownLayout,
  super::imp::NoCell,
- super::imp::TryFromBytes,
- super::imp::FromZeros,
  super::imp::FromBytes,
  super::imp::IntoBytes,
  Copy,

zerocopy-derive/tests/paths_and_modules.rs

@@ -17,13 +17,13 @@ include!("include.rs");
 mod foo {
  use super::*;
 
- #[derive(imp::FromZeros, imp::FromBytes, imp::IntoBytes, imp::Unaligned)]
+ #[derive(imp::FromBytes, imp::IntoBytes, imp::Unaligned)]
  #[repr(C)]
  pub struct Foo {
  foo: u8,
  }
 
- #[derive(imp::FromZeros, imp::FromBytes, imp::IntoBytes, imp::Unaligned)]
+ #[derive(imp::FromBytes, imp::IntoBytes, imp::Unaligned)]
  #[repr(C)]
  pub struct Bar {
  bar: u8,
@@ -32,7 +32,7 @@ mod foo {
 
 use foo::Foo;
 
-#[derive(imp::FromZeros, imp::FromBytes, imp::IntoBytes, imp::Unaligned)]
+#[derive(imp::FromBytes, imp::IntoBytes, imp::Unaligned)]
 #[repr(C)]
 struct Baz {
  foo: Foo,