Move automatic generation of Unpin implementation to proc-macro-derive

To generate the correct `Unpin` implementation, we need to collect the
types of the pinned fields. However, since proc-macro-attribute is
applied before cfg, we cannot be collecting field types at this timing.
So instead of generating the `Unpin` implementation here, we need to
delegate automatic generation of the `Unpin` implementation to
proc-macro-derive.

Author: taiki-e

azure-pipelines.yml

@@ -39,6 +39,7 @@ jobs:
   parameters:
     toolchain: nightly
     name: nightly
+    cross: true
 
 - job: compiletest
   pool:
@@ -49,7 +50,9 @@ jobs:
         toolchain: nightly
     - script: |
         cargo clean
-        RUSTFLAGS='--cfg compiletest --cfg pin_project_show_unpin_struct' cargo test -p pin-project --all-features --test compiletest
+        cargo test -p pin-project --all-features --test compiletest
+      env:
+        RUSTFLAGS: -Dwarnings --cfg compiletest --cfg pin_project_show_unpin_struct
       displayName: compiletest
 
 - job: clippy
@@ -122,5 +125,7 @@ jobs:
       parameters:
         toolchain: nightly
     - script: |
-        RUSTDOCFLAGS=-Dwarnings cargo doc --no-deps --all --all-features
+        cargo doc --no-deps --all --all-features
+      env:
+        RUSTDOCFLAGS: -Dwarnings
       displayName: cargo doc

ci/azure-test.yml

@@ -1,11 +1,19 @@
 parameters:
-  vmImage: ubuntu-16.04
   cmd: test
 
 jobs:
 - job: ${{ parameters.name }}
+  strategy:
+    matrix:
+      Linux:
+        vmImage: ubuntu-16.04
+      ${{ if parameters.cross }}:
+        MacOS:
+          vmImage: macOS-10.13
+        Windows:
+          vmImage: vs2017-win2016
   pool:
-    vmImage: ${{ parameters.vmImage }}
+    vmImage: $(vmImage)
 
   steps:
     - template: azure-install-rust.yml

compiletest.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+# A script to run compile tests with the same condition that pin-project executes with CI.
+
+rm -rf target/debug/deps/libpin_project* && RUSTFLAGS='--cfg compiletest --cfg pin_project_show_unpin_struct' cargo test -p pin-project --all-features --test compiletest

pin-project-internal/src/lib.rs

@@ -333,7 +333,8 @@ use syn::parse::Nothing;
 /// [`pinned_drop`]: ./attr.pinned_drop.html
 #[proc_macro_attribute]
 pub fn pin_project(args: TokenStream, input: TokenStream) -> TokenStream {
-    pin_project::attribute(args.into(), input.into()).into()
+    let input = syn::parse_macro_input!(input);
+    pin_project::attribute(args.into(), input).into()
 }
 
 // TODO: Move this doc into pin-project crate when https://github.com/rust-lang/rust/pull/62855 merged.
@@ -372,7 +373,8 @@ pub fn pin_project(args: TokenStream, input: TokenStream) -> TokenStream {
 #[proc_macro_attribute]
 pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {
     let _: Nothing = syn::parse_macro_input!(args);
-    pinned_drop::attribute(input.into()).into()
+    let input = syn::parse_macro_input!(input);
+    pinned_drop::attribute(&input).into()
 }
 
 // TODO: Move this doc into pin-project crate when https://github.com/rust-lang/rust/pull/62855 merged.
@@ -493,7 +495,15 @@ pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {
 #[proc_macro_attribute]
 pub fn project(args: TokenStream, input: TokenStream) -> TokenStream {
     let _: Nothing = syn::parse_macro_input!(args);
-    project::attribute(input.into()).into()
+    let input = syn::parse_macro_input!(input);
+    project::attribute(input).into()
+}
+
+#[doc(hidden)]
+#[proc_macro_derive(__PinProjectAutoImplUnpin, attributes(pin))]
+pub fn derive_unpin(input: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(input);
+    pin_project::derive(input).into()
 }
 
 #[cfg(feature = "renamed")]

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

@@ -1,16 +1,16 @@
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote, ToTokens};
-use syn::{parse::Nothing, Field, Fields, FieldsNamed, FieldsUnnamed, ItemEnum, Result, Variant};
+use syn::{Field, Fields, FieldsNamed, FieldsUnnamed, ItemEnum, Result, Variant};
 
-use crate::utils::VecExt;
+use crate::utils::collect_cfg;
 
-use super::{Context, PIN};
+use super::Context;
 
 pub(super) fn parse(cx: &mut Context, mut item: ItemEnum) -> Result<TokenStream> {
     if item.variants.is_empty() {
-        return Err(error!(
-            item,
-            "#[pin_project] attribute may not be used on enums without variants"
+        return Err(syn::Error::new(
+            item.brace_token.span,
+            "#[pin_project] attribute may not be used on enums without variants",
         ));
     }
     let has_field = item.variants.iter().try_fold(false, |has_field, v| {
@@ -62,17 +62,22 @@ pub(super) fn parse(cx: &mut Context, mut item: ItemEnum) -> Result<TokenStream>
 fn variants(cx: &mut Context, item: &mut ItemEnum) -> Result<(Vec<TokenStream>, Vec<TokenStream>)> {
     let mut proj_variants = Vec::with_capacity(item.variants.len());
     let mut proj_arms = Vec::with_capacity(item.variants.len());
-    for Variant { fields, ident, .. } in &mut item.variants {
+    for Variant { attrs, fields, ident, .. } in &mut item.variants {
         let (proj_pat, proj_body, proj_fields) = match fields {
             Fields::Unnamed(fields) => unnamed(cx, fields)?,
             Fields::Named(fields) => named(cx, fields)?,
             Fields::Unit => (TokenStream::new(), TokenStream::new(), TokenStream::new()),
         };
+        let cfg = collect_cfg(attrs);
         let Context { orig_ident, proj_ident, .. } = &cx;
-        let proj_arm = quote!(#orig_ident::#ident #proj_pat => #proj_ident::#ident #proj_body );
-        let proj_variant = quote!(#ident #proj_fields);
-        proj_arms.push(proj_arm);
-        proj_variants.push(proj_variant);
+        proj_variants.push(quote! {
+            #(#cfg)* #ident #proj_fields
+        });
+        proj_arms.push(quote! {
+            #(#cfg)* #orig_ident::#ident #proj_pat => {
+                #proj_ident::#ident #proj_body
+            }
+        });
     }
 
     Ok((proj_variants, proj_arms))
@@ -86,18 +91,27 @@ fn named(
     let mut proj_body = Vec::with_capacity(fields.len());
     let mut proj_fields = Vec::with_capacity(fields.len());
     for Field { attrs, ident, ty, .. } in fields {
-        if let Some(attr) = attrs.find_remove(PIN) {
-            let _: Nothing = syn::parse2(attr.tokens)?;
-            cx.push_unpin_bounds(ty.clone());
+        let cfg = collect_cfg(attrs);
+        if cx.find_pin_attr(attrs)? {
             let lifetime = &cx.lifetime;
-            proj_fields.push(quote!(#ident: ::core::pin::Pin<&#lifetime mut #ty>));
-            proj_body.push(quote!(#ident: ::core::pin::Pin::new_unchecked(#ident)));
+            proj_fields.push(quote! {
+                #(#cfg)* #ident: ::core::pin::Pin<&#lifetime mut #ty>
+            });
+            proj_body.push(quote! {
+                #(#cfg)* #ident: ::core::pin::Pin::new_unchecked(#ident)
+            });
         } else {
             let lifetime = &cx.lifetime;
-            proj_fields.push(quote!(#ident: &#lifetime mut #ty));
-            proj_body.push(quote!(#ident));
+            proj_fields.push(quote! {
+                #(#cfg)* #ident: &#lifetime mut #ty
+            });
+            proj_body.push(quote! {
+                #(#cfg)* #ident: #ident
+            });
         }
-        proj_pat.push(ident);
+        proj_pat.push(quote! {
+            #(#cfg)* #ident
+        });
     }
 
     let proj_pat = quote!({ #(#proj_pat),* });
@@ -114,19 +128,34 @@ fn unnamed(
     let mut proj_body = Vec::with_capacity(fields.len());
     let mut proj_fields = Vec::with_capacity(fields.len());
     for (i, Field { attrs, ty, .. }) in fields.iter_mut().enumerate() {
-        let x = format_ident!("_x{}", i);
-        if let Some(attr) = attrs.find_remove(PIN) {
-            let _: Nothing = syn::parse2(attr.tokens)?;
-            cx.push_unpin_bounds(ty.clone());
+        let id = format_ident!("_x{}", i);
+        let cfg = collect_cfg(attrs);
+        if !cfg.is_empty() {
+            return Err(error!(
+                cfg.first(),
+                "`cfg` attributes on the field of tuple variants are not supported"
+            ));
+        }
+        if cx.find_pin_attr(attrs)? {
             let lifetime = &cx.lifetime;
-            proj_fields.push(quote!(::core::pin::Pin<&#lifetime mut #ty>));
-            proj_body.push(quote!(::core::pin::Pin::new_unchecked(#x)));
+            proj_fields.push(quote! {
+                ::core::pin::Pin<&#lifetime mut #ty>
+            });
+            proj_body.push(quote! {
+                ::core::pin::Pin::new_unchecked(#id)
+            });
         } else {
             let lifetime = &cx.lifetime;
-            proj_fields.push(quote!(&#lifetime mut #ty));
-            proj_body.push(quote!(#x));
+            proj_fields.push(quote! {
+                &#lifetime mut #ty
+            });
+            proj_body.push(quote! {
+                #id
+            });
         }
-        proj_pat.push(x);
+        proj_pat.push(quote! {
+            #id
+        });
     }
 
     let proj_pat = quote!((#(#proj_pat),*));

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

@@ -1,10 +1,10 @@
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
-use syn::{parse::Nothing, Field, Fields, FieldsNamed, FieldsUnnamed, Index, ItemStruct, Result};
+use syn::{Field, Fields, FieldsNamed, FieldsUnnamed, Index, ItemStruct, Result};
 
-use crate::utils::VecExt;
+use crate::utils::collect_cfg;
 
-use super::{Context, PIN};
+use super::Context;
 
 pub(super) fn parse(cx: &mut Context, mut item: ItemStruct) -> Result<TokenStream> {
     let (proj_fields, proj_init) = match &mut item.fields {
@@ -19,7 +19,7 @@ pub(super) fn parse(cx: &mut Context, mut item: ItemStruct) -> Result<TokenStrea
         }
         Fields::Unit => {
             return Err(error!(
-                item,
+                item.ident,
                 "#[pin_project] attribute may not be used on structs with units"
             ));
         }
@@ -61,16 +61,23 @@ fn named(
     let mut proj_fields = Vec::with_capacity(fields.len());
     let mut proj_init = Vec::with_capacity(fields.len());
     for Field { attrs, ident, ty, .. } in fields {
-        if let Some(attr) = attrs.find_remove(PIN) {
-            let _: Nothing = syn::parse2(attr.tokens)?;
-            cx.push_unpin_bounds(ty.clone());
+        let cfg = collect_cfg(attrs);
+        if cx.find_pin_attr(attrs)? {
             let lifetime = &cx.lifetime;
-            proj_fields.push(quote!(#ident: ::core::pin::Pin<&#lifetime mut #ty>));
-            proj_init.push(quote!(#ident: ::core::pin::Pin::new_unchecked(&mut this.#ident)));
+            proj_fields.push(quote! {
+                #(#cfg)* #ident: ::core::pin::Pin<&#lifetime mut #ty>
+            });
+            proj_init.push(quote! {
+                #(#cfg)* #ident: ::core::pin::Pin::new_unchecked(&mut this.#ident)
+            });
         } else {
             let lifetime = &cx.lifetime;
-            proj_fields.push(quote!(#ident: &#lifetime mut #ty));
-            proj_init.push(quote!(#ident: &mut this.#ident));
+            proj_fields.push(quote! {
+                #(#cfg)* #ident: &#lifetime mut #ty
+            });
+            proj_init.push(quote! {
+                #(#cfg)* #ident: &mut this.#ident
+            });
         }
     }
 
@@ -85,18 +92,31 @@ fn unnamed(
 ) -> Result<(TokenStream, TokenStream)> {
     let mut proj_fields = Vec::with_capacity(fields.len());
     let mut proj_init = Vec::with_capacity(fields.len());
-    for (i, Field { attrs, ty, .. }) in fields.iter_mut().enumerate() {
-        let i = Index::from(i);
-        if let Some(attr) = attrs.find_remove(PIN) {
-            let _: Nothing = syn::parse2(attr.tokens)?;
-            cx.push_unpin_bounds(ty.clone());
+    for (index, Field { attrs, ty, .. }) in fields.iter_mut().enumerate() {
+        let index = Index::from(index);
+        let cfg = collect_cfg(attrs);
+        if !cfg.is_empty() {
+            return Err(error!(
+                cfg.first(),
+                "`cfg` attributes on the field of tuple structs are not supported"
+            ));
+        }
+        if cx.find_pin_attr(attrs)? {
             let lifetime = &cx.lifetime;
-            proj_fields.push(quote!(::core::pin::Pin<&#lifetime mut #ty>));
-            proj_init.push(quote!(::core::pin::Pin::new_unchecked(&mut this.#i)));
+            proj_fields.push(quote! {
+                ::core::pin::Pin<&#lifetime mut #ty>
+            });
+            proj_init.push(quote! {
+                ::core::pin::Pin::new_unchecked(&mut this.#index)
+            });
         } else {
             let lifetime = &cx.lifetime;
-            proj_fields.push(quote!(&#lifetime mut #ty));
-            proj_init.push(quote!(&mut this.#i));
+            proj_fields.push(quote! {
+                &#lifetime mut #ty
+            });
+            proj_init.push(quote! {
+                &mut this.#index
+            });
         }
     }
 

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

@@ -7,7 +7,7 @@ use syn::{
 
 use crate::utils::crate_path;
 
-pub(super) fn attribute(input: TokenStream) -> TokenStream {
+pub(crate) fn attribute(input: &ItemFn) -> TokenStream {
     parse(input).unwrap_or_else(|e| e.to_compile_error())
 }
 
@@ -34,8 +34,7 @@ fn parse_arg(arg: &FnArg) -> Result<&Type> {
     Err(error!(arg, "#[pinned_drop] function must take a argument `Pin<&mut Type>`"))
 }
 
-fn parse(input: TokenStream) -> Result<TokenStream> {
-    let item: ItemFn = syn::parse2(input)?;
+fn parse(item: &ItemFn) -> Result<TokenStream> {
     if let ReturnType::Type(_, ty) = &item.sig.output {
         match &**ty {
             Type::Tuple(TypeTuple { elems, .. }) if elems.is_empty() => {}

pin-project-internal/src/pinned_drop.rs

@@ -11,12 +11,11 @@ use crate::utils::{proj_generics, proj_ident, proj_lifetime_name, VecExt, DEFAUL
 /// The attribute name.
 const NAME: &str = "project";
 
-pub(super) fn attribute(input: TokenStream) -> TokenStream {
+pub(crate) fn attribute(input: Stmt) -> TokenStream {
     parse(input).unwrap_or_else(|e| e.to_compile_error())
 }
 
-fn parse(input: TokenStream) -> Result<TokenStream> {
-    let mut stmt = syn::parse2(input)?;
+fn parse(mut stmt: Stmt) -> Result<TokenStream> {
     match &mut stmt {
         Stmt::Expr(Expr::Match(expr)) | Stmt::Semi(Expr::Match(expr), _) => {
             Context::default().replace_expr_match(expr)

pin-project-internal/src/project.rs

@@ -58,13 +58,21 @@ pub(crate) fn proj_generics(generics: &mut Generics, lifetime: Lifetime) {
     );
 }
 
+pub(crate) fn collect_cfg(attrs: &[Attribute]) -> Vec<Attribute> {
+    attrs.iter().filter(|attr| attr.path.is_ident("cfg")).cloned().collect()
+}
+
 pub(crate) trait VecExt {
+    fn position(&self, ident: &str) -> Option<usize>;
     fn find_remove(&mut self, ident: &str) -> Option<Attribute>;
 }
 
 impl VecExt for Vec<Attribute> {
+    fn position(&self, ident: &str) -> Option<usize> {
+        self.iter().position(|attr| attr.path.is_ident(ident))
+    }
     fn find_remove(&mut self, ident: &str) -> Option<Attribute> {
-        self.iter().position(|attr| attr.path.is_ident(ident)).map(|i| self.remove(i))
+        self.position(ident).map(|i| self.remove(i))
     }
 }
 

pin-project-internal/src/utils.rs

@@ -124,6 +124,9 @@ pub mod __private {
     use super::UnsafeUnpin;
     use core::pin::Pin;
 
+    #[doc(hidden)]
+    pub use pin_project_internal::__PinProjectAutoImplUnpin;
+
     // This is an internal helper trait used by `pin-project-internal`.
     // This allows us to force an error if the user tries to provide
     // a regular `Drop` impl when they specify the `PinnedDrop` argument.

src/lib.rs

@@ -0,0 +1,150 @@
+#![warn(unsafe_code)]
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+// Refs: https://doc.rust-lang.org/reference/attributes.html
+
+use core::marker::PhantomPinned;
+use pin_project::pin_project;
+
+#[cfg(all(unix, target_os = "macos"))]
+pub struct MacOS;
+#[cfg(all(unix, not(target_os = "macos")))]
+pub struct Linux;
+#[cfg(windows)]
+pub struct Windows;
+
+// Using `PhantomPinned: Unpin` without #![feature(trivial_bounds)] will result in an error.
+// Use this type to check that `cfg(any())` is working properly.
+pub struct Any(PhantomPinned);
+
+#[test]
+fn struct_() {
+    #[pin_project]
+    pub struct SameName {
+        #[cfg(all(unix, target_os = "macos"))]
+        #[pin]
+        inner: MacOS,
+        #[cfg(all(unix, not(target_os = "macos")))]
+        #[pin]
+        inner: Linux,
+        #[cfg(windows)]
+        #[pin]
+        inner: Windows,
+        #[cfg(any())]
+        #[pin]
+        any: Any,
+    }
+
+    #[cfg(all(unix, target_os = "macos"))]
+    let _x = SameName { inner: MacOS };
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let _x = SameName { inner: Linux };
+    #[cfg(windows)]
+    let _x = SameName { inner: Windows };
+
+    #[pin_project]
+    pub struct DifferentName {
+        #[cfg(all(unix, target_os = "macos"))]
+        #[pin]
+        m: MacOS,
+        #[cfg(all(unix, not(target_os = "macos")))]
+        #[pin]
+        l: Linux,
+        #[cfg(windows)]
+        #[pin]
+        w: Windows,
+        #[cfg(any())]
+        #[pin]
+        a: Any,
+    }
+
+    #[cfg(all(unix, target_os = "macos"))]
+    let _x = DifferentName { m: MacOS };
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let _x = DifferentName { l: Linux };
+    #[cfg(windows)]
+    let _x = DifferentName { w: Windows };
+}
+
+#[test]
+fn enum_() {
+    #[pin_project]
+    pub enum Variant {
+        #[cfg(all(unix, target_os = "macos"))]
+        Inner(#[pin] MacOS),
+        #[cfg(all(unix, not(target_os = "macos")))]
+        Inner(#[pin] Linux),
+        #[cfg(windows)]
+        Inner(#[pin] Windows),
+
+        #[cfg(all(unix, target_os = "macos"))]
+        MacOS(#[pin] MacOS),
+        #[cfg(all(unix, not(target_os = "macos")))]
+        Linux(#[pin] Linux),
+        #[cfg(windows)]
+        Windows(#[pin] Windows),
+        #[cfg(any())]
+        Any(#[pin] Any),
+    }
+
+    #[cfg(all(unix, target_os = "macos"))]
+    let _x = Variant::Inner(MacOS);
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let _x = Variant::Inner(Linux);
+    #[cfg(windows)]
+    let _x = Variant::Inner(Windows);
+
+    #[cfg(all(unix, target_os = "macos"))]
+    let _x = Variant::MacOS(MacOS);
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let _x = Variant::Linux(Linux);
+    #[cfg(windows)]
+    let _x = Variant::Windows(Windows);
+
+    #[pin_project]
+    pub enum Field {
+        SameName {
+            #[cfg(all(unix, target_os = "macos"))]
+            #[pin]
+            inner: MacOS,
+            #[cfg(all(unix, not(target_os = "macos")))]
+            #[pin]
+            inner: Linux,
+            #[cfg(windows)]
+            #[pin]
+            inner: Windows,
+            #[cfg(any())]
+            #[pin]
+            any: Any,
+        },
+        DifferentName {
+            #[cfg(all(unix, target_os = "macos"))]
+            #[pin]
+            m: MacOS,
+            #[cfg(all(unix, not(target_os = "macos")))]
+            #[pin]
+            l: Linux,
+            #[cfg(windows)]
+            #[pin]
+            w: Windows,
+            #[cfg(any())]
+            #[pin]
+            any: Any,
+        },
+    }
+
+    #[cfg(all(unix, target_os = "macos"))]
+    let _x = Field::SameName { inner: MacOS };
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let _x = Field::SameName { inner: Linux };
+    #[cfg(windows)]
+    let _x = Field::SameName { inner: Windows };
+
+    #[cfg(all(unix, target_os = "macos"))]
+    let _x = Field::DifferentName { m: MacOS };
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let _x = Field::DifferentName { l: Linux };
+    #[cfg(windows)]
+    let _x = Field::DifferentName { w: Windows };
+}

tests/cfg.rs

@@ -1,4 +1,3 @@
-#![no_std]
 #![warn(unsafe_code)]
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 #![allow(dead_code)]

tests/pinned_drop.rs

@@ -1,5 +1,4 @@
 #![cfg(feature = "project_attr")]
-#![no_std]
 #![warn(unsafe_code)]
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 #![allow(dead_code)]

tests/project.rs

@@ -1,5 +1,4 @@
 #![cfg(feature = "project_attr")]
-#![no_std]
 #![warn(unsafe_code)]
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 #![allow(dead_code)]

tests/project_nightly.rs

@@ -0,0 +1,15 @@
+// compile-fail
+
+use pin_project::pin_project;
+
+#[pin_project]
+pub struct TupleStruct(
+    #[cfg(unix)] //~ ERROR `cfg` attributes on the field of tuple structs are not supported
+    #[pin]
+    Unix,
+    #[cfg(windows)]
+    #[pin]
+    Windows,
+);
+
+fn main() {}

tests/ui/cfg/tuple-struct.rs

@@ -0,0 +1,8 @@
+error: `cfg` attributes on the field of tuple structs are not supported
+ --> $DIR/tuple-struct.rs:7:5
+  |
+7 |     #[cfg(unix)] //~ ERROR `cfg` attributes on the field of tuple structs are not supported
+  |     ^^^^^^^^^^^^
+
+error: aborting due to previous error
+

tests/ui/cfg/tuple-struct.stderr

@@ -0,0 +1,17 @@
+// compile-fail
+
+use pin_project::pin_project;
+
+#[pin_project]
+pub enum Field {
+    Tuple(
+        #[cfg(unix)] //~ ERROR `cfg` attributes on the field of tuple variants are not supported
+        #[pin]
+        Unix,
+        #[cfg(windows)]
+        #[pin]
+        Windows,
+    ),
+}
+
+fn main() {}

tests/ui/cfg/tuple-variant.rs

@@ -0,0 +1,8 @@
+error: `cfg` attributes on the field of tuple variants are not supported
+ --> $DIR/tuple-variant.rs:8:9
+  |
+8 |         #[cfg(unix)] //~ ERROR `cfg` attributes on the field of tuple variants are not supported
+  |         ^^^^^^^^^^^^
+
+error: aborting due to previous error
+

tests/ui/cfg/tuple-variant.stderr

@@ -0,0 +1,13 @@
+// compile-fail
+
+// Refs: https://github.com/rust-lang/rust/issues/48214
+
+use core::marker::PhantomPinned;
+use pin_project::pin_project;
+
+struct Inner(PhantomPinned);
+
+#[pin_project]
+struct Foo(#[pin] Inner);
+
+fn main() {}

tests/ui/pin_project/phantom-pinned.rs

@@ -0,0 +1,16 @@
+error[E0277]: the trait bound `std::marker::PhantomPinned: std::marker::Unpin` is not satisfied in `UnpinStructFoo`
+  --> $DIR/phantom-pinned.rs:10:1
+   |
+10 | #[pin_project]
+   | ^^^^^^^^^^^^^^ within `UnpinStructFoo`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+   |
+   = help: the following implementations were found:
+             <std::marker::PhantomPinned as std::marker::Unpin>
+   = note: required because it appears within the type `Inner`
+   = note: required because it appears within the type `UnpinStructFoo`
+   = help: see issue #48214
+   = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.

tests/ui/pin_project/phantom-pinned.stderr

@@ -1,6 +1,6 @@
 // compile-fail
 
-use pin_project::{pin_project, pinned_drop};
+use pin_project::pin_project;
 use std::pin::Pin;
 
 struct Inner<T> {

tests/ui/pin_project/proper_unpin.rs

@@ -0,0 +1,15 @@
+// run-pass
+
+// Refs: https://github.com/rust-lang/rust/issues/48214
+
+#![feature(trivial_bounds)]
+
+use core::marker::PhantomPinned;
+use pin_project::pin_project;
+
+struct Inner(PhantomPinned);
+
+#[pin_project]
+struct Foo(#[pin] Inner);
+
+fn main() {}

tests/ui/pin_project/trivial_bounds.rs

@@ -11,16 +11,16 @@ error: #[pin_project] attribute may not be used on structs with zero fields
   |               ^^
 
 error: #[pin_project] attribute may not be used on structs with units
-  --> $DIR/unsupported.rs:12:1
+  --> $DIR/unsupported.rs:12:8
    |
 12 | struct Struct3; //~ ERROR may not be used on structs with units
-   | ^^^^^^^^^^^^^^^
+   |        ^^^^^^^
 
 error: #[pin_project] attribute may not be used on enums without variants
-  --> $DIR/unsupported.rs:15:1
+  --> $DIR/unsupported.rs:15:12
    |
 15 | enum Enum1 {} //~ ERROR may not be used on enums without variants
-   | ^^^^^^^^^^^^^
+   |            ^^
 
 error: #[pin_project] attribute may not be used on enums with discriminants
   --> $DIR/unsupported.rs:19:9

tests/ui/pin_project/unsupported.stderr

@@ -1,4 +1,3 @@
-#![no_std]
 #![warn(unsafe_code)]
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 #![allow(dead_code)]