Remove pin_project! macro and add #[pinned_drop] attribute

README.md

@@ -34,13 +34,13 @@ The current version of pin-project requires Rust 1.33 or later.
 
 ## Examples
 
-[`pin_projectable`] attribute creates a projection struct covering all the fields.
+[`pin_project`] attribute creates a projection struct covering all the fields.
 
 ```rust
-use pin_project::pin_projectable;
+use pin_project::pin_project;
 use std::pin::Pin;
 
-#[pin_projectable]
+#[pin_project]
 struct Foo<T, U> {
     #[pin]
     future: T,
@@ -58,7 +58,7 @@ impl<T, U> Foo<T, U> {
 
 [Code like this will be generated](doc/struct-example-1.md)
 
-[`pin_projectable`]: https://docs.rs/pin-project/0.3/pin_project/attr.pin_projectable.html
+[`pin_project`]: https://docs.rs/pin-project/0.3/pin_project/attr.pin_project.html
 
 ## License
 

pin-project-internal/src/lib.rs

@@ -12,13 +12,14 @@ extern crate proc_macro;
 #[macro_use]
 mod utils;
 
-mod pin_projectable;
+mod pin_project;
+mod pinned_drop;
 #[cfg(feature = "project_attr")]
 mod project;
 
 use proc_macro::TokenStream;
 
-use crate::utils::Nothing;
+use utils::Nothing;
 
 #[cfg(feature = "project_attr")]
 #[proc_macro_attribute]
@@ -27,17 +28,15 @@ pub fn project(args: TokenStream, input: TokenStream) -> TokenStream {
     project::attribute(input.into()).into()
 }
 
-/// This is a doc comment from the defining crate!
-#[proc_macro]
-pub fn pin_project(input: TokenStream) -> TokenStream {
-    pin_projectable::pin_project(input.into()).unwrap_or_else(|e| e.to_compile_error()).into()
+#[proc_macro_attribute]
+pub fn pin_project(args: TokenStream, input: TokenStream) -> TokenStream {
+    pin_project::attribute(args.into(), input.into()).into()
 }
 
 #[proc_macro_attribute]
-pub fn pin_projectable(args: TokenStream, input: TokenStream) -> TokenStream {
-    pin_projectable::attribute(args.into(), input.into())
-        .unwrap_or_else(|e| e.to_compile_error())
-        .into()
+pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {
+    let _: Nothing = syn::parse_macro_input!(args);
+    pinned_drop::attribute(input.into()).into()
 }
 
 #[cfg(feature = "renamed")]

pin-project-internal/src/pin_projectable/enums.rs → pin-project-internal/src/pin_project/enums.rs

@@ -6,13 +6,8 @@ use crate::utils::{proj_ident, VecExt};
 
 use super::*;
 
-pub(super) fn parse(
-    args: TokenStream,
-    mut item: ItemEnum,
-    pinned_drop: Option<ItemFn>,
-) -> Result<TokenStream> {
-    let impl_drop = ImplDrop::new(item.generics.clone(), pinned_drop)?;
-    let mut impl_unpin = ImplUnpin::new(args, &item.generics)?;
+pub(super) fn parse(args: Args, mut item: ItemEnum) -> Result<TokenStream> {
+    let mut impl_unpin = args.impl_unpin(&item.generics);
 
     if item.variants.is_empty() {
         return Err(error!(item, "cannot be implemented for enums without variants"));
@@ -34,6 +29,7 @@ pub(super) fn parse(
     let (proj_item_body, proj_arms) = variants(&mut item, &proj_ident, &mut impl_unpin)?;
 
     let ident = &item.ident;
+    let impl_drop = args.impl_drop(&item.generics);
     let proj_generics = proj_generics(&item.generics);
     let proj_ty_generics = proj_generics.split_for_impl().1;
     let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();

pin-project-internal/src/pin_project/mod.rs

@@ -0,0 +1,254 @@
+use proc_macro2::{Ident, Span, TokenStream};
+use quote::{quote, quote_spanned};
+use syn::{
+    parse::{Parse, ParseStream},
+    Fields, FieldsNamed, FieldsUnnamed, Generics, Index, Item, ItemStruct, Meta, NestedMeta,
+    Result, Type,
+};
+
+use crate::utils::{crate_path, Nothing};
+
+mod enums;
+mod structs;
+
+/// The annotation for pinned type.
+const PIN: &str = "pin";
+
+pub(super) fn attribute(args: TokenStream, input: TokenStream) -> TokenStream {
+    parse(args, input).unwrap_or_else(|e| e.to_compile_error())
+}
+
+#[derive(Clone, Copy)]
+struct Args {
+    pinned_drop: Option<Span>,
+    unsafe_unpin: Option<Span>,
+}
+
+impl Args {
+    fn impl_drop(self, generics: &Generics) -> ImplDrop<'_> {
+        ImplDrop::new(generics, self.pinned_drop)
+    }
+
+    fn impl_unpin(self, generics: &Generics) -> ImplUnpin {
+        ImplUnpin::new(generics, self.unsafe_unpin)
+    }
+}
+
+impl Parse for Args {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let mut pinned_drop = None;
+        let mut unsafe_unpin = None;
+        while !input.is_empty() {
+            let i = input.parse::<Ident>()?;
+            match &*i.to_string() {
+                "PinnedDrop" => pinned_drop = Some(i.span()),
+                "unsafe_Unpin" => unsafe_unpin = Some(i.span()),
+                _ => return Err(error!(i, "an invalid argument was passed")),
+            }
+        }
+        Ok(Self { pinned_drop, unsafe_unpin })
+    }
+}
+
+fn parse(args: TokenStream, input: TokenStream) -> Result<TokenStream> {
+    let args = syn::parse2(args)?;
+    match syn::parse2(input)? {
+        Item::Struct(item) => {
+            let packed_check = ensure_not_packed(&item)?;
+            let mut res = structs::parse(args, item)?;
+            res.extend(packed_check);
+            Ok(res)
+        }
+        Item::Enum(item) => {
+            // We don't need to check for '#[repr(packed)]',
+            // since it does not apply to enums
+            enums::parse(args, item)
+        }
+        item => Err(error!(item, "may only be used on structs or enums")),
+    }
+}
+
+fn ensure_not_packed(item: &ItemStruct) -> Result<TokenStream> {
+    for meta in item.attrs.iter().filter_map(|attr| attr.parse_meta().ok()) {
+        if let Meta::List(l) = meta {
+            if l.ident == "repr" {
+                for repr in l.nested.iter() {
+                    if let NestedMeta::Meta(Meta::Word(w)) = repr {
+                        if w == "packed" {
+                            return Err(error!(
+                                w,
+                                "pin_project may not be used on #[repr(packed)] types"
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Workaround for https://github.com/taiki-e/pin-project/issues/32
+    // Through the tricky use of proc macros, it's possible to bypass
+    // the above check for the 'repr' attribute.
+    // To ensure that it's impossible to use pin projections on a #[repr(packed)][
+    // struct, we generate code like this:
+    //
+    // #[deny(safe_packed_borrows)]
+    // fn enforce_not_packed_for_MyStruct(val: MyStruct) {
+    //  let _field1 = &val.field1;
+    //  let _field2 = &val.field2;
+    //  ...
+    //  let _fieldn = &val.fieldn;
+    // }
+    //
+    // Taking a reference to a packed field is unsafe, amd appplying
+    // #[deny(safe_packed_borrows)] makes sure that doing this without
+    // an 'unsafe' block (which we deliberately do not generate)
+    // is a hard error.
+    //
+    // If the struct ends up having #[repr(packed)] applied somehow,
+    // this will generate an (unfriendly) error message. Under all reasonable
+    // circumstances, we'll detect the #[repr(packed)] attribute, and generate
+    // a much nicer error above.
+    //
+    // There is one exception: If the type of a struct field has a alignemtn of 1
+    // (e.g. u8), it is always safe to take a reference to it, even if the struct
+    // is #[repr(packed)]. If the struct is composed entirely of types of alignent 1,
+    // our generated method will not trigger an error if the struct is #[repr(packed)]
+    //
+    // Fortunately, this should have no observable consequence - #[repr(packed)]
+    // is essentially a no-op on such a type. Nevertheless, we include a test
+    // to ensure that the compiler doesn't ever try to copy the fields on
+    // such a struct when trying to drop it - which is reason we prevent
+    // #[repr(packed)] in the first place
+    let mut field_refs = vec![];
+    match &item.fields {
+        Fields::Named(FieldsNamed { named, .. }) => {
+            for field in named.iter() {
+                let ident = field.ident.as_ref().unwrap();
+                field_refs.push(quote!(&val.#ident;));
+            }
+        }
+        Fields::Unnamed(FieldsUnnamed { unnamed, .. }) => {
+            for (i, _) in unnamed.iter().enumerate() {
+                let index = Index::from(i);
+                field_refs.push(quote!(&val.#index;));
+            }
+        }
+        Fields::Unit => {}
+    }
+
+    let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
+
+    let struct_name = &item.ident;
+    let method_name = Ident::new(
+        &("__pin_project_assert_not_repr_packed_".to_string() + &item.ident.to_string()),
+        Span::call_site(),
+    );
+    let test_fn = quote! {
+        #[deny(safe_packed_borrows)]
+        fn #method_name #impl_generics (val: #struct_name #ty_generics) #where_clause {
+            #(#field_refs)*
+        }
+    };
+    Ok(test_fn)
+}
+
+/// Makes the generics of projected type from the reference of the original generics.
+fn proj_generics(generics: &Generics) -> Generics {
+    let mut generics = generics.clone();
+    generics.params.insert(0, syn::parse_quote!('__a));
+    generics
+}
+
+// =================================================================================================
+// Drop implementation
+
+struct ImplDrop<'a> {
+    generics: &'a Generics,
+    pinned_drop: Option<Span>,
+}
+
+impl<'a> ImplDrop<'a> {
+    fn new(generics: &'a Generics, pinned_drop: Option<Span>) -> Self {
+        Self { generics, pinned_drop }
+    }
+
+    fn build(self, ident: &Ident) -> TokenStream {
+        let (impl_generics, ty_generics, where_clause) = self.generics.split_for_impl();
+
+        if let Some(pinned_drop) = self.pinned_drop {
+            let crate_path = crate_path();
+            let call = quote_spanned! { pinned_drop =>
+                ::#crate_path::__private::UnsafePinnedDrop::pinned_drop(pinned_self)
+            };
+
+            quote! {
+                impl #impl_generics ::core::ops::Drop for #ident #ty_generics #where_clause {
+                    fn drop(&mut self) {
+                        // Safety - we're in 'drop', so we know that 'self' will
+                        // never move again
+                        let pinned_self = unsafe { ::core::pin::Pin::new_unchecked(self) };
+                        // We call `pinned_drop` only once. Since `UnsafePinnedDrop::pinned_drop`
+                        // is an unsafe function and a private API, it is never called again in safe
+                        // code *unless the user uses a maliciously crafted macro*.
+                        unsafe {
+                            #call;
+                        }
+                    }
+                }
+            }
+        } else {
+            quote! {
+                impl #impl_generics ::core::ops::Drop for #ident #ty_generics #where_clause {
+                    fn drop(&mut self) {
+                        // Do nothing. The precense of this Drop
+                        // impl ensures that the user can't provide one of their own
+                    }
+                }
+            }
+        }
+    }
+}
+
+// =================================================================================================
+// conditional Unpin implementation
+
+struct ImplUnpin {
+    generics: Generics,
+    unsafe_unpin: bool,
+}
+
+impl ImplUnpin {
+    fn new(generics: &Generics, unsafe_unpin: Option<Span>) -> Self {
+        let mut generics = generics.clone();
+        if let Some(unsafe_unpin) = unsafe_unpin {
+            let crate_path = crate_path();
+            generics.make_where_clause().predicates.push(
+                syn::parse2(quote_spanned! { unsafe_unpin =>
+                    ::#crate_path::__private::Wrapper<Self>: ::#crate_path::UnsafeUnpin
+                })
+                .unwrap(),
+            );
+        }
+
+        Self { generics, unsafe_unpin: unsafe_unpin.is_some() }
+    }
+
+    fn push(&mut self, ty: &Type) {
+        // We only add bounds for automatically generated impls
+        if !self.unsafe_unpin {
+            self.generics
+                .make_where_clause()
+                .predicates
+                .push(syn::parse_quote!(#ty: ::core::marker::Unpin));
+        }
+    }
+
+    /// Creates `Unpin` implementation.
+    fn build(self, ident: &Ident) -> TokenStream {
+        let (impl_generics, ty_generics, where_clause) = self.generics.split_for_impl();
+        quote! {
+            impl #impl_generics ::core::marker::Unpin for #ident #ty_generics #where_clause {}
+        }
+    }
+}

pin-project-internal/src/pin_projectable/structs.rs → pin-project-internal/src/pin_project/structs.rs

@@ -6,13 +6,8 @@ use crate::utils::{proj_ident, Nothing, VecExt};
 
 use super::*;
 
-pub(super) fn parse(
-    args: TokenStream,
-    mut item: ItemStruct,
-    pinned_drop: Option<ItemFn>,
-) -> Result<TokenStream> {
-    let impl_drop = ImplDrop::new(item.generics.clone(), pinned_drop)?;
-    let mut impl_unpin = ImplUnpin::new(args, &item.generics)?;
+pub(super) fn parse(args: Args, mut item: ItemStruct) -> Result<TokenStream> {
+    let mut impl_unpin = args.impl_unpin(&item.generics);
 
     let (proj_item_body, proj_init_body) = match &mut item.fields {
         Fields::Named(FieldsNamed { named: fields, .. })
@@ -28,6 +23,7 @@ pub(super) fn parse(
     };
 
     let ident = &item.ident;
+    let impl_drop = args.impl_drop(&item.generics);
     let proj_ident = proj_ident(&item.ident);
     let proj_generics = proj_generics(&item.generics);
     let proj_ty_generics = proj_generics.split_for_impl().1;