diff options
Diffstat (limited to 'vendor/serde_derive/src/internals/receiver.rs')
| -rw-r--r-- | vendor/serde_derive/src/internals/receiver.rs | 292 |
1 files changed, 0 insertions, 292 deletions
diff --git a/vendor/serde_derive/src/internals/receiver.rs b/vendor/serde_derive/src/internals/receiver.rs deleted file mode 100644 index fa2a77d..0000000 --- a/vendor/serde_derive/src/internals/receiver.rs +++ /dev/null @@ -1,292 +0,0 @@ -use crate::internals::respan::respan; -use proc_macro2::Span; -use quote::ToTokens; -use std::mem; -use syn::punctuated::Punctuated; -use syn::{ - parse_quote, Data, DeriveInput, Expr, ExprPath, GenericArgument, GenericParam, Generics, Macro, - Path, PathArguments, QSelf, ReturnType, Token, Type, TypeParamBound, TypePath, WherePredicate, -}; - -pub fn replace_receiver(input: &mut DeriveInput) { - let self_ty = { - let ident = &input.ident; - let ty_generics = input.generics.split_for_impl().1; - 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); -} - -struct ReplaceReceiver<'a>(&'a TypePath); - -impl ReplaceReceiver<'_> { - fn self_ty(&self, span: Span) -> TypePath { - let tokens = self.0.to_token_stream(); - let respanned = respan(tokens, span); - syn::parse2(respanned).unwrap() - } - - fn self_to_qself(&self, qself: &mut Option<QSelf>, path: &mut Path) { - if path.leading_colon.is_some() || path.segments[0].ident != "Self" { - return; - } - - if path.segments.len() == 1 { - self.self_to_expr_path(path); - return; - } - - let span = path.segments[0].ident.span(); - *qself = Some(QSelf { - lt_token: Token, - ty: Box::new(Type::Path(self.self_ty(span))), - 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) { - let self_ty = self.self_ty(path.segments[0].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)); - } - } -} - -impl ReplaceReceiver<'_> { - // `Self` -> `Receiver` - fn visit_type_mut(&mut self, ty: &mut Type) { - let span = if let Type::Path(node) = ty { - if node.qself.is_none() && node.path.is_ident("Self") { - node.path.segments[0].ident.span() - } else { - self.visit_type_path_mut(node); - return; - } - } else { - self.visit_type_mut_impl(ty); - return; - }; - *ty = self.self_ty(span).into(); - } - - // `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); - } - self.visit_type_path_mut_impl(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); - } - self.visit_expr_path_mut_impl(expr); - } - - // Everything below is simply traversing the syntax tree. - - fn visit_type_mut_impl(&mut self, ty: &mut Type) { - match ty { - #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] - Type::Array(ty) => { - self.visit_type_mut(&mut ty.elem); - self.visit_expr_mut(&mut ty.len); - } - Type::BareFn(ty) => { - for arg in &mut ty.inputs { - self.visit_type_mut(&mut arg.ty); - } - self.visit_return_type_mut(&mut ty.output); - } - Type::Group(ty) => self.visit_type_mut(&mut ty.elem), - Type::ImplTrait(ty) => { - for bound in &mut ty.bounds { - self.visit_type_param_bound_mut(bound); - } - } - Type::Macro(ty) => self.visit_macro_mut(&mut ty.mac), - Type::Paren(ty) => self.visit_type_mut(&mut ty.elem), - Type::Path(ty) => { - if let Some(qself) = &mut ty.qself { - self.visit_type_mut(&mut qself.ty); - } - self.visit_path_mut(&mut ty.path); - } - Type::Ptr(ty) => self.visit_type_mut(&mut ty.elem), - Type::Reference(ty) => self.visit_type_mut(&mut ty.elem), - Type::Slice(ty) => self.visit_type_mut(&mut ty.elem), - Type::TraitObject(ty) => { - for bound in &mut ty.bounds { - self.visit_type_param_bound_mut(bound); - } - } - Type::Tuple(ty) => { - for elem in &mut ty.elems { - self.visit_type_mut(elem); - } - } - - Type::Infer(_) | Type::Never(_) | Type::Verbatim(_) => {} - - _ => {} - } - } - - fn visit_type_path_mut_impl(&mut self, ty: &mut TypePath) { - if let Some(qself) = &mut ty.qself { - self.visit_type_mut(&mut qself.ty); - } - self.visit_path_mut(&mut ty.path); - } - - fn visit_expr_path_mut_impl(&mut self, expr: &mut ExprPath) { - if let Some(qself) = &mut expr.qself { - self.visit_type_mut(&mut qself.ty); - } - self.visit_path_mut(&mut expr.path); - } - - fn visit_path_mut(&mut self, path: &mut Path) { - for segment in &mut path.segments { - self.visit_path_arguments_mut(&mut segment.arguments); - } - } - - fn visit_path_arguments_mut(&mut self, arguments: &mut PathArguments) { - match arguments { - PathArguments::None => {} - PathArguments::AngleBracketed(arguments) => { - for arg in &mut arguments.args { - match arg { - #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] - GenericArgument::Type(arg) => self.visit_type_mut(arg), - GenericArgument::AssocType(arg) => self.visit_type_mut(&mut arg.ty), - GenericArgument::Lifetime(_) - | GenericArgument::Const(_) - | GenericArgument::AssocConst(_) - | GenericArgument::Constraint(_) => {} - _ => {} - } - } - } - PathArguments::Parenthesized(arguments) => { - for argument in &mut arguments.inputs { - self.visit_type_mut(argument); - } - self.visit_return_type_mut(&mut arguments.output); - } - } - } - - fn visit_return_type_mut(&mut self, return_type: &mut ReturnType) { - match return_type { - ReturnType::Default => {} - ReturnType::Type(_, output) => self.visit_type_mut(output), - } - } - - fn visit_type_param_bound_mut(&mut self, bound: &mut TypeParamBound) { - match bound { - #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] - TypeParamBound::Trait(bound) => self.visit_path_mut(&mut bound.path), - TypeParamBound::Lifetime(_) | TypeParamBound::Verbatim(_) => {} - _ => {} - } - } - - fn visit_generics_mut(&mut self, generics: &mut Generics) { - for param in &mut generics.params { - match param { - GenericParam::Type(param) => { - for bound in &mut param.bounds { - self.visit_type_param_bound_mut(bound); - } - } - GenericParam::Lifetime(_) | GenericParam::Const(_) => {} - } - } - if let Some(where_clause) = &mut generics.where_clause { - for predicate in &mut where_clause.predicates { - match predicate { - #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] - WherePredicate::Type(predicate) => { - self.visit_type_mut(&mut predicate.bounded_ty); - for bound in &mut predicate.bounds { - self.visit_type_param_bound_mut(bound); - } - } - WherePredicate::Lifetime(_) => {} - _ => {} - } - } - } - } - - fn visit_data_mut(&mut self, data: &mut Data) { - match data { - Data::Struct(data) => { - for field in &mut data.fields { - self.visit_type_mut(&mut field.ty); - } - } - Data::Enum(data) => { - for variant in &mut data.variants { - for field in &mut variant.fields { - self.visit_type_mut(&mut field.ty); - } - } - } - Data::Union(_) => {} - } - } - - fn visit_expr_mut(&mut self, expr: &mut Expr) { - match expr { - Expr::Binary(expr) => { - self.visit_expr_mut(&mut expr.left); - self.visit_expr_mut(&mut expr.right); - } - Expr::Call(expr) => { - self.visit_expr_mut(&mut expr.func); - for arg in &mut expr.args { - self.visit_expr_mut(arg); - } - } - Expr::Cast(expr) => { - self.visit_expr_mut(&mut expr.expr); - self.visit_type_mut(&mut expr.ty); - } - Expr::Field(expr) => self.visit_expr_mut(&mut expr.base), - Expr::Index(expr) => { - self.visit_expr_mut(&mut expr.expr); - self.visit_expr_mut(&mut expr.index); - } - Expr::Paren(expr) => self.visit_expr_mut(&mut expr.expr), - Expr::Path(expr) => self.visit_expr_path_mut(expr), - Expr::Unary(expr) => self.visit_expr_mut(&mut expr.expr), - _ => {} - } - } - - fn visit_macro_mut(&mut self, _mac: &mut Macro) {} -} |