| use proc_macro2::TokenStream; |
| use quote::{quote, ToTokens}; |
| use syn::{spanned::Spanned, visit_mut::VisitMut, *}; |
| |
| use crate::utils::{parse_as_empty, prepend_underscore_to_self, ReplaceReceiver, SliceExt}; |
| |
| pub(crate) fn attribute(args: &TokenStream, mut input: ItemImpl) -> TokenStream { |
| if let Err(e) = parse_as_empty(args).and_then(|()| parse(&mut input)) { |
| let mut tokens = e.to_compile_error(); |
| if let Type::Path(self_ty) = &*input.self_ty { |
| let (impl_generics, _, where_clause) = input.generics.split_for_impl(); |
| |
| // A dummy impl of `PinnedDrop`. |
| // In many cases, `#[pinned_drop] impl` is declared after `#[pin_project]`. |
| // Therefore, if `pinned_drop` compile fails, you will also get an error |
| // about `PinnedDrop` not being implemented. |
| // This can be prevented to some extent by generating a dummy |
| // `PinnedDrop` implementation. |
| // We already know that we will get a compile error, so this won't |
| // accidentally compile successfully. |
| // |
| // However, if `input.self_ty` is not Type::Path, there is a high possibility that |
| // the type does not exist, so do not generate a dummy impl. |
| tokens.extend(quote! { |
| impl #impl_generics ::pin_project::__private::PinnedDrop for #self_ty |
| #where_clause |
| { |
| unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} |
| } |
| }); |
| } |
| tokens |
| } else { |
| input.into_token_stream() |
| } |
| } |
| |
| fn parse_method(method: &ImplItemMethod) -> Result<()> { |
| fn get_ty_path(ty: &Type) -> Option<&Path> { |
| if let Type::Path(TypePath { qself: None, path }) = ty { Some(path) } else { None } |
| } |
| |
| const INVALID_ARGUMENT: &str = "method `drop` must take an argument `self: Pin<&mut Self>`"; |
| |
| if method.sig.ident != "drop" { |
| return Err(error!( |
| method.sig.ident, |
| "method `{}` is not a member of trait `PinnedDrop", method.sig.ident, |
| )); |
| } |
| |
| if let ReturnType::Type(_, ty) = &method.sig.output { |
| match &**ty { |
| Type::Tuple(ty) if ty.elems.is_empty() => {} |
| _ => return Err(error!(ty, "method `drop` must return the unit type")), |
| } |
| } |
| |
| match method.sig.inputs.len() { |
| 1 => {} |
| 0 => return Err(Error::new(method.sig.paren_token.span, INVALID_ARGUMENT)), |
| _ => return Err(error!(method.sig.inputs, INVALID_ARGUMENT)), |
| } |
| |
| if let Some(FnArg::Typed(pat)) = method.sig.receiver() { |
| // (mut) self: <path> |
| if let Some(path) = get_ty_path(&pat.ty) { |
| let ty = path.segments.last().unwrap(); |
| if let PathArguments::AngleBracketed(args) = &ty.arguments { |
| // (mut) self: (<path>::)<ty><&mut <elem>..> |
| if let Some(GenericArgument::Type(Type::Reference(TypeReference { |
| mutability: Some(_), |
| elem, |
| .. |
| }))) = args.args.first() |
| { |
| // (mut) self: (<path>::)Pin<&mut Self> |
| if args.args.len() == 1 |
| && ty.ident == "Pin" |
| && get_ty_path(elem).map_or(false, |path| path.is_ident("Self")) |
| { |
| if method.sig.unsafety.is_some() { |
| return Err(error!( |
| method.sig.unsafety, |
| "implementing the method `drop` is not unsafe" |
| )); |
| } |
| return Ok(()); |
| } |
| } |
| } |
| } |
| } |
| |
| Err(error!(method.sig.inputs[0], INVALID_ARGUMENT)) |
| } |
| |
| fn parse(item: &mut ItemImpl) -> Result<()> { |
| const INVALID_ITEM: &str = |
| "#[pinned_drop] may only be used on implementation for the `PinnedDrop` trait"; |
| |
| if let Some(attr) = item.attrs.find("pinned_drop") { |
| return Err(error!(attr, "duplicate #[pinned_drop] attribute")); |
| } |
| |
| if let Some((_, path, _)) = &mut item.trait_ { |
| if path.is_ident("PinnedDrop") { |
| *path = parse_quote_spanned! { path.span() => |
| ::pin_project::__private::PinnedDrop |
| }; |
| } else { |
| return Err(error!(path, INVALID_ITEM)); |
| } |
| } else { |
| return Err(error!(item.self_ty, INVALID_ITEM)); |
| } |
| |
| if item.unsafety.is_some() { |
| return Err(error!(item.unsafety, "implementing the trait `PinnedDrop` is not unsafe")); |
| } |
| if item.items.is_empty() { |
| return Err(error!(item, "not all trait items implemented, missing: `drop`")); |
| } |
| |
| match &*item.self_ty { |
| Type::Path(_) => {} |
| ty => { |
| return Err(error!( |
| ty, |
| "implementing the trait `PinnedDrop` on this type is unsupported" |
| )); |
| } |
| } |
| |
| item.items |
| .iter() |
| .enumerate() |
| .try_for_each(|(i, item)| match item { |
| ImplItem::Const(item) => { |
| Err(error!(item, "const `{}` is not a member of trait `PinnedDrop`", item.ident)) |
| } |
| ImplItem::Type(item) => { |
| Err(error!(item, "type `{}` is not a member of trait `PinnedDrop`", item.ident)) |
| } |
| ImplItem::Method(method) => { |
| parse_method(method)?; |
| if i == 0 { |
| Ok(()) |
| } else { |
| Err(error!(method, "duplicate definitions with name `drop`")) |
| } |
| } |
| _ => unreachable!("unexpected ImplItem"), |
| }) |
| .map(|()| expand_item(item)) |
| } |
| |
| // from: |
| // |
| // fn drop(self: Pin<&mut Self>) { |
| // // something |
| // } |
| // |
| // into: |
| // |
| // unsafe fn drop(self: Pin<&mut Self>) { |
| // fn __drop_inner<T>(__self: Pin<&mut Foo<'_, T>>) { |
| // fn __drop_inner() {} |
| // // something |
| // } |
| // __drop_inner(self); |
| // } |
| // |
| fn expand_item(item: &mut ItemImpl) { |
| let method = |
| if let ImplItem::Method(method) = &mut item.items[0] { method } else { unreachable!() }; |
| let mut drop_inner = method.clone(); |
| |
| // `fn drop(mut self: Pin<&mut Self>)` -> `fn __drop_inner<T>(mut __self: Pin<&mut Receiver>)` |
| let ident = Ident::new("__drop_inner", drop_inner.sig.ident.span()); |
| // Add a dummy `__drop_inner` function to prevent users call outer `__drop_inner`. |
| drop_inner.block.stmts.insert(0, parse_quote!(fn #ident() {})); |
| drop_inner.sig.ident = ident; |
| drop_inner.sig.generics = item.generics.clone(); |
| if let FnArg::Typed(arg) = &mut drop_inner.sig.inputs[0] { |
| if let Pat::Ident(ident) = &mut *arg.pat { |
| prepend_underscore_to_self(&mut ident.ident); |
| } |
| } |
| let self_ty = if let Type::Path(ty) = &*item.self_ty { ty } else { unreachable!() }; |
| let mut visitor = ReplaceReceiver(self_ty); |
| visitor.visit_signature_mut(&mut drop_inner.sig); |
| visitor.visit_block_mut(&mut drop_inner.block); |
| |
| // `fn drop(mut self: Pin<&mut Self>)` -> `unsafe fn drop(self: Pin<&mut Self>)` |
| method.sig.unsafety = Some(<Token![unsafe]>::default()); |
| let mut self_token = None; |
| if let FnArg::Typed(arg) = &mut method.sig.inputs[0] { |
| if let Pat::Ident(ident) = &mut *arg.pat { |
| ident.mutability = None; |
| self_token = Some(&ident.ident); |
| } |
| } |
| assert!(self_token.is_some()); |
| |
| method.block.stmts = parse_quote! { |
| #[allow(clippy::needless_pass_by_value)] // This lint does not warn the receiver. |
| #drop_inner |
| __drop_inner(#self_token); |
| }; |
| } |