| use proc_macro2::{Delimiter, Group, Span, TokenStream}; |
| use quote::{format_ident, quote, quote_spanned, ToTokens}; |
| use syn::{ |
| parse::{Parse, ParseStream}, |
| spanned::Spanned, |
| visit_mut::VisitMut, |
| *, |
| }; |
| |
| use super::PIN; |
| use crate::utils::{ |
| determine_lifetime_name, determine_visibility, insert_lifetime_and_bound, ParseBufferExt, |
| ProjKind, ReplaceReceiver, SliceExt, Variants, |
| }; |
| |
| pub(super) fn parse_derive(input: TokenStream) -> Result<TokenStream> { |
| let mut input: DeriveInput = syn::parse2(input)?; |
| |
| let ident = &input.ident; |
| let ty_generics = input.generics.split_for_impl().1; |
| let self_ty = parse_quote!(#ident #ty_generics); |
| let mut visitor = ReplaceReceiver(&self_ty); |
| visitor.visit_generics_mut(&mut input.generics); |
| visitor.visit_data_mut(&mut input.data); |
| |
| let mut cx = Context::new(&input.attrs, &input.vis, &input.ident, &mut input.generics)?; |
| let packed_check; |
| |
| let (mut items, scoped_items) = match &input.data { |
| Data::Struct(data) => { |
| // Do this first for a better error message. |
| packed_check = Some(cx.ensure_not_packed(&data.fields)?); |
| cx.parse_struct(data)? |
| } |
| Data::Enum(data) => { |
| // We don't need to check for `#[repr(packed)]`, |
| // since it does not apply to enums. |
| packed_check = None; |
| cx.parse_enum(data)? |
| } |
| Data::Union(_) => { |
| return Err(error!( |
| input, |
| "#[pin_project] attribute may only be used on structs or enums" |
| )); |
| } |
| }; |
| |
| let unpin_impl = cx.make_unpin_impl(); |
| let drop_impl = cx.make_drop_impl(); |
| let dummy_const = if cfg!(underscore_consts) { |
| format_ident!("_") |
| } else { |
| format_ident!("__SCOPE_{}", ident) |
| }; |
| items.extend(quote! { |
| // All items except projected types are generated inside a `const` scope. |
| // This makes it impossible for user code to refer to these types. |
| // However, this prevents Rustdoc from displaying docs for any |
| // of our types. In particular, users cannot see the |
| // automatically generated `Unpin` impl for the '__UnpinStruct' types |
| // |
| // Previously, we provided a flag to correctly document the |
| // automatically generated `Unpin` impl by using def-site hygiene, |
| // but it is now removed. |
| // |
| // Refs: |
| // * https://github.com/rust-lang/rust/issues/63281 |
| // * https://github.com/taiki-e/pin-project/pull/53#issuecomment-525906867 |
| // * https://github.com/taiki-e/pin-project/pull/70 |
| #[doc(hidden)] |
| #[allow(non_upper_case_globals)] |
| #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058 |
| #[allow(clippy::used_underscore_binding)] |
| const #dummy_const: () = { |
| #scoped_items |
| #unpin_impl |
| #drop_impl |
| #packed_check |
| }; |
| }); |
| Ok(items) |
| } |
| |
| fn validate_struct(ident: &Ident, fields: &Fields) -> Result<()> { |
| if fields.is_empty() { |
| let msg = "#[pin_project] attribute may not be used on structs with zero fields"; |
| if let Fields::Unit = fields { Err(error!(ident, msg)) } else { Err(error!(fields, msg)) } |
| } else { |
| Ok(()) |
| } |
| } |
| |
| fn validate_enum(brace_token: token::Brace, variants: &Variants) -> Result<()> { |
| if variants.is_empty() { |
| return Err(Error::new( |
| brace_token.span, |
| "#[pin_project] attribute may not be used on enums without variants", |
| )); |
| } |
| let has_field = variants.iter().try_fold(false, |has_field, v| { |
| if let Some((_, e)) = &v.discriminant { |
| Err(error!(e, "#[pin_project] attribute may not be used on enums with discriminants")) |
| } else if let Some(attr) = v.attrs.find(PIN) { |
| Err(error!(attr, "#[pin] attribute may only be used on fields of structs or variants")) |
| } else if v.fields.is_empty() { |
| Ok(has_field) |
| } else { |
| Ok(true) |
| } |
| })?; |
| if has_field { |
| Ok(()) |
| } else { |
| Err(error!(variants, "#[pin_project] attribute may not be used on enums with zero fields")) |
| } |
| } |
| |
| struct Args { |
| /// `PinnedDrop` argument. |
| pinned_drop: Option<Span>, |
| /// `UnsafeUnpin` or `!Unpin` argument. |
| unpin_impl: UnpinImpl, |
| /// `project = <ident>` argument. |
| project: Option<Ident>, |
| /// `project_ref = <ident>` argument. |
| project_ref: Option<Ident>, |
| /// `project_replace [= <ident>]` or `Replace` argument. |
| project_replace: ProjReplace, |
| } |
| |
| enum ProjReplace { |
| None, |
| /// `project_replace` or `Replace`. |
| Unnamed { |
| span: Span, |
| }, |
| /// `project_replace = <ident>`. |
| Named { |
| span: Span, |
| ident: Ident, |
| }, |
| } |
| |
| impl ProjReplace { |
| fn span(&self) -> Option<Span> { |
| match self { |
| ProjReplace::None => None, |
| ProjReplace::Named { span, .. } | ProjReplace::Unnamed { span, .. } => Some(*span), |
| } |
| } |
| |
| fn ident(&self) -> Option<&Ident> { |
| if let ProjReplace::Named { ident, .. } = self { Some(ident) } else { None } |
| } |
| } |
| |
| const DUPLICATE_PIN: &str = "duplicate #[pin] attribute"; |
| |
| impl Args { |
| fn get(attrs: &[Attribute]) -> Result<Self> { |
| // `(__private(<args>))` -> `<args>` |
| struct Input(Option<TokenStream>); |
| |
| impl Parse for Input { |
| fn parse(input: ParseStream<'_>) -> Result<Self> { |
| Ok(Self((|| { |
| let content = input.parenthesized().ok()?; |
| let private = content.parse::<Ident>().ok()?; |
| if private == "__private" { |
| content.parenthesized().ok()?.parse::<TokenStream>().ok() |
| } else { |
| None |
| } |
| })())) |
| } |
| } |
| |
| if let Some(attr) = attrs.find("pin_project") { |
| return Err(error!(attr, "duplicate #[pin_project] attribute")); |
| } |
| |
| let mut attrs = attrs.iter().filter(|attr| attr.path.is_ident(PIN)); |
| |
| let prev = if let Some(attr) = attrs.next() { |
| (attr, syn::parse2::<Input>(attr.tokens.clone()).unwrap().0) |
| } else { |
| // This only fails if another macro removes `#[pin]`. |
| return Err(error!(TokenStream::new(), "#[pin_project] attribute has been removed")); |
| }; |
| |
| if let Some(attr) = attrs.next() { |
| let (prev_attr, prev_res) = &prev; |
| // As the `#[pin]` attribute generated by `#[pin_project]` |
| // has the same span as `#[pin_project]`, it is possible |
| // that a useless error message will be generated. |
| let res = syn::parse2::<Input>(attr.tokens.clone()).unwrap().0; |
| let span = match (&prev_res, res) { |
| (Some(_), _) => attr, |
| (_, Some(_)) => prev_attr, |
| (None, None) => prev_attr, |
| }; |
| Err(error!(span, DUPLICATE_PIN)) |
| } else { |
| // This `unwrap` only fails if another macro removes `#[pin]` and inserts own `#[pin]`. |
| syn::parse2(prev.1.unwrap()) |
| } |
| } |
| } |
| |
| impl Parse for Args { |
| fn parse(input: ParseStream<'_>) -> Result<Self> { |
| mod kw { |
| syn::custom_keyword!(Unpin); |
| } |
| |
| // Parses `= <value>` in `<name> = <value>` and returns value and span of name-value pair. |
| fn parse_value( |
| input: ParseStream<'_>, |
| name: &Ident, |
| has_prev: bool, |
| ) -> Result<(Ident, TokenStream)> { |
| if input.is_empty() { |
| return Err(error!(name, "expected `{0} = <identifier>`, found `{0}`", name)); |
| } |
| let eq_token: Token![=] = input.parse()?; |
| if input.is_empty() { |
| let span = quote!(#name #eq_token); |
| return Err(error!(span, "expected `{0} = <identifier>`, found `{0} =`", name)); |
| } |
| let value: Ident = input.parse()?; |
| let span = quote!(#name #value); |
| if has_prev { |
| Err(error!(span, "duplicate `{}` argument", name)) |
| } else { |
| Ok((value, span)) |
| } |
| } |
| |
| let mut pinned_drop = None; |
| let mut unsafe_unpin = None; |
| let mut not_unpin = None; |
| let mut project = None; |
| let mut project_ref = None; |
| |
| let mut replace = None; |
| let mut project_replace_value = None; |
| let mut project_replace_span = None; |
| |
| while !input.is_empty() { |
| if input.peek(Token![!]) { |
| let bang: Token![!] = input.parse()?; |
| if input.is_empty() { |
| return Err(error!(bang, "expected `!Unpin`, found `!`")); |
| } |
| let unpin: kw::Unpin = input.parse()?; |
| let span = quote!(#bang #unpin); |
| if not_unpin.replace(span.span()).is_some() { |
| return Err(error!(span, "duplicate `!Unpin` argument")); |
| } |
| } else { |
| let token = input.parse::<Ident>()?; |
| match &*token.to_string() { |
| "PinnedDrop" => { |
| if pinned_drop.replace(token.span()).is_some() { |
| return Err(error!(token, "duplicate `PinnedDrop` argument")); |
| } |
| } |
| "UnsafeUnpin" => { |
| if unsafe_unpin.replace(token.span()).is_some() { |
| return Err(error!(token, "duplicate `UnsafeUnpin` argument")); |
| } |
| } |
| "project" => { |
| project = Some(parse_value(input, &token, project.is_some())?.0); |
| } |
| "project_ref" => { |
| project_ref = Some(parse_value(input, &token, project_ref.is_some())?.0); |
| } |
| "project_replace" => { |
| if input.peek(Token![=]) { |
| let (value, span) = |
| parse_value(input, &token, project_replace_span.is_some())?; |
| project_replace_value = Some(value); |
| project_replace_span = Some(span.span()); |
| } else if project_replace_span.is_some() { |
| return Err(error!(token, "duplicate `project_replace` argument")); |
| } else { |
| project_replace_span = Some(token.span()); |
| } |
| } |
| "Replace" => { |
| if replace.replace(token.span()).is_some() { |
| return Err(error!(token, "duplicate `Replace` argument")); |
| } |
| } |
| _ => return Err(error!(token, "unexpected argument: {}", token)), |
| } |
| } |
| |
| if input.is_empty() { |
| break; |
| } |
| let _: Token![,] = input.parse()?; |
| } |
| |
| if project.is_some() || project_ref.is_some() { |
| if project == project_ref { |
| return Err(error!( |
| project_ref, |
| "name `{}` is already specified by `project` argument", |
| project_ref.as_ref().unwrap() |
| )); |
| } |
| if let Some(ident) = &project_replace_value { |
| if project == project_replace_value { |
| return Err(error!( |
| ident, |
| "name `{}` is already specified by `project` argument", ident |
| )); |
| } else if project_ref == project_replace_value { |
| return Err(error!( |
| ident, |
| "name `{}` is already specified by `project_ref` argument", ident |
| )); |
| } |
| } |
| } |
| |
| if let Some(span) = pinned_drop { |
| if project_replace_span.is_some() { |
| return Err(Error::new( |
| span, |
| "arguments `PinnedDrop` and `project_replace` are mutually exclusive", |
| )); |
| } else if replace.is_some() { |
| return Err(Error::new( |
| span, |
| "arguments `PinnedDrop` and `Replace` are mutually exclusive", |
| )); |
| } |
| } |
| let project_replace = match (project_replace_span, project_replace_value, replace) { |
| (None, _, None) => ProjReplace::None, |
| // If both `project_replace` and `Replace` are specified, |
| // We always prefer `project_replace`'s span, |
| (Some(span), Some(ident), _) => ProjReplace::Named { ident, span }, |
| (Some(span), ..) | (None, _, Some(span)) => ProjReplace::Unnamed { span }, |
| }; |
| let unpin_impl = match (unsafe_unpin, not_unpin) { |
| (None, None) => UnpinImpl::Default, |
| (Some(span), None) => UnpinImpl::Unsafe(span), |
| (None, Some(span)) => UnpinImpl::Negative(span), |
| (Some(span), Some(_)) => { |
| return Err(Error::new( |
| span, |
| "arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive", |
| )); |
| } |
| }; |
| |
| Ok(Self { pinned_drop, unpin_impl, project, project_ref, project_replace }) |
| } |
| } |
| |
| struct OriginalType<'a> { |
| /// Attributes of the original type. |
| attrs: &'a [Attribute], |
| /// Visibility of the original type. |
| vis: &'a Visibility, |
| /// Name of the original type. |
| ident: &'a Ident, |
| /// Generics of the original type. |
| generics: &'a Generics, |
| } |
| |
| struct ProjectedType { |
| /// Visibility of the projected types. |
| vis: Visibility, |
| /// Name of the projected type returned by `project` method. |
| mut_ident: Ident, |
| /// Name of the projected type returned by `project_ref` method. |
| ref_ident: Ident, |
| /// Name of the projected type returned by `project_replace` method. |
| own_ident: Ident, |
| /// Lifetime on the generated projected types. |
| lifetime: Lifetime, |
| /// Generics of the projected types. |
| generics: Generics, |
| /// `where` clause of the projected types. This has an additional |
| /// bound generated by `insert_lifetime_and_bound` |
| where_clause: WhereClause, |
| } |
| |
| struct ProjectedVariants { |
| proj_variants: TokenStream, |
| proj_ref_variants: TokenStream, |
| proj_own_variants: TokenStream, |
| proj_arms: TokenStream, |
| proj_ref_arms: TokenStream, |
| proj_own_arms: TokenStream, |
| } |
| |
| #[derive(Default)] |
| struct ProjectedFields { |
| proj_pat: TokenStream, |
| proj_body: TokenStream, |
| proj_own_body: TokenStream, |
| proj_fields: TokenStream, |
| proj_ref_fields: TokenStream, |
| proj_own_fields: TokenStream, |
| } |
| |
| struct Context<'a> { |
| /// The original type. |
| orig: OriginalType<'a>, |
| /// The projected types. |
| proj: ProjectedType, |
| /// Types of the pinned fields. |
| pinned_fields: Vec<Type>, |
| |
| /// `PinnedDrop` argument. |
| pinned_drop: Option<Span>, |
| /// `UnsafeUnpin` or `!Unpin` argument. |
| unpin_impl: UnpinImpl, |
| /// `project` argument. |
| project: bool, |
| /// `project_ref` argument. |
| project_ref: bool, |
| /// `project_replace [= <ident>]` or `Replace` argument. |
| project_replace: ProjReplace, |
| } |
| |
| #[derive(Clone, Copy)] |
| enum UnpinImpl { |
| Default, |
| /// `UnsafeUnpin`. |
| Unsafe(Span), |
| /// `!Unpin`. |
| Negative(Span), |
| } |
| |
| impl<'a> Context<'a> { |
| fn new( |
| attrs: &'a [Attribute], |
| vis: &'a Visibility, |
| ident: &'a Ident, |
| generics: &'a mut Generics, |
| ) -> Result<Self> { |
| let Args { pinned_drop, unpin_impl, project, project_ref, project_replace } = |
| Args::get(attrs)?; |
| |
| let mut lifetime_name = String::from("'pin"); |
| determine_lifetime_name(&mut lifetime_name, generics); |
| let lifetime = Lifetime::new(&lifetime_name, Span::call_site()); |
| |
| let ty_generics = generics.split_for_impl().1; |
| let ty_generics_as_generics = parse_quote!(#ty_generics); |
| let mut proj_generics = generics.clone(); |
| let pred = insert_lifetime_and_bound( |
| &mut proj_generics, |
| lifetime.clone(), |
| &ty_generics_as_generics, |
| ident, |
| ); |
| let mut where_clause = generics.make_where_clause().clone(); |
| where_clause.predicates.push(pred); |
| |
| let own_ident = |
| project_replace.ident().cloned().unwrap_or_else(|| ProjKind::Owned.proj_ident(ident)); |
| |
| Ok(Self { |
| pinned_drop, |
| unpin_impl, |
| project: project.is_some(), |
| project_ref: project_ref.is_some(), |
| project_replace, |
| proj: ProjectedType { |
| vis: determine_visibility(vis), |
| mut_ident: project.unwrap_or_else(|| ProjKind::Mutable.proj_ident(ident)), |
| ref_ident: project_ref.unwrap_or_else(|| ProjKind::Immutable.proj_ident(ident)), |
| own_ident, |
| lifetime, |
| generics: proj_generics, |
| where_clause, |
| }, |
| orig: OriginalType { attrs, vis, ident, generics }, |
| pinned_fields: Vec::new(), |
| }) |
| } |
| |
| /// Returns attributes used on projected types. |
| fn proj_attrs(&self) -> (TokenStream, TokenStream, TokenStream) { |
| // If the user gave it a name, it should appear in the document. |
| let doc_attr = quote!(#[doc(hidden)]); |
| let doc_proj = if self.project { None } else { Some(&doc_attr) }; |
| let doc_proj_ref = if self.project_ref { None } else { Some(&doc_attr) }; |
| let doc_proj_own = |
| if self.project_replace.ident().is_some() { None } else { Some(&doc_attr) }; |
| |
| let proj_mut = quote! { |
| #doc_proj |
| #[allow(dead_code)] // This lint warns unused fields/variants. |
| #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058 |
| #[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`. |
| #[allow(clippy::type_repetition_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/4326} |
| }; |
| let proj_ref = quote! { |
| #doc_proj_ref |
| #[allow(dead_code)] // This lint warns unused fields/variants. |
| #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058 |
| #[allow(clippy::type_repetition_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/4326 |
| }; |
| let proj_own = quote! { |
| #doc_proj_own |
| #[allow(dead_code)] // This lint warns unused fields/variants. |
| #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058 |
| #[allow(unreachable_pub)] // This lint warns `pub` field in private struct. |
| }; |
| (proj_mut, proj_ref, proj_own) |
| } |
| |
| fn parse_struct( |
| &mut self, |
| DataStruct { fields, .. }: &DataStruct, |
| ) -> Result<(TokenStream, TokenStream)> { |
| validate_struct(self.orig.ident, fields)?; |
| |
| let ProjectedFields { |
| proj_pat, |
| proj_body, |
| proj_fields, |
| proj_ref_fields, |
| proj_own_fields, |
| proj_own_body, |
| } = match fields { |
| Fields::Named(_) => self.visit_fields(None, fields, Delimiter::Brace)?, |
| Fields::Unnamed(_) => self.visit_fields(None, fields, Delimiter::Parenthesis)?, |
| Fields::Unit => unreachable!(), |
| }; |
| |
| let proj_ident = &self.proj.mut_ident; |
| let proj_ref_ident = &self.proj.ref_ident; |
| let proj_own_ident = &self.proj.own_ident; |
| let vis = &self.proj.vis; |
| let mut orig_generics = self.orig.generics.clone(); |
| let orig_where_clause = orig_generics.where_clause.take(); |
| let proj_generics = &self.proj.generics; |
| let proj_where_clause = &self.proj.where_clause; |
| |
| // For tuple structs, we need to generate `(T1, T2) where Foo: Bar` |
| // For non-tuple structs, we need to generate `where Foo: Bar { field1: T }` |
| let (where_clause_fields, where_clause_ref_fields, where_clause_own_fields) = match fields { |
| Fields::Named(_) => ( |
| quote!(#proj_where_clause #proj_fields), |
| quote!(#proj_where_clause #proj_ref_fields), |
| quote!(#orig_where_clause #proj_own_fields), |
| ), |
| Fields::Unnamed(_) => ( |
| quote!(#proj_fields #proj_where_clause;), |
| quote!(#proj_ref_fields #proj_where_clause;), |
| quote!(#proj_own_fields #orig_where_clause;), |
| ), |
| Fields::Unit => unreachable!(), |
| }; |
| |
| let (proj_attrs, proj_ref_attrs, proj_own_attrs) = self.proj_attrs(); |
| let mut proj_items = quote! { |
| #proj_attrs |
| #vis struct #proj_ident #proj_generics #where_clause_fields |
| #proj_ref_attrs |
| #vis struct #proj_ref_ident #proj_generics #where_clause_ref_fields |
| }; |
| if self.project_replace.span().is_some() { |
| proj_items.extend(quote! { |
| #proj_own_attrs |
| #vis struct #proj_own_ident #orig_generics #where_clause_own_fields |
| }); |
| } |
| |
| let proj_mut_body = quote! { |
| let Self #proj_pat = self.get_unchecked_mut(); |
| #proj_ident #proj_body |
| }; |
| let proj_ref_body = quote! { |
| let Self #proj_pat = self.get_ref(); |
| #proj_ref_ident #proj_body |
| }; |
| let proj_own_body = quote! { |
| let __self_ptr: *mut Self = self.get_unchecked_mut(); |
| let Self #proj_pat = &mut *__self_ptr; |
| #proj_own_body |
| }; |
| let proj_impl = self.make_proj_impl(&proj_mut_body, &proj_ref_body, &proj_own_body); |
| |
| Ok((proj_items, proj_impl)) |
| } |
| |
| fn parse_enum( |
| &mut self, |
| DataEnum { brace_token, variants, .. }: &DataEnum, |
| ) -> Result<(TokenStream, TokenStream)> { |
| validate_enum(*brace_token, variants)?; |
| |
| let ProjectedVariants { |
| proj_variants, |
| proj_ref_variants, |
| proj_own_variants, |
| proj_arms, |
| proj_ref_arms, |
| proj_own_arms, |
| } = self.visit_variants(variants)?; |
| |
| let proj_ident = &self.proj.mut_ident; |
| let proj_ref_ident = &self.proj.ref_ident; |
| let proj_own_ident = &self.proj.own_ident; |
| let vis = &self.proj.vis; |
| let mut orig_generics = self.orig.generics.clone(); |
| let orig_where_clause = orig_generics.where_clause.take(); |
| let proj_generics = &self.proj.generics; |
| let proj_where_clause = &self.proj.where_clause; |
| |
| let (proj_attrs, proj_ref_attrs, proj_own_attrs) = self.proj_attrs(); |
| let mut proj_items = quote! { |
| #proj_attrs |
| #vis enum #proj_ident #proj_generics #proj_where_clause { |
| #proj_variants |
| } |
| #proj_ref_attrs |
| #vis enum #proj_ref_ident #proj_generics #proj_where_clause { |
| #proj_ref_variants |
| } |
| }; |
| if self.project_replace.span().is_some() { |
| proj_items.extend(quote! { |
| #proj_own_attrs |
| #vis enum #proj_own_ident #orig_generics #orig_where_clause { |
| #proj_own_variants |
| } |
| }); |
| } |
| |
| let proj_mut_body = quote! { |
| match self.get_unchecked_mut() { |
| #proj_arms |
| } |
| }; |
| let proj_ref_body = quote! { |
| match self.get_ref() { |
| #proj_ref_arms |
| } |
| }; |
| let proj_own_body = quote! { |
| let __self_ptr: *mut Self = self.get_unchecked_mut(); |
| match &mut *__self_ptr { |
| #proj_own_arms |
| } |
| }; |
| let proj_impl = self.make_proj_impl(&proj_mut_body, &proj_ref_body, &proj_own_body); |
| |
| Ok((proj_items, proj_impl)) |
| } |
| |
| fn visit_variants(&mut self, variants: &Variants) -> Result<ProjectedVariants> { |
| let mut proj_variants = TokenStream::new(); |
| let mut proj_ref_variants = TokenStream::new(); |
| let mut proj_own_variants = TokenStream::new(); |
| let mut proj_arms = TokenStream::new(); |
| let mut proj_ref_arms = TokenStream::new(); |
| let mut proj_own_arms = TokenStream::new(); |
| |
| for Variant { ident, fields, .. } in variants { |
| let ProjectedFields { |
| proj_pat, |
| proj_body, |
| proj_fields, |
| proj_ref_fields, |
| proj_own_fields, |
| proj_own_body, |
| } = match fields { |
| Fields::Named(_) => self.visit_fields(Some(ident), fields, Delimiter::Brace)?, |
| Fields::Unnamed(_) => { |
| self.visit_fields(Some(ident), fields, Delimiter::Parenthesis)? |
| } |
| Fields::Unit => ProjectedFields { |
| proj_own_body: self.proj_own_body(Some(ident), None, &[]), |
| ..ProjectedFields::default() |
| }, |
| }; |
| |
| let orig_ident = self.orig.ident; |
| let proj_ident = &self.proj.mut_ident; |
| let proj_ref_ident = &self.proj.ref_ident; |
| proj_variants.extend(quote! { |
| #ident #proj_fields, |
| }); |
| proj_ref_variants.extend(quote! { |
| #ident #proj_ref_fields, |
| }); |
| proj_own_variants.extend(quote! { |
| #ident #proj_own_fields, |
| }); |
| proj_arms.extend(quote! { |
| #orig_ident::#ident #proj_pat => { |
| #proj_ident::#ident #proj_body |
| } |
| }); |
| proj_ref_arms.extend(quote! { |
| #orig_ident::#ident #proj_pat => { |
| #proj_ref_ident::#ident #proj_body |
| } |
| }); |
| proj_own_arms.extend(quote! { |
| #orig_ident::#ident #proj_pat => { |
| #proj_own_body |
| } |
| }); |
| } |
| |
| Ok(ProjectedVariants { |
| proj_variants, |
| proj_ref_variants, |
| proj_own_variants, |
| proj_arms, |
| proj_ref_arms, |
| proj_own_arms, |
| }) |
| } |
| |
| fn visit_fields( |
| &mut self, |
| variant_ident: Option<&Ident>, |
| fields: &Fields, |
| delim: Delimiter, |
| ) -> Result<ProjectedFields> { |
| let mut proj_pat = TokenStream::new(); |
| let mut proj_body = TokenStream::new(); |
| let mut proj_fields = TokenStream::new(); |
| let mut proj_ref_fields = TokenStream::new(); |
| let mut proj_own_fields = TokenStream::new(); |
| let mut proj_move = TokenStream::new(); |
| let mut pinned_bindings = Vec::with_capacity(fields.len()); |
| |
| for (i, Field { attrs, vis, ident, colon_token, ty, .. }) in fields.iter().enumerate() { |
| let binding = ident.clone().unwrap_or_else(|| format_ident!("_{}", i)); |
| proj_pat.extend(quote!(#binding,)); |
| if attrs.position_exact(PIN)?.is_some() { |
| let lifetime = &self.proj.lifetime; |
| proj_fields.extend(quote! { |
| #vis #ident #colon_token ::pin_project::__private::Pin<&#lifetime mut (#ty)>, |
| }); |
| proj_ref_fields.extend(quote! { |
| #vis #ident #colon_token ::pin_project::__private::Pin<&#lifetime (#ty)>, |
| }); |
| proj_own_fields.extend(quote! { |
| #vis #ident #colon_token ::pin_project::__private::PhantomData<#ty>, |
| }); |
| proj_body.extend(quote! { |
| #ident #colon_token ::pin_project::__private::Pin::new_unchecked(#binding), |
| }); |
| proj_move.extend(quote! { |
| #ident #colon_token ::pin_project::__private::PhantomData, |
| }); |
| |
| self.pinned_fields.push(ty.clone()); |
| pinned_bindings.push(binding); |
| } else { |
| let lifetime = &self.proj.lifetime; |
| proj_fields.extend(quote! { |
| #vis #ident #colon_token &#lifetime mut (#ty), |
| }); |
| proj_ref_fields.extend(quote! { |
| #vis #ident #colon_token &#lifetime (#ty), |
| }); |
| proj_own_fields.extend(quote! { |
| #vis #ident #colon_token #ty, |
| }); |
| proj_body.extend(quote! { |
| #binding, |
| }); |
| proj_move.extend(quote! { |
| #ident #colon_token ::pin_project::__private::ptr::read(#binding), |
| }); |
| } |
| } |
| |
| fn surround(delim: Delimiter, tokens: TokenStream) -> TokenStream { |
| Group::new(delim, tokens).into_token_stream() |
| } |
| |
| let proj_pat = surround(delim, proj_pat); |
| let proj_body = surround(delim, proj_body); |
| let proj_fields = surround(delim, proj_fields); |
| let proj_ref_fields = surround(delim, proj_ref_fields); |
| let proj_own_fields = surround(delim, proj_own_fields); |
| |
| let proj_move = Group::new(delim, proj_move); |
| let proj_own_body = self.proj_own_body(variant_ident, Some(proj_move), &pinned_bindings); |
| |
| Ok(ProjectedFields { |
| proj_pat, |
| proj_body, |
| proj_own_body, |
| proj_fields, |
| proj_ref_fields, |
| proj_own_fields, |
| }) |
| } |
| |
| /// Generates the processing that `project_replace` does for the struct or each variant. |
| fn proj_own_body( |
| &self, |
| variant_ident: Option<&'a Ident>, |
| proj_move: Option<Group>, |
| pinned_fields: &[Ident], |
| ) -> TokenStream { |
| let ident = &self.proj.own_ident; |
| let proj_own = match variant_ident { |
| Some(variant_ident) => quote!(#ident::#variant_ident), |
| None => quote!(#ident), |
| }; |
| |
| quote! { |
| // First, extract all the unpinned fields |
| let __result = #proj_own #proj_move; |
| |
| // Destructors will run in reverse order, so next create a guard to overwrite |
| // `self` with the replacement value without calling destructors. |
| let __guard = ::pin_project::__private::UnsafeOverwriteGuard { |
| target: __self_ptr, |
| value: ::pin_project::__private::ManuallyDrop::new(__replacement), |
| }; |
| |
| // Now create guards to drop all the pinned fields |
| // |
| // Due to a compiler bug (https://github.com/rust-lang/rust/issues/47949) |
| // this must be in its own scope, or else `__result` will not be dropped |
| // if any of the destructors panic. |
| { |
| #( |
| let __guard = ::pin_project::__private::UnsafeDropInPlaceGuard(#pinned_fields); |
| )* |
| } |
| |
| // Finally, return the result |
| __result |
| } |
| } |
| |
| /// Creates `Unpin` implementation for original type. |
| fn make_unpin_impl(&self) -> TokenStream { |
| match self.unpin_impl { |
| UnpinImpl::Unsafe(span) => { |
| let mut proj_generics = self.proj.generics.clone(); |
| let orig_ident = self.orig.ident; |
| let lifetime = &self.proj.lifetime; |
| |
| // Make the error message highlight `UnsafeUnpin` argument. |
| proj_generics.make_where_clause().predicates.push(parse_quote_spanned! { span => |
| ::pin_project::__private::Wrapper<#lifetime, Self>: ::pin_project::UnsafeUnpin |
| }); |
| |
| let (impl_generics, _, where_clause) = proj_generics.split_for_impl(); |
| let ty_generics = self.orig.generics.split_for_impl().1; |
| |
| quote_spanned! { span => |
| impl #impl_generics ::pin_project::__private::Unpin for #orig_ident #ty_generics |
| #where_clause |
| { |
| } |
| } |
| } |
| UnpinImpl::Negative(span) => { |
| let mut proj_generics = self.proj.generics.clone(); |
| let orig_ident = self.orig.ident; |
| let lifetime = &self.proj.lifetime; |
| |
| proj_generics.make_where_clause().predicates.push(parse_quote! { |
| ::pin_project::__private::Wrapper< |
| #lifetime, ::pin_project::__private::PhantomPinned |
| >: ::pin_project::__private::Unpin |
| }); |
| |
| let (proj_impl_generics, _, proj_where_clause) = proj_generics.split_for_impl(); |
| let (impl_generics, ty_generics, orig_where_clause) = |
| self.orig.generics.split_for_impl(); |
| |
| // For interoperability with `forbid(unsafe_code)`, `unsafe` token should be |
| // call-site span. |
| let unsafety = <Token![unsafe]>::default(); |
| quote_spanned! { span => |
| impl #proj_impl_generics ::pin_project::__private::Unpin |
| for #orig_ident #ty_generics |
| #proj_where_clause |
| { |
| } |
| |
| // A dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it. |
| // |
| // To ensure that users don't accidentally write a non-functional `UnsafeUnpin` |
| // impls, we emit one ourselves. If the user ends up writing an `UnsafeUnpin` |
| // impl, they'll get a "conflicting implementations of trait" error when |
| // coherence checks are run. |
| #unsafety impl #impl_generics ::pin_project::UnsafeUnpin |
| for #orig_ident #ty_generics |
| #orig_where_clause |
| { |
| } |
| } |
| } |
| UnpinImpl::Default => { |
| let mut full_where_clause = self.orig.generics.where_clause.clone().unwrap(); |
| |
| // Generate a field in our new struct for every |
| // pinned field in the original type. |
| let fields = self.pinned_fields.iter().enumerate().map(|(i, ty)| { |
| let field_ident = format_ident!("__field{}", i); |
| quote!(#field_ident: #ty) |
| }); |
| |
| // We could try to determine the subset of type parameters |
| // and lifetimes that are actually used by the pinned fields |
| // (as opposed to those only used by unpinned fields). |
| // However, this would be tricky and error-prone, since |
| // it's possible for users to create types that would alias |
| // with generic parameters (e.g. 'struct T'). |
| // |
| // Instead, we generate a use of every single type parameter |
| // and lifetime used in the original struct. For type parameters, |
| // we generate code like this: |
| // |
| // ```rust |
| // struct AlwaysUnpin<T: ?Sized>(PhantomData<T>) {} |
| // impl<T: ?Sized> Unpin for AlwaysUnpin<T> {} |
| // |
| // ... |
| // _field: AlwaysUnpin<(A, B, C)> |
| // ``` |
| // |
| // This ensures that any unused type parameters |
| // don't end up with `Unpin` bounds. |
| let lifetime_fields = self.orig.generics.lifetimes().enumerate().map( |
| |(i, LifetimeDef { lifetime, .. })| { |
| let field_ident = format_ident!("__lifetime{}", i); |
| quote!(#field_ident: &#lifetime ()) |
| }, |
| ); |
| |
| let orig_ident = self.orig.ident; |
| let struct_ident = format_ident!("__{}", orig_ident); |
| let vis = self.orig.vis; |
| let lifetime = &self.proj.lifetime; |
| let type_params = self.orig.generics.type_params().map(|t| &t.ident); |
| let proj_generics = &self.proj.generics; |
| let (proj_impl_generics, proj_ty_generics, _) = proj_generics.split_for_impl(); |
| let (impl_generics, ty_generics, where_clause) = |
| self.orig.generics.split_for_impl(); |
| |
| full_where_clause.predicates.push(parse_quote! { |
| #struct_ident #proj_ty_generics: ::pin_project::__private::Unpin |
| }); |
| |
| quote! { |
| // This needs to have the same visibility as the original type, |
| // due to the limitations of the 'public in private' error. |
| // |
| // Our goal is to implement the public trait `Unpin` for |
| // a potentially public user type. Because of this, rust |
| // requires that any types mentioned in the where clause of |
| // our `Unpin` impl also be public. This means that our generated |
| // `__UnpinStruct` type must also be public. |
| // However, we ensure that the user can never actually reference |
| // this 'public' type by creating this type in the inside of `const`. |
| #vis struct #struct_ident #proj_generics #where_clause { |
| __pin_project_use_generics: ::pin_project::__private::AlwaysUnpin< |
| #lifetime, (#(::pin_project::__private::PhantomData<#type_params>),*) |
| >, |
| |
| #(#fields,)* |
| #(#lifetime_fields,)* |
| } |
| |
| impl #proj_impl_generics ::pin_project::__private::Unpin |
| for #orig_ident #ty_generics |
| #full_where_clause |
| { |
| } |
| |
| // A dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it. |
| // |
| // To ensure that users don't accidentally write a non-functional `UnsafeUnpin` |
| // impls, we emit one ourselves. If the user ends up writing an `UnsafeUnpin` |
| // impl, they'll get a "conflicting implementations of trait" error when |
| // coherence checks are run. |
| unsafe impl #impl_generics ::pin_project::UnsafeUnpin |
| for #orig_ident #ty_generics |
| #where_clause |
| { |
| } |
| } |
| } |
| } |
| } |
| |
| /// Creates `Drop` implementation for original type. |
| fn make_drop_impl(&self) -> TokenStream { |
| let ident = self.orig.ident; |
| let (impl_generics, ty_generics, where_clause) = self.orig.generics.split_for_impl(); |
| |
| if let Some(span) = self.pinned_drop { |
| // For interoperability with `forbid(unsafe_code)`, `unsafe` token should be |
| // call-site span. |
| let unsafety = <Token![unsafe]>::default(); |
| quote_spanned! { span => |
| impl #impl_generics ::pin_project::__private::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 = #unsafety { |
| ::pin_project::__private::Pin::new_unchecked(self) |
| }; |
| // We call `pinned_drop` only once. Since `PinnedDrop::drop` |
| // is an unsafe method and a private API, it is never called again in safe |
| // code *unless the user uses a maliciously crafted macro*. |
| #unsafety { |
| ::pin_project::__private::PinnedDrop::drop(pinned_self); |
| } |
| } |
| } |
| } |
| } else { |
| // If the user does not provide a `PinnedDrop` impl, |
| // we need to ensure that they don't provide a `Drop` impl of their |
| // own. |
| // Based on https://github.com/upsuper/assert-impl/blob/f503255b292ab0ba8d085b657f4065403cfa46eb/src/lib.rs#L80-L87 |
| // |
| // We create a new identifier for each struct, so that the traits |
| // for different types do not conflict with each other. |
| // |
| // Another approach would be to provide an empty Drop impl, |
| // which would conflict with a user-provided Drop impl. |
| // However, this would trigger the compiler's special handling |
| // of Drop types (e.g. fields cannot be moved out of a Drop type). |
| // This approach prevents the creation of needless Drop impls, |
| // giving users more flexibility. |
| let trait_ident = format_ident!("{}MustNotImplDrop", ident); |
| |
| quote! { |
| // There are two possible cases: |
| // 1. The user type does not implement Drop. In this case, |
| // the first blanked impl will not apply to it. This code |
| // will compile, as there is only one impl of MustNotImplDrop for the user type |
| // 2. The user type does impl Drop. This will make the blanket impl applicable, |
| // which will then conflict with the explicit MustNotImplDrop impl below. |
| // This will result in a compilation error, which is exactly what we want. |
| trait #trait_ident {} |
| #[allow(clippy::drop_bounds)] |
| impl<T: ::pin_project::__private::Drop> #trait_ident for T {} |
| impl #impl_generics #trait_ident for #ident #ty_generics #where_clause {} |
| |
| // A dummy impl of `PinnedDrop`, to ensure that the user cannot implement it. |
| // Since the user did not pass `PinnedDrop` to `#[pin_project]`, any `PinnedDrop` |
| // impl will not actually be called. Unfortunately, we can't detect this situation |
| // directly from either the `#[pin_project]` or `#[pinned_drop]` attributes, since |
| // we don't know what other attirbutes/impl may exist. |
| // |
| // To ensure that users don't accidentally write a non-functional `PinnedDrop` |
| // impls, we emit one ourselves. If the user ends up writing a `PinnedDrop` impl, |
| // they'll get a "conflicting implementations of trait" error when coherence |
| // checks are run. |
| impl #impl_generics ::pin_project::__private::PinnedDrop for #ident #ty_generics |
| #where_clause |
| { |
| unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} |
| } |
| } |
| } |
| } |
| |
| /// Creates an implementation of the projection method. |
| fn make_proj_impl( |
| &self, |
| proj_body: &TokenStream, |
| proj_ref_body: &TokenStream, |
| proj_own_body: &TokenStream, |
| ) -> TokenStream { |
| let vis = &self.proj.vis; |
| let lifetime = &self.proj.lifetime; |
| let orig_ident = self.orig.ident; |
| let proj_ident = &self.proj.mut_ident; |
| let proj_ref_ident = &self.proj.ref_ident; |
| let proj_own_ident = &self.proj.own_ident; |
| |
| let orig_ty_generics = self.orig.generics.split_for_impl().1; |
| let proj_ty_generics = self.proj.generics.split_for_impl().1; |
| let (impl_generics, ty_generics, where_clause) = self.orig.generics.split_for_impl(); |
| |
| let replace_impl = self.project_replace.span().map(|span| { |
| // For interoperability with `forbid(unsafe_code)`, `unsafe` token should be |
| // call-site span. |
| let unsafety = <Token![unsafe]>::default(); |
| quote_spanned! { span => |
| #vis fn project_replace( |
| self: ::pin_project::__private::Pin<&mut Self>, |
| __replacement: Self, |
| ) -> #proj_own_ident #orig_ty_generics { |
| #unsafety { |
| #proj_own_body |
| } |
| } |
| } |
| }); |
| |
| quote! { |
| impl #impl_generics #orig_ident #ty_generics #where_clause { |
| #vis fn project<#lifetime>( |
| self: ::pin_project::__private::Pin<&#lifetime mut Self>, |
| ) -> #proj_ident #proj_ty_generics { |
| unsafe { |
| #proj_body |
| } |
| } |
| #vis fn project_ref<#lifetime>( |
| self: ::pin_project::__private::Pin<&#lifetime Self>, |
| ) -> #proj_ref_ident #proj_ty_generics { |
| unsafe { |
| #proj_ref_body |
| } |
| } |
| #replace_impl |
| } |
| } |
| } |
| |
| fn ensure_not_packed(&self, fields: &Fields) -> Result<TokenStream> { |
| for meta in self.orig.attrs.iter().filter_map(|attr| attr.parse_meta().ok()) { |
| if let Meta::List(list) = meta { |
| if list.path.is_ident("repr") { |
| for repr in list.nested.iter() { |
| match repr { |
| NestedMeta::Meta(Meta::Path(path)) |
| | NestedMeta::Meta(Meta::List(MetaList { path, .. })) |
| if path.is_ident("packed") => |
| { |
| return Err(error!( |
| repr, |
| "#[pin_project] attribute may not be used on #[repr(packed)] types" |
| )); |
| } |
| _ => {} |
| } |
| } |
| } |
| } |
| } |
| |
| // As proc-macro-derive can't rewrite the structure definition, |
| // it's probably no longer necessary, but it keeps it for now. |
| |
| // 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: |
| // |
| // ```rust |
| // #[deny(safe_packed_borrows)] |
| // fn assert_not_repr_packed(val: &MyStruct) { |
| // let _field1 = &val.field1; |
| // let _field2 = &val.field2; |
| // ... |
| // let _fieldn = &val.fieldn; |
| // } |
| // ``` |
| // |
| // Taking a reference to a packed field is unsafe, and applying |
| // `#[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 an alignment 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 |
| // alignment 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. |
| // |
| // See also https://github.com/taiki-e/pin-project/pull/34. |
| let mut field_refs = vec![]; |
| match fields { |
| Fields::Named(FieldsNamed { named, .. }) => { |
| for Field { ident, .. } in named { |
| field_refs.push(quote!(&val.#ident;)); |
| } |
| } |
| Fields::Unnamed(FieldsUnnamed { unnamed, .. }) => { |
| for (index, _) in unnamed.iter().enumerate() { |
| let index = Index::from(index); |
| field_refs.push(quote!(&val.#index;)); |
| } |
| } |
| Fields::Unit => {} |
| } |
| |
| let (impl_generics, ty_generics, where_clause) = self.orig.generics.split_for_impl(); |
| let ident = self.orig.ident; |
| Ok(quote! { |
| #[deny(safe_packed_borrows)] |
| fn __assert_not_repr_packed #impl_generics (val: &#ident #ty_generics) #where_clause { |
| #(#field_refs)* |
| } |
| }) |
| } |
| } |
