rewrite the #[pinned_drop] attribute macro using syn

Rewrite the attribute macro for implementing `PinnedDrop` using `syn`.
Otherwise no functional changes intended aside from improved error
messages on syntactic and semantical errors. For example:

When missing the `drop` function in the implementation, the old error
was:

    error: no rules expected `)`
     --> tests/ui/compile-fail/pinned_drop/no_fn.rs:6:1
      |
    6 | #[pinned_drop]
      | ^^^^^^^^^^^^^^ no rules expected this token in macro call
      |
    note: while trying to match keyword `fn`
     --> src/macros.rs
      |
      |             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)

And the new one is:

    error[E0046]: not all trait items implemented, missing: `drop`
     --> tests/ui/compile-fail/pinned_drop/no_fn.rs:7:1
      |
    7 | impl PinnedDrop for Foo {}
      | ^^^^^^^^^^^^^^^^^^^^^^^ missing `drop` in implementation
      |
      = help: implement the missing item: `fn drop(self: Pin<&mut Self>, _: OnlyCallFromDrop) { todo!() }`

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

Author: BennoLossin

internal/src/lib.rs

@@ -25,7 +25,11 @@ pub fn pin_data(inner: TokenStream, item: TokenStream) -> TokenStream {
 
 #[proc_macro_attribute]
 pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {
-    pinned_drop::pinned_drop(args.into(), input.into()).into()
+    pinned_drop::pinned_drop(
+        parse_macro_input!(args as _),
+        parse_macro_input!(input as _),
+    )
+    .into()
 }
 
 #[proc_macro_derive(Zeroable)]

internal/src/pinned_drop.rs

@@ -1,49 +1,56 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use proc_macro2::{TokenStream, TokenTree};
-use quote::quote;
+use proc_macro2::TokenStream;
+use quote::{quote, quote_spanned};
+use syn::{parse::Nothing, parse_quote, spanned::Spanned, ImplItem, 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;
+pub(crate) fn pinned_drop(_args: Nothing, mut input: ItemImpl) -> TokenStream {
+    let mut errors = vec![];
+    if let Some(unsafety) = input.unsafety {
+        errors.push(quote_spanned! {unsafety.span=>
+            ::core::compile_error!("implementing `PinnedDrop` is safe");
+        });
+    }
+    input.unsafety = Some(Token![unsafe](input.impl_token.span));
+    match &mut input.trait_ {
+        Some((not, path, _for)) => {
+            if let Some(not) = not {
+                errors.push(quote_spanned! {not.span=>
+                    ::core::compile_error!("cannot implement `!PinnedDrop`");
+                });
             }
-            TokenTree::Punct(p) if p.as_char() == '>' => {
-                nesting = nesting.checked_sub(1).unwrap();
-                continue;
+            for (seg, expected) in path
+                .segments
+                .iter()
+                .rev()
+                .zip(["PinnedDrop", "pin_init", ""])
+            {
+                if expected.is_empty() || seg.ident != expected {
+                    errors.push(quote_spanned! {seg.span()=>
+                        ::core::compile_error!("bad import path for `PinnedDrop`");
+                    });
+                }
+                if !seg.arguments.is_none() {
+                    errors.push(quote_spanned! {seg.arguments.span()=>
+                        ::core::compile_error!("unexpected arguments for `PinnedDrop` path");
+                    });
+                }
             }
-            _ => {}
-        }
-        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;
+            *path = parse_quote!(::pin_init::PinnedDrop);
         }
+        None => errors.push(quote_spanned! {input.impl_token.span=>
+            ::core::compile_error!("expected `impl ... PinnedDrop for ...`, got inherent impl");
+        }),
     }
-    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!(::pin_init::));
-    // Take the `{}` body and call the declarative macro.
-    if let Some(TokenTree::Group(last)) = toks.pop() {
-        let last = last.stream();
-        quote!(::pin_init::__pinned_drop! {
-            @impl_sig(#(#toks)*),
-            @impl_body(#last),
-        })
-    } else {
-        TokenStream::from_iter(toks)
+    for item in &mut input.items {
+        if let ImplItem::Fn(fn_item) = item {
+            if fn_item.sig.ident == "drop" {
+                fn_item
+                    .sig
+                    .inputs
+                    .push(parse_quote!(_: ::pin_init::__internal::OnlyCallFromDrop));
+            }
+        }
     }
+    quote!(#(#errors)* #input)
 }

src/macros.rs

@@ -503,34 +503,6 @@ pub use ::macros::paste;
 #[cfg(not(kernel))]
 pub use ::paste::paste;
 
-/// Creates a `unsafe impl<...> PinnedDrop for $type` block.
-///
-/// See [`PinnedDrop`] for more information.
-///
-/// [`PinnedDrop`]: crate::PinnedDrop
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __pinned_drop {
-    (
-        @impl_sig($($impl_sig:tt)*),
-        @impl_body(
-            $(#[$($attr:tt)*])*
-            fn drop($($sig:tt)*) {
-                $($inner:tt)*
-            }
-        ),
-    ) => {
-        // SAFETY: TODO.
-        unsafe $($impl_sig)* {
-            // Inherit all attributes and the type/ident tokens for the signature.
-            $(#[$($attr)*])*
-            fn drop($($sig)*, _: $crate::__internal::OnlyCallFromDrop) {
-                $($inner)*
-            }
-        }
-    }
-}
-
 /// This macro first parses the struct definition such that it separates pinned and not pinned
 /// fields. Afterwards it declares the struct and implement the `PinData` trait safely.
 #[doc(hidden)]

tests/ui/compile-fail/init/wrong_generics2.stderr

@@ -12,7 +12,7 @@ help: you might have forgotten to add the struct literal inside the block
  --> src/macros.rs
   |
   ~                 ::core::ptr::write($slot, $t { SomeStruct {
-  |2                    $($acc)*
+  |4                    $($acc)*
   ~                 } });
   |
 

tests/ui/compile-fail/pinned_drop/no_fn.stderr

@@ -1,12 +1,7 @@
-error: no rules expected `)`
- --> tests/ui/compile-fail/pinned_drop/no_fn.rs:6:1
+error[E0046]: not all trait items implemented, missing: `drop`
+ --> tests/ui/compile-fail/pinned_drop/no_fn.rs:7:1
   |
-6 | #[pinned_drop]
-  | ^^^^^^^^^^^^^^ no rules expected this token in macro call
+7 | impl PinnedDrop for Foo {}
+  | ^^^^^^^^^^^^^^^^^^^^^^^ missing `drop` in implementation
   |
-note: while trying to match keyword `fn`
- --> src/macros.rs
-  |
-  |             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)
+  = help: implement the missing item: `fn drop(self: Pin<&mut Self>, _: OnlyCallFromDrop) { todo!() }`

tests/ui/compile-fail/pinned_drop/unexpected_additional_item.rs

@@ -1,4 +1,5 @@
 use pin_init::*;
+use std::pin::Pin;
 
 #[pin_data(PinnedDrop)]
 struct Foo {}

tests/ui/compile-fail/pinned_drop/unexpected_additional_item.stderr

@@ -1,11 +1,5 @@
-error: no rules expected keyword `const`
-  --> tests/ui/compile-fail/pinned_drop/unexpected_additional_item.rs:10:5
+error[E0438]: const `BAZ` is not a member of trait `pin_init::PinnedDrop`
+  --> tests/ui/compile-fail/pinned_drop/unexpected_additional_item.rs:11:5
    |
-10 |     const BAZ: usize = 0;
-   |     ^^^^^ no rules expected this token in macro call
-   |
-note: while trying to match `)`
-  --> src/macros.rs
-   |
-   |         ),
-   |         ^
+11 |     const BAZ: usize = 0;
+   |     ^^^^^^^^^^^^^^^^^^^^^ not a member of trait `pin_init::PinnedDrop`

tests/ui/compile-fail/pinned_drop/unexpected_generics.stderr

@@ -1,13 +1,5 @@
-error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
-  --> tests/ui/compile-fail/pinned_drop/unexpected_generics.rs:10:9
+error: unexpected arguments for `PinnedDrop` path
+  --> tests/ui/compile-fail/pinned_drop/unexpected_generics.rs:10:19
    |
 10 | impl<T> PinnedDrop<T> for Foo<T> {
-   |         ^^^^^^^^^^--- help: remove the unnecessary generics
-   |         |
-   |         expected 0 generic arguments
-   |
-note: trait defined here, with 0 generic parameters
-  --> src/lib.rs
-   |
-   | pub unsafe trait PinnedDrop: __internal::HasPinData {
-   |                  ^^^^^^^^^^
+   |                   ^^^

tests/ui/compile-fail/pinned_drop/unexpected_item.stderr

@@ -1,11 +1,13 @@
-error: no rules expected keyword `const`
+error[E0438]: const `BAZ` is not a member of trait `pin_init::PinnedDrop`
  --> tests/ui/compile-fail/pinned_drop/unexpected_item.rs:8:5
   |
 8 |     const BAZ: usize = 0;
-  |     ^^^^^ no rules expected this token in macro call
+  |     ^^^^^^^^^^^^^^^^^^^^^ not a member of trait `pin_init::PinnedDrop`
+
+error[E0046]: not all trait items implemented, missing: `drop`
+ --> tests/ui/compile-fail/pinned_drop/unexpected_item.rs:7:1
   |
-note: while trying to match keyword `fn`
- --> src/macros.rs
+7 | impl PinnedDrop for Foo {
+  | ^^^^^^^^^^^^^^^^^^^^^^^ missing `drop` in implementation
   |
-  |             fn drop($($sig:tt)*) {
-  |             ^^
+  = help: implement the missing item: `fn drop(self: Pin<&mut Self>, _: OnlyCallFromDrop) { todo!() }`