Commit a92f5fd2 authored by Benno Lossin's avatar Benno Lossin
Browse files

rust: pin-init: 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!() }`

Tested-by: default avatarAndreas Hindborg <a.hindborg@kernel.org>
Reviewed-by: default avatarGary Guo <gary@garyguo.net>
Signed-off-by: default avatarBenno Lossin <lossin@kernel.org>
parent 50426bde

rust/pin-init/internal/src/lib.rs

+3 −1
Original line number Diff line number Diff line
@@ -28,7 +28,9 @@ 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()

    let args = parse_macro_input!(args);

    let input = parse_macro_input!(input);

    DiagCtxt::with(|dcx| pinned_drop::pinned_drop(args, input, dcx)).into()

}



#[proc_macro_derive(Zeroable)]

rust/pin-init/internal/src/pinned_drop.rs

+49 −37
Original line number Diff line number Diff line 
// SPDX-License-Identifier: Apache-2.0 OR MIT



use proc_macro2::{TokenStream, TokenTree};

use proc_macro2::TokenStream;

use quote::quote;

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 == "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;

            }

            TokenTree::Punct(p) if p.as_char() == '>' => {

                nesting = nesting.checked_sub(1).unwrap();

                continue;

            }

            _ => {}

        }

        if i >= 1 && nesting == 0 {

            // Found the end of the generics, this should be `PinnedDrop`.

            assert!(

                matches!(tt, TokenTree::Ident(i) if i == "PinnedDrop"),

                "expected 'PinnedDrop', found: '{tt:?}'"

use crate::diagnostics::{DiagCtxt, ErrorGuaranteed};



pub(crate) fn pinned_drop(

    _args: Nothing,

    mut input: ItemImpl,

    dcx: &mut DiagCtxt,

) -> Result<TokenStream, ErrorGuaranteed> {

    if let Some(unsafety) = input.unsafety {

        dcx.error(unsafety, "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 {

                dcx.error(not, "cannot implement `!PinnedDrop`");

            }

            for (seg, expected) in path

                .segments

                .iter()

                .rev()

                .zip(["PinnedDrop", "pin_init", ""])

            {

                if expected.is_empty() || seg.ident != expected {

                    dcx.error(seg, "bad import path for `PinnedDrop`");

                }

                if !seg.arguments.is_none() {

                    dcx.error(&seg.arguments, "unexpected arguments for `PinnedDrop` path");

                }

            }

            *path = parse_quote!(::pin_init::PinnedDrop);

        }

        None => {

            let span = input

                .impl_token

                .span

                .join(input.self_ty.span())

                .unwrap_or(input.impl_token.span);

            dcx.error(

                span,

                "expected `impl ... PinnedDrop for ...`, got inherent impl",

            );

            pinned_drop_idx = Some(i);

            break;

        }

    }

    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));

            }

        }

    }

    Ok(quote!(#input))

}

rust/pin-init/src/macros.rs

+0 −28
Original line number Diff line number Diff line
@@ -503,34 +503,6 @@ 
#[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)]