| use std::{iter::FromIterator, mem}; |
| |
| use proc_macro2::{Group, Spacing, Span, TokenStream, TokenTree}; |
| use quote::{quote, quote_spanned, ToTokens}; |
| use syn::{ |
| parse::{Parse, ParseBuffer, ParseStream}, |
| parse_quote, |
| punctuated::Punctuated, |
| token, |
| visit_mut::{self, VisitMut}, |
| Attribute, ExprPath, ExprStruct, Generics, Ident, Item, Lifetime, LifetimeDef, Macro, PatPath, |
| PatStruct, PatTupleStruct, Path, PathArguments, PredicateType, QSelf, Result, Token, Type, |
| TypeParamBound, TypePath, Variant, Visibility, WherePredicate, |
| }; |
| |
| pub(crate) type Variants = Punctuated<Variant, Token![,]>; |
| |
| macro_rules! format_err { |
| ($span:expr, $msg:expr $(,)?) => { |
| syn::Error::new_spanned(&$span as &dyn quote::ToTokens, &$msg as &dyn std::fmt::Display) |
| }; |
| ($span:expr, $($tt:tt)*) => { |
| format_err!($span, format!($($tt)*)) |
| }; |
| } |
| |
| macro_rules! bail { |
| ($($tt:tt)*) => { |
| return Err(format_err!($($tt)*)) |
| }; |
| } |
| |
| macro_rules! parse_quote_spanned { |
| ($span:expr => $($tt:tt)*) => { |
| syn::parse2(quote::quote_spanned!($span => $($tt)*)).unwrap_or_else(|e| panic!("{}", e)) |
| }; |
| } |
| |
| /// Determines the lifetime names. Ensure it doesn't overlap with any existing |
| /// lifetime names. |
| pub(crate) fn determine_lifetime_name(lifetime_name: &mut String, generics: &mut Generics) { |
| struct CollectLifetimes(Vec<String>); |
| |
| impl VisitMut for CollectLifetimes { |
| fn visit_lifetime_def_mut(&mut self, def: &mut LifetimeDef) { |
| self.0.push(def.lifetime.to_string()); |
| } |
| } |
| |
| debug_assert!(lifetime_name.starts_with('\'')); |
| |
| let mut lifetimes = CollectLifetimes(Vec::new()); |
| lifetimes.visit_generics_mut(generics); |
| |
| while lifetimes.0.iter().any(|name| name.starts_with(&**lifetime_name)) { |
| lifetime_name.push('_'); |
| } |
| } |
| |
| /// Like `insert_lifetime`, but also generates a bound of the form |
| /// `OriginalType<A, B>: 'lifetime`. Used when generating the definition |
| /// of a projection type |
| pub(crate) fn insert_lifetime_and_bound( |
| generics: &mut Generics, |
| lifetime: Lifetime, |
| orig_generics: &Generics, |
| orig_ident: &Ident, |
| ) -> WherePredicate { |
| insert_lifetime(generics, lifetime.clone()); |
| |
| let orig_type: Type = parse_quote!(#orig_ident #orig_generics); |
| let mut punct = Punctuated::new(); |
| punct.push(TypeParamBound::Lifetime(lifetime)); |
| |
| WherePredicate::Type(PredicateType { |
| lifetimes: None, |
| bounded_ty: orig_type, |
| colon_token: <Token![:]>::default(), |
| bounds: punct, |
| }) |
| } |
| |
| /// Inserts a `lifetime` at position `0` of `generics.params`. |
| pub(crate) fn insert_lifetime(generics: &mut Generics, lifetime: Lifetime) { |
| generics.lt_token.get_or_insert_with(<Token![<]>::default); |
| generics.gt_token.get_or_insert_with(<Token![>]>::default); |
| generics.params.insert(0, LifetimeDef::new(lifetime).into()); |
| } |
| |
| /// Determines the visibility of the projected types and projection methods. |
| /// |
| /// If given visibility is `pub`, returned visibility is `pub(crate)`. |
| /// Otherwise, returned visibility is the same as given visibility. |
| pub(crate) fn determine_visibility(vis: &Visibility) -> Visibility { |
| if let Visibility::Public(token) = vis { |
| parse_quote_spanned!(token.pub_token.span => pub(crate)) |
| } else { |
| vis.clone() |
| } |
| } |
| |
| /// Checks if `tokens` is an empty `TokenStream`. |
| /// |
| /// This is almost equivalent to `syn::parse2::<Nothing>()`, but produces |
| /// a better error message and does not require ownership of `tokens`. |
| pub(crate) fn parse_as_empty(tokens: &TokenStream) -> Result<()> { |
| if tokens.is_empty() { |
| Ok(()) |
| } else { |
| bail!(tokens, "unexpected token: `{}`", tokens) |
| } |
| } |
| |
| pub(crate) fn respan<T>(node: &T, span: Span) -> T |
| where |
| T: ToTokens + Parse, |
| { |
| let tokens = node.to_token_stream(); |
| let respanned = respan_tokens(tokens, span); |
| syn::parse2(respanned).unwrap() |
| } |
| |
| fn respan_tokens(tokens: TokenStream, span: Span) -> TokenStream { |
| tokens |
| .into_iter() |
| .map(|mut token| { |
| token.set_span(span); |
| token |
| }) |
| .collect() |
| } |
| |
| // ================================================================================================= |
| // extension traits |
| |
| pub(crate) trait SliceExt { |
| fn position_exact(&self, ident: &str) -> Result<Option<usize>>; |
| fn find(&self, ident: &str) -> Option<&Attribute>; |
| } |
| |
| impl SliceExt for [Attribute] { |
| /// # Errors |
| /// |
| /// - There are multiple specified attributes. |
| /// - The `Attribute::tokens` field of the specified attribute is not empty. |
| fn position_exact(&self, ident: &str) -> Result<Option<usize>> { |
| self.iter() |
| .try_fold((0, None), |(i, mut prev), attr| { |
| if attr.path.is_ident(ident) { |
| if prev.replace(i).is_some() { |
| bail!(attr, "duplicate #[{}] attribute", ident); |
| } |
| parse_as_empty(&attr.tokens)?; |
| } |
| Ok((i + 1, prev)) |
| }) |
| .map(|(_, pos)| pos) |
| } |
| |
| fn find(&self, ident: &str) -> Option<&Attribute> { |
| self.iter().position(|attr| attr.path.is_ident(ident)).map(|i| &self[i]) |
| } |
| } |
| |
| pub(crate) trait ParseBufferExt<'a> { |
| fn parenthesized(self) -> Result<ParseBuffer<'a>>; |
| } |
| |
| impl<'a> ParseBufferExt<'a> for ParseStream<'a> { |
| fn parenthesized(self) -> Result<ParseBuffer<'a>> { |
| let content; |
| let _: token::Paren = syn::parenthesized!(content in self); |
| Ok(content) |
| } |
| } |
| |
| impl<'a> ParseBufferExt<'a> for ParseBuffer<'a> { |
| fn parenthesized(self) -> Result<ParseBuffer<'a>> { |
| let content; |
| let _: token::Paren = syn::parenthesized!(content in self); |
| Ok(content) |
| } |
| } |
| |
| // ================================================================================================= |
| // visitors |
| |
| // Replace `self`/`Self` with `__self`/`self_ty`. |
| // Based on: |
| // - https://github.com/dtolnay/async-trait/blob/0.1.35/src/receiver.rs |
| // - https://github.com/dtolnay/async-trait/commit/6029cbf375c562ca98fa5748e9d950a8ff93b0e7 |
| |
| pub(crate) struct ReplaceReceiver<'a>(pub(crate) &'a TypePath); |
| |
| impl ReplaceReceiver<'_> { |
| fn self_ty(&self, span: Span) -> TypePath { |
| respan(self.0, span) |
| } |
| |
| fn self_to_qself(&self, qself: &mut Option<QSelf>, path: &mut Path) { |
| if path.leading_colon.is_some() { |
| return; |
| } |
| |
| let first = &path.segments[0]; |
| if first.ident != "Self" || !first.arguments.is_empty() { |
| return; |
| } |
| |
| if path.segments.len() == 1 { |
| self.self_to_expr_path(path); |
| return; |
| } |
| |
| let span = first.ident.span(); |
| *qself = Some(QSelf { |
| lt_token: Token, |
| ty: Box::new(self.self_ty(span).into()), |
| position: 0, |
| as_token: None, |
| gt_token: Token, |
| }); |
| |
| path.leading_colon = Some(**path.segments.pairs().next().unwrap().punct().unwrap()); |
| |
| let segments = mem::replace(&mut path.segments, Punctuated::new()); |
| path.segments = segments.into_pairs().skip(1).collect(); |
| } |
| |
| fn self_to_expr_path(&self, path: &mut Path) { |
| if path.leading_colon.is_some() { |
| return; |
| } |
| |
| let first = &path.segments[0]; |
| if first.ident != "Self" || !first.arguments.is_empty() { |
| return; |
| } |
| |
| let self_ty = self.self_ty(first.ident.span()); |
| let variant = mem::replace(path, self_ty.path); |
| for segment in &mut path.segments { |
| if let PathArguments::AngleBracketed(bracketed) = &mut segment.arguments { |
| if bracketed.colon2_token.is_none() && !bracketed.args.is_empty() { |
| bracketed.colon2_token = Some(<Token![::]>::default()); |
| } |
| } |
| } |
| if variant.segments.len() > 1 { |
| path.segments.push_punct(<Token![::]>::default()); |
| path.segments.extend(variant.segments.into_pairs().skip(1)); |
| } |
| } |
| |
| fn visit_token_stream(&self, tokens: &mut TokenStream) -> bool { |
| let mut out = Vec::new(); |
| let mut modified = false; |
| let mut iter = tokens.clone().into_iter().peekable(); |
| while let Some(tt) = iter.next() { |
| match tt { |
| TokenTree::Ident(mut ident) => { |
| modified |= prepend_underscore_to_self(&mut ident); |
| if ident == "Self" { |
| modified = true; |
| let self_ty = self.self_ty(ident.span()); |
| match iter.peek() { |
| Some(TokenTree::Punct(p)) |
| if p.as_char() == ':' && p.spacing() == Spacing::Joint => |
| { |
| let next = iter.next().unwrap(); |
| match iter.peek() { |
| Some(TokenTree::Punct(p)) if p.as_char() == ':' => { |
| let span = ident.span(); |
| out.extend(quote_spanned!(span=> <#self_ty>)); |
| } |
| _ => out.extend(quote!(#self_ty)), |
| } |
| out.push(next); |
| } |
| _ => out.extend(quote!(#self_ty)), |
| } |
| } else { |
| out.push(TokenTree::Ident(ident)); |
| } |
| } |
| TokenTree::Group(group) => { |
| let mut content = group.stream(); |
| modified |= self.visit_token_stream(&mut content); |
| let mut new = Group::new(group.delimiter(), content); |
| new.set_span(group.span()); |
| out.push(TokenTree::Group(new)); |
| } |
| other => out.push(other), |
| } |
| } |
| if modified { |
| *tokens = TokenStream::from_iter(out); |
| } |
| modified |
| } |
| } |
| |
| impl VisitMut for ReplaceReceiver<'_> { |
| // `Self` -> `Receiver` |
| fn visit_type_mut(&mut self, ty: &mut Type) { |
| if let Type::Path(node) = ty { |
| if node.qself.is_none() && node.path.is_ident("Self") { |
| *ty = self.self_ty(node.path.segments[0].ident.span()).into(); |
| } else { |
| self.visit_type_path_mut(node); |
| } |
| } else { |
| visit_mut::visit_type_mut(self, ty); |
| } |
| } |
| |
| // `Self::Assoc` -> `<Receiver>::Assoc` |
| fn visit_type_path_mut(&mut self, ty: &mut TypePath) { |
| if ty.qself.is_none() { |
| self.self_to_qself(&mut ty.qself, &mut ty.path); |
| } |
| visit_mut::visit_type_path_mut(self, ty); |
| } |
| |
| // `Self::method` -> `<Receiver>::method` |
| fn visit_expr_path_mut(&mut self, expr: &mut ExprPath) { |
| if expr.qself.is_none() { |
| self.self_to_qself(&mut expr.qself, &mut expr.path); |
| } |
| visit_mut::visit_expr_path_mut(self, expr); |
| } |
| |
| fn visit_expr_struct_mut(&mut self, expr: &mut ExprStruct) { |
| self.self_to_expr_path(&mut expr.path); |
| visit_mut::visit_expr_struct_mut(self, expr); |
| } |
| |
| fn visit_pat_path_mut(&mut self, pat: &mut PatPath) { |
| if pat.qself.is_none() { |
| self.self_to_qself(&mut pat.qself, &mut pat.path); |
| } |
| visit_mut::visit_pat_path_mut(self, pat); |
| } |
| |
| fn visit_pat_struct_mut(&mut self, pat: &mut PatStruct) { |
| self.self_to_expr_path(&mut pat.path); |
| visit_mut::visit_pat_struct_mut(self, pat); |
| } |
| |
| fn visit_pat_tuple_struct_mut(&mut self, pat: &mut PatTupleStruct) { |
| self.self_to_expr_path(&mut pat.path); |
| visit_mut::visit_pat_tuple_struct_mut(self, pat); |
| } |
| |
| fn visit_path_mut(&mut self, path: &mut Path) { |
| if path.segments.len() == 1 { |
| // Replace `self`, but not `self::function`. |
| prepend_underscore_to_self(&mut path.segments[0].ident); |
| } |
| for segment in &mut path.segments { |
| self.visit_path_arguments_mut(&mut segment.arguments); |
| } |
| } |
| |
| fn visit_item_mut(&mut self, item: &mut Item) { |
| match item { |
| // Visit `macro_rules!` because locally defined macros can refer to `self`. |
| Item::Macro(item) if item.mac.path.is_ident("macro_rules") => { |
| self.visit_macro_mut(&mut item.mac); |
| } |
| // Otherwise, do not recurse into nested items. |
| _ => {} |
| } |
| } |
| |
| fn visit_macro_mut(&mut self, mac: &mut Macro) { |
| // We can't tell in general whether `self` inside a macro invocation |
| // refers to the self in the argument list or a different self |
| // introduced within the macro. Heuristic: if the macro input contains |
| // `fn`, then `self` is more likely to refer to something other than the |
| // outer function's self argument. |
| if !contains_fn(mac.tokens.clone()) { |
| self.visit_token_stream(&mut mac.tokens); |
| } |
| } |
| } |
| |
| fn contains_fn(tokens: TokenStream) -> bool { |
| tokens.into_iter().any(|tt| match tt { |
| TokenTree::Ident(ident) => ident == "fn", |
| TokenTree::Group(group) => contains_fn(group.stream()), |
| _ => false, |
| }) |
| } |
| |
| pub(crate) fn prepend_underscore_to_self(ident: &mut Ident) -> bool { |
| let modified = ident == "self"; |
| if modified { |
| *ident = Ident::new("__self", ident.span()); |
| } |
| modified |
| } |
