[RFC PATCH 1/6] rust: pin-init: internal: add syn version of the `Zeroable` derive macro

[Benno Lossin <benno.lossin@proton.me>]

Implement the `Zeroable` derive macro using syn to simplify parsing by
not going through an additional declarative macro.

The syn version is only enabled in the user-space version and disabled
in the kernel until syn becomes available there.

Signed-off-by: Benno Lossin <benno.lossin@proton.me>
---
 rust/pin-init/internal/src/lib.rs          |  5 ++
 rust/pin-init/internal/src/syn_zeroable.rs | 63 ++++++++++++++++++++++
 2 files changed, 68 insertions(+)
 create mode 100644 rust/pin-init/internal/src/syn_zeroable.rs

diff --git a/rust/pin-init/internal/src/lib.rs b/rust/pin-init/internal/src/lib.rs
index babe5e878550..5019efe22662 100644
--- a/rust/pin-init/internal/src/lib.rs
+++ b/rust/pin-init/internal/src/lib.rs
@@ -30,6 +30,11 @@
 mod helpers;
 mod pin_data;
 mod pinned_drop;
+#[cfg(kernel)]
+mod zeroable;
+
+#[cfg(not(kernel))]
+#[path = "syn_zeroable.rs"]
 mod zeroable;
 
 #[proc_macro_attribute]
diff --git a/rust/pin-init/internal/src/syn_zeroable.rs b/rust/pin-init/internal/src/syn_zeroable.rs
new file mode 100644
index 000000000000..90ea8fa63c83
--- /dev/null
+++ b/rust/pin-init/internal/src/syn_zeroable.rs
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{
+    parse_macro_input, parse_quote, Data, DataStruct, DeriveInput, Error, GenericParam, Result,
+    TypeParam, WherePredicate,
+};
+
+pub(crate) fn derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let raw = input.clone().into();
+    do_derive(parse_macro_input!(input as DeriveInput), raw)
+        .unwrap_or_else(|e| e.into_compile_error())
+        .into()
+}
+
+fn do_derive(
+    DeriveInput {
+        ident,
+        mut generics,
+        data,
+        ..
+    }: DeriveInput,
+    raw_input: TokenStream,
+) -> Result<TokenStream> {
+    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);
+    let zeroable_bounds = generics
+        .params
+        .iter()
+        .filter_map(|p| match p {
+            GenericParam::Type(TypeParam { ident, .. }) => {
+                Some(parse_quote!(#ident: ::pin_init::Zeroable))
+            }
+            _ => None,
+        })
+        .collect::<Vec<WherePredicate>>();
+    generics
+        .make_where_clause()
+        .predicates
+        .extend(zeroable_bounds);
+    let (impl_generics, ty_generics, whr) = generics.split_for_impl();
+    Ok(quote! {
+        // SAFETY: Every field type implements `Zeroable` and padding bytes may be zero.
+        #[automatically_derived]
+        unsafe impl #impl_generics ::pin_init::Zeroable for #ident #ty_generics
+            #whr
+        {}
+        const _: () = {
+            fn assert_zeroable<T: ?::core::marker::Sized + ::pin_init::Zeroable>() {}
+            fn ensure_zeroable #impl_generics ()
+                #whr
+            {
+                #(assert_zeroable::<#field_ty>();)*
+            }
+        };
+    })
+}
-- 
2.48.1