rust: macros: rewrite Zeroable derive macro using syn

Now that `syn` and `quote` are available in the Kernel use them for the
`Zeroable` derive macro instead of the current hybrid
proc-macro/declarative approach.

Proc-macros written using `syn` are a lot more readable and thus easier
to maintain than convoluted declarative macros. An additional advantage
of `syn` is the improved error reporting, here is an example:

    #[derive(Zeroable)]
    enum Foo {
        A,
        B
    }

Prior to this patch, the error reads:

    error: no rules expected the token `enum`
        --> samples/rust/rust_minimal.rs:41:1
         |
    41   | enum Foo {
         | ^^^^ no rules expected this token in macro call
         |
    note: while trying to match `struct`
        --> rust/kernel/init/macros.rs:1373:22
         |
    1373 |             $vis:vis struct $name:ident
         |                      ^^^^^^

    error: aborting due to 1 previous error

After this patch, the error reads:

    error: `Zeroable` can only be derived for structs.
      --> samples/rust/rust_minimal.rs:41:1
       |
    41 | / enum Foo {
    42 | |     A,
    43 | |     B
    44 | | }
       | |_^

    error: aborting due to 1 previous error

Signed-off-by: Benno Lossin <[email protected]>

Author: BennoLossin

rust/kernel/init/macros.rs

@@ -1363,38 +1363,3 @@ 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::init::Zeroable for $name<$($ty_generics)*>
-        where
-            $($($whr)*)?
-        {}
-        const _: () = {
-            fn assert_zeroable<T: ?::core::marker::Sized + $crate::init::Zeroable>() {}
-            fn ensure_zeroable<$($impl_generics)*>()
-                where $($($whr)*)?
-            {
-                $(assert_zeroable::<$field_ty>();)*
-            }
-        };
-    };
-}

rust/macros/lib.rs

@@ -13,7 +13,7 @@ mod zeroable;
 
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::parse_macro_input;
+use syn::{parse_macro_input, DeriveInput};
 
 /// Declares a kernel module.
 ///
@@ -426,5 +426,11 @@ pub fn paste(input: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_derive(Zeroable)]
 pub fn derive_zeroable(input: TokenStream) -> TokenStream {
-    zeroable::derive(input.into()).into()
+    let raw_input = input.clone().into();
+    let input = parse_macro_input!(input as DeriveInput);
+    match zeroable::derive(input, raw_input) {
+        Ok(output) => output,
+        Err(err) => err.into_compile_error(),
+    }
+    .into()
 }

rust/macros/zeroable.rs

@@ -1,74 +1,57 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use crate::helpers::{parse_generics, Generics};
-use proc_macro2::{TokenStream, TokenTree};
+use proc_macro2::TokenStream;
 use quote::quote;
+use syn::{
+    parse_quote, Data, DataStruct, DeriveInput, Error, GenericParam, Result, TypeParam,
+    WherePredicate,
+};
 
-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! { : ::kernel::init::Zeroable });
-                }
-                in_generic = true;
-                inserted = false;
-                new_impl_generics.push(tt);
+pub(crate) fn derive(
+    DeriveInput {
+        ident,
+        mut generics,
+        data,
+        ..
+    }: DeriveInput,
+    raw_input: TokenStream,
+) -> Result<TokenStream> {
+    let zeroable_bounds = generics
+        .params
+        .iter()
+        .filter_map(|p| match p {
+            GenericParam::Type(t) => Some(t),
+            _ => None,
+        })
+        .map(|TypeParam { ident, .. }| {
+            parse_quote! { #ident: ::kernel::init::Zeroable, }
+        })
+        .collect::<Vec<WherePredicate>>();
+    generics
+        .make_where_clause()
+        .predicates
+        .extend(zeroable_bounds);
+    let (impl_g, type_g, whr) = generics.split_for_impl();
+    let Data::Struct(DataStruct { fields, .. }) = data else {
+        return Err(Error::new_spanned(
+            raw_input,
+            "`Zeroable` can only be derived for structs.",
+        ));
+    };
+    let field_ty = fields.iter().map(|f| &f.ty);
+    Ok(quote! {
+        // SAFETY: Every field type implements `Zeroable` and padding bytes may be zero.
+        #[automatically_derived]
+        unsafe impl #impl_g ::kernel::init::Zeroable for #ident #type_g
+            #whr
+        {}
+        const _: () = {
+            fn assert_zeroable<T: ?::core::marker::Sized + ::kernel::init::Zeroable>() {}
+            fn ensure_zeroable #impl_g ()
+                #whr
+            {
+                #(assert_zeroable::<#field_ty>();)*
             }
-            // 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! { ::kernel::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! { : ::kernel::init::Zeroable });
-    }
-    quote! {
-        ::kernel::__derive_zeroable!(
-            parse_input:
-                @sig(#(#rest)*),
-                @impl_generics(#(#new_impl_generics)*),
-                @ty_generics(#(#ty_generics)*),
-                @body(#last),
-        );
-    }
+        };
+    })
 }