add Zeroable derive macro

Author: BennoLossin

pinned-init-macro/src/lib.rs

@@ -1,5 +1,6 @@
 mod pin_data;
 mod pinned_drop;
+mod zeroable;
 
 use proc_macro::TokenStream;
 
@@ -78,3 +79,22 @@ pub fn pin_data(inner: TokenStream, item: TokenStream) -> TokenStream {
 pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {
     pinned_drop::pinned_drop(args, input)
 }
+
+/// Derives the [`Zeroable`] trait for the given struct.
+///
+/// This can only be used for structs where every field implements the [`Zeroable`] trait.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// #[derive(Zeroable)]
+/// pub struct DriverData {
+///     id: i64,
+///     buf_ptr: *mut u8,
+///     len: usize,
+/// }
+/// ```
+#[proc_macro_derive(Zeroable)]
+pub fn derive_zeroable(input: TokenStream) -> TokenStream {
+    zeroable::derive(input.into()).into()
+}

pinned-init-macro/src/pin_data.rs

@@ -3,16 +3,16 @@
 use proc_macro2::{Group, Punct, Spacing, TokenStream, TokenTree};
 use quote::quote;
 
-struct Generics {
-    decl_generics: Vec<TokenTree>,
-    impl_generics: Vec<TokenTree>,
-    ty_generics: Vec<TokenTree>,
+pub(crate) struct Generics {
+    pub(crate) decl_generics: Vec<TokenTree>,
+    pub(crate) impl_generics: Vec<TokenTree>,
+    pub(crate) ty_generics: Vec<TokenTree>,
 }
 
 /// Parses the given `TokenStream` into `Generics` and the rest.
 ///
 /// The generics are not present in the rest, but a where clause might remain.
-fn parse_generics(input: TokenStream) -> (Generics, Vec<TokenTree>) {
+pub(crate) fn parse_generics(input: TokenStream) -> (Generics, Vec<TokenTree>) {
     // The generics with bounds and default values.
     let mut decl_generics = vec![];
     // `impl_generics`, the declared generics with their bounds.

pinned-init-macro/src/zeroable.rs

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: GPL-2.0
+
+use crate::pin_data::{parse_generics, Generics};
+use proc_macro2::{TokenStream, TokenTree};
+use quote::quote;
+
+pub(crate) fn derive(input: TokenStream) -> TokenStream {
+    let (
+        Generics {
+            impl_generics,
+            decl_generics: _,
+            ty_generics,
+        },
+        mut rest,
+    ) = parse_generics(input);
+    // This should be the body of the struct `{...}`.
+    let last = rest.pop();
+    // Now we insert `Zeroable` as a bound for every generic parameter in `impl_generics`.
+    let mut new_impl_generics = Vec::with_capacity(impl_generics.len());
+    // Are we inside of a generic where we want to add `Zeroable`?
+    let mut in_generic = !impl_generics.is_empty();
+    // Have we already inserted `Zeroable`?
+    let mut inserted = false;
+    // Level of `<>` nestings.
+    let mut nested = 0;
+    for tt in impl_generics {
+        match &tt {
+            // If we find a `,`, then we have finished a generic/constant/lifetime parameter.
+            TokenTree::Punct(p) if nested == 0 && p.as_char() == ',' => {
+                if in_generic && !inserted {
+                    new_impl_generics.extend(quote! { : ::pinned_init::Zeroable });
+                }
+                in_generic = true;
+                inserted = false;
+                new_impl_generics.push(tt);
+            }
+            // If we find `'`, then we are entering a lifetime.
+            TokenTree::Punct(p) if nested == 0 && p.as_char() == '\'' => {
+                in_generic = false;
+                new_impl_generics.push(tt);
+            }
+            TokenTree::Punct(p) if nested == 0 && p.as_char() == ':' => {
+                new_impl_generics.push(tt);
+                if in_generic {
+                    new_impl_generics.extend(quote! { ::pinned_init::Zeroable + });
+                    inserted = true;
+                }
+            }
+            TokenTree::Punct(p) if p.as_char() == '<' => {
+                nested += 1;
+                new_impl_generics.push(tt);
+            }
+            TokenTree::Punct(p) if p.as_char() == '>' => {
+                assert!(nested > 0);
+                nested -= 1;
+                new_impl_generics.push(tt);
+            }
+            _ => new_impl_generics.push(tt),
+        }
+    }
+    assert_eq!(nested, 0);
+    if in_generic && !inserted {
+        new_impl_generics.extend(quote! { : ::pinned_init::Zeroable });
+    }
+    quote! {
+        ::pinned_init::__derive_zeroable!(
+            parse_input:
+                @sig(#(#rest)*),
+                @impl_generics(#(#new_impl_generics)*),
+                @ty_generics(#(#ty_generics)*),
+                @body(#last),
+        );
+    }
+}

src/lib.rs

@@ -269,7 +269,7 @@ pub mod __internal;
 #[doc(hidden)]
 pub mod macros;
 
-pub use pinned_init_macro::{pin_data, pinned_drop};
+pub use pinned_init_macro::{pin_data, pinned_drop, Zeroable};
 
 /// Initialize and pin a type directly on the stack.
 ///

src/macros.rs

@@ -1362,3 +1362,38 @@ macro_rules! __init_internal {
         );
     };
 }
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __derive_zeroable {
+    (parse_input:
+        @sig(
+            $(#[$($struct_attr:tt)*])*
+            $vis:vis struct $name:ident
+            $(where $($whr:tt)*)?
+        ),
+        @impl_generics($($impl_generics:tt)*),
+        @ty_generics($($ty_generics:tt)*),
+        @body({
+            $(
+                $(#[$($field_attr:tt)*])*
+                $field:ident : $field_ty:ty
+            ),* $(,)?
+        }),
+    ) => {
+        // SAFETY: Every field type implements `Zeroable` and padding bytes may be zero.
+        #[automatically_derived]
+        unsafe impl<$($impl_generics)*> $crate::Zeroable for $name<$($ty_generics)*>
+        where
+            $($($whr)*)?
+        {}
+        const _: () = {
+            fn assert_zeroable<T: ?::core::marker::Sized + $crate::Zeroable>() {}
+            fn ensure_zeroable<$($impl_generics)*>()
+                where $($($whr)*)?
+            {
+                $(assert_zeroable::<$field_ty>();)*
+            }
+        };
+    };
+}

tests/ui/missing_pin_data.stderr

@@ -12,9 +12,9 @@ error[E0599]: no associated item named `__pin_data` found for struct `Foo` in th
            candidate #1: `HasPinData`
    = note: this error originates in the macro `pin_init` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: there is an associated function `__init_data` with a similar name
-  --> $SRC_DIR/src/lib.rs:618:35
+  --> $SRC_DIR/src/lib.rs:616:35
    |
-618|             @has_data(HasPinData, __init_data),
+616|             @has_data(HasPinData, __init_data),
    |                                   ~~~~~~~~~~~
 
 error: aborting due to 1 previous error

tests/ui/no_pin_data_but_pinned_drop.stderr

@@ -5,9 +5,9 @@ error[E0277]: the trait bound `Foo: HasPinData` is not satisfied
      |                     ^^^ the trait `HasPinData` is not implemented for `Foo`
      |
 note: required by a bound in `PinnedDrop`
-    --> $SRC_DIR/src/lib.rs:1321:30
+    --> $SRC_DIR/src/lib.rs:1319:30
      |
-1321 | pub unsafe trait PinnedDrop: __internal::HasPinData {
+1319 | pub unsafe trait PinnedDrop: __internal::HasPinData {
      |                              ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `PinnedDrop`
 
 error: aborting due to 1 previous error