rust: macros: rewrite #[pinned_drop] using syn

Now that `syn` and `quote` are available in the Kernel use them for the
`#[pinned_drop]` proc-macro attribute 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:

    #[pin_data(PinnedDrop)]
    struct Foo {}

    #[pinned_drop]
    impl PinnedDrop for Foo {}

Prior to this patch, the error reads:

    error: no rules expected the token `)`
       --> samples/rust/rust_minimal.rs:43:1
        |
    43  | #[pinned_drop]
        | ^^^^^^^^^^^^^^ no rules expected this token in macro call
        |
    note: while trying to match `fn`
       --> rust/kernel/init/macros.rs:511:13
        |
    511 |             fn drop($($sig:tt)*) {
        |             ^^
        = note: this error originates in the attribute macro `pinned_drop` (in Nightly builds, run with -Z macro-backtrace for more info)

    error[E0277]: the trait bound `Foo: PinnedDrop` is not satisfied
      --> samples/rust/rust_minimal.rs:40:1
       |
    40 | #[pin_data(PinnedDrop)]
       | ^^^^^^^^^^^^^^^^^^^^^^^
       | |
       | the trait `PinnedDrop` is not implemented for `Foo`
       | required by a bound introduced by this call
       |
       = note: this error originates in the macro `$crate::__pin_data` which comes from the expansion of the attribute macro `pin_data` (in Nightly builds, run with -Z macro-backtrace for more info)

    error: aborting due to 2 previous errors

After this patch, the error reads:

    error: Expected exactly one function in the `PinnedDrop` impl.
      --> samples/rust/rust_minimal.rs:44:25
       |
    44 | impl PinnedDrop for Foo {}
       |                         ^^

    error: aborting due to 1 previous error

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

Author: BennoLossin

rust/kernel/init/macros.rs

@@ -498,31 +498,6 @@
 //! };
 //! ```
 
-/// Creates a `unsafe impl<...> PinnedDrop for $type` block.
-///
-/// See [`PinnedDrop`] for more information.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __pinned_drop {
-    (
-        @impl_sig($($impl_sig:tt)*),
-        @impl_body(
-            $(#[$($attr:tt)*])*
-            fn drop($($sig:tt)*) {
-                $($inner:tt)*
-            }
-        ),
-    ) => {
-        unsafe $($impl_sig)* {
-            // Inherit all attributes and the type/ident tokens for the signature.
-            $(#[$($attr)*])*
-            fn drop($($sig)*, _: $crate::init::__internal::OnlyCallFromDrop) {
-                $($inner)*
-            }
-        }
-    }
-}
-
 /// The internal init macro. Do not call manually!
 ///
 /// This is called by the `{try_}{pin_}init!` macros with various inputs.

rust/macros/lib.rs

@@ -293,7 +293,22 @@ pub fn pin_data(args: TokenStream, input: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_attribute]
 pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {
-    pinned_drop::pinned_drop(args.into(), input.into()).into()
+    parse_macro_input!(args as syn::parse::Nothing);
+    match syn::parse(input.clone()) {
+        Ok(input) => match pinned_drop::pinned_drop(input) {
+            Ok(output) => output,
+            Err((err, impl_)) => {
+                let err = err.into_compile_error();
+                quote! {
+                    #impl_
+                    #err
+                }
+            }
+        }
+        .into(),
+        // Let the compiler handle the error.
+        Err(_) => input,
+    }
 }
 
 /// Paste identifiers together.

rust/macros/pinned_drop.rs

@@ -1,50 +1,112 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use proc_macro2::{TokenStream, TokenTree};
-use quote::quote;
+use proc_macro2::TokenStream;
+use quote::{quote, ToTokens};
+use syn::{parse_quote, Error, ImplItem, ImplItemFn, ItemImpl, Token};
 
-pub(crate) fn pinned_drop(_args: TokenStream, input: TokenStream) -> TokenStream {
-    let mut toks = input.into_iter().collect::<Vec<_>>();
-    assert!(!toks.is_empty());
-    // Ensure that we have an `impl` item.
-    assert!(matches!(&toks[0], TokenTree::Ident(i) if i.to_string() == "impl"));
-    // Ensure that we are implementing `PinnedDrop`.
-    let mut nesting: usize = 0;
-    let mut pinned_drop_idx = None;
-    for (i, tt) in toks.iter().enumerate() {
-        match tt {
-            TokenTree::Punct(p) if p.as_char() == '<' => {
-                nesting += 1;
+struct PinnedDropImpl(ItemImpl, ImplItemFn);
+
+impl TryFrom<ItemImpl> for PinnedDropImpl {
+    type Error = (Error, TokenStream);
+    fn try_from(mut impl_: ItemImpl) -> Result<Self, Self::Error> {
+        let aux_impl = match &impl_ {
+            ItemImpl {
+                attrs,
+                impl_token,
+                generics,
+                trait_: Some((polarity, path, for_)),
+                self_ty,
+                ..
+            } if path.is_ident("PinnedDrop") => {
+                let (impl_generics, _, whr) = generics.split_for_impl();
+                quote! {
+                    #(#attrs)*
+                    unsafe #impl_token #impl_generics #polarity ::kernel::init::PinnedDrop #for_ #self_ty
+                        #whr
+                    {
+                        fn drop(
+                            self: ::core::pin::Pin<&mut Self>,
+                            _: ::kernel::init::__internal::OnlyCallFromDrop,
+                        ) {}
+                    }
+                }
+            }
+            _ => quote!(#impl_),
+        };
+        if impl_.unsafety.is_some() {
+            return Err((
+                Error::new_spanned(
+                    impl_.unsafety,
+                    "The `PinnedDrop` impl must not be `unsafe`.",
+                ),
+                aux_impl,
+            ));
+        }
+        let trait_tokens = match &impl_.trait_ {
+            None => quote!(),
+            Some((None, path, _)) => quote!(#path),
+            Some((Some(not), path, _)) => quote!(#not #path),
+        };
+        match &impl_.trait_ {
+            Some((None, path, _)) if path.is_ident("PinnedDrop") => {}
+            None | Some((None, ..)) => {
+                return Err((
+                    Error::new_spanned(
+                        trait_tokens,
+                        "`#[pinned_drop]` can only be used on `PinnedDrop` impls.",
+                    ),
+                    aux_impl,
+                ));
             }
-            TokenTree::Punct(p) if p.as_char() == '>' => {
-                nesting = nesting.checked_sub(1).unwrap();
-                continue;
+            Some((Some(_), ..)) => {
+                return Err((
+                    Error::new_spanned(
+                        trait_tokens,
+                        "`#[pinned_drop]` can only be used on positive `PinnedDrop` impls.",
+                    ),
+                    aux_impl,
+                ));
             }
-            _ => {}
         }
-        if i >= 1 && nesting == 0 {
-            // Found the end of the generics, this should be `PinnedDrop`.
-            assert!(
-                matches!(tt, TokenTree::Ident(i) if i.to_string() == "PinnedDrop"),
-                "expected 'PinnedDrop', found: '{:?}'",
-                tt
-            );
-            pinned_drop_idx = Some(i);
-            break;
+        if impl_.items.len() != 1 {
+            return Err((
+                Error::new(
+                    impl_.brace_token.span.join(),
+                    "Expected exactly one function in the `PinnedDrop` impl.",
+                ),
+                aux_impl,
+            ));
         }
+        let ImplItem::Fn(drop) = impl_.items.pop().unwrap() else {
+            return Err((
+                Error::new(impl_.brace_token.span.join(), "Expected a function."),
+                aux_impl,
+            ));
+        };
+
+        Ok(Self(impl_, drop))
     }
-    let idx = pinned_drop_idx
-        .unwrap_or_else(|| panic!("Expected an `impl` block implementing `PinnedDrop`."));
-    // Fully qualify the `PinnedDrop`, as to avoid any tampering.
-    toks.splice(idx..idx, quote!(::kernel::init::));
-    // Take the `{}` body and call the declarative macro.
-    if let Some(TokenTree::Group(last)) = toks.pop() {
-        let last = last.stream();
-        quote!(::kernel::__pinned_drop! {
-            @impl_sig(#(#toks)*),
-            @impl_body(#last),
-        })
-    } else {
-        TokenStream::from_iter(toks)
+}
+
+impl ToTokens for PinnedDropImpl {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.0.to_tokens(tokens)
     }
 }
+
+pub(crate) fn pinned_drop(drop_impl: ItemImpl) -> Result<TokenStream, (Error, TokenStream)> {
+    let PinnedDropImpl(mut drop_impl, mut drop) = drop_impl.try_into()?;
+    drop.sig
+        .inputs
+        .push(parse_quote!(_: ::kernel::init::__internal::OnlyCallFromDrop));
+    let span = drop_impl.impl_token.span;
+
+    drop_impl.items.push(ImplItem::Fn(drop));
+    drop_impl.unsafety = Some(Token![unsafe](span));
+    drop_impl.trait_ = Some((
+        None,
+        parse_quote!(::kernel::init::PinnedDrop),
+        Token![for](span),
+    ));
+    Ok(quote! { #drop_impl })
+}