diff options
Diffstat (limited to 'vendor/serde_derive/src/bound.rs')
| -rw-r--r-- | vendor/serde_derive/src/bound.rs | 408 |
1 files changed, 0 insertions, 408 deletions
diff --git a/vendor/serde_derive/src/bound.rs b/vendor/serde_derive/src/bound.rs deleted file mode 100644 index fe8ccff..0000000 --- a/vendor/serde_derive/src/bound.rs +++ /dev/null @@ -1,408 +0,0 @@ -use crate::internals::ast::{Container, Data}; -use crate::internals::{attr, ungroup}; -use proc_macro2::Span; -use std::collections::HashSet; -use syn::punctuated::{Pair, Punctuated}; -use syn::Token; - -// Remove the default from every type parameter because in the generated impls -// they look like associated types: "error: associated type bindings are not -// allowed here". -pub fn without_defaults(generics: &syn::Generics) -> syn::Generics { - syn::Generics { - params: generics - .params - .iter() - .map(|param| match param { - syn::GenericParam::Type(param) => syn::GenericParam::Type(syn::TypeParam { - eq_token: None, - default: None, - ..param.clone() - }), - _ => param.clone(), - }) - .collect(), - ..generics.clone() - } -} - -pub fn with_where_predicates( - generics: &syn::Generics, - predicates: &[syn::WherePredicate], -) -> syn::Generics { - let mut generics = generics.clone(); - generics - .make_where_clause() - .predicates - .extend(predicates.iter().cloned()); - generics -} - -pub fn with_where_predicates_from_fields( - cont: &Container, - generics: &syn::Generics, - from_field: fn(&attr::Field) -> Option<&[syn::WherePredicate]>, -) -> syn::Generics { - let predicates = cont - .data - .all_fields() - .filter_map(|field| from_field(&field.attrs)) - .flat_map(<[syn::WherePredicate]>::to_vec); - - let mut generics = generics.clone(); - generics.make_where_clause().predicates.extend(predicates); - generics -} - -pub fn with_where_predicates_from_variants( - cont: &Container, - generics: &syn::Generics, - from_variant: fn(&attr::Variant) -> Option<&[syn::WherePredicate]>, -) -> syn::Generics { - let variants = match &cont.data { - Data::Enum(variants) => variants, - Data::Struct(_, _) => { - return generics.clone(); - } - }; - - let predicates = variants - .iter() - .filter_map(|variant| from_variant(&variant.attrs)) - .flat_map(<[syn::WherePredicate]>::to_vec); - - let mut generics = generics.clone(); - generics.make_where_clause().predicates.extend(predicates); - generics -} - -// Puts the given bound on any generic type parameters that are used in fields -// for which filter returns true. -// -// For example, the following struct needs the bound `A: Serialize, B: -// Serialize`. -// -// struct S<'b, A, B: 'b, C> { -// a: A, -// b: Option<&'b B> -// #[serde(skip_serializing)] -// c: C, -// } -pub fn with_bound( - cont: &Container, - generics: &syn::Generics, - filter: fn(&attr::Field, Option<&attr::Variant>) -> bool, - bound: &syn::Path, -) -> syn::Generics { - struct FindTyParams<'ast> { - // Set of all generic type parameters on the current struct (A, B, C in - // the example). Initialized up front. - all_type_params: HashSet<syn::Ident>, - - // Set of generic type parameters used in fields for which filter - // returns true (A and B in the example). Filled in as the visitor sees - // them. - relevant_type_params: HashSet<syn::Ident>, - - // Fields whose type is an associated type of one of the generic type - // parameters. - associated_type_usage: Vec<&'ast syn::TypePath>, - } - - impl<'ast> FindTyParams<'ast> { - fn visit_field(&mut self, field: &'ast syn::Field) { - if let syn::Type::Path(ty) = ungroup(&field.ty) { - if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() { - if self.all_type_params.contains(&t.ident) { - self.associated_type_usage.push(ty); - } - } - } - self.visit_type(&field.ty); - } - - fn visit_path(&mut self, path: &'ast syn::Path) { - if let Some(seg) = path.segments.last() { - if seg.ident == "PhantomData" { - // Hardcoded exception, because PhantomData<T> implements - // Serialize and Deserialize whether or not T implements it. - return; - } - } - if path.leading_colon.is_none() && path.segments.len() == 1 { - let id = &path.segments[0].ident; - if self.all_type_params.contains(id) { - self.relevant_type_params.insert(id.clone()); - } - } - for segment in &path.segments { - self.visit_path_segment(segment); - } - } - - // Everything below is simply traversing the syntax tree. - - fn visit_type(&mut self, ty: &'ast syn::Type) { - match ty { - #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] - syn::Type::Array(ty) => self.visit_type(&ty.elem), - syn::Type::BareFn(ty) => { - for arg in &ty.inputs { - self.visit_type(&arg.ty); - } - self.visit_return_type(&ty.output); - } - syn::Type::Group(ty) => self.visit_type(&ty.elem), - syn::Type::ImplTrait(ty) => { - for bound in &ty.bounds { - self.visit_type_param_bound(bound); - } - } - syn::Type::Macro(ty) => self.visit_macro(&ty.mac), - syn::Type::Paren(ty) => self.visit_type(&ty.elem), - syn::Type::Path(ty) => { - if let Some(qself) = &ty.qself { - self.visit_type(&qself.ty); - } - self.visit_path(&ty.path); - } - syn::Type::Ptr(ty) => self.visit_type(&ty.elem), - syn::Type::Reference(ty) => self.visit_type(&ty.elem), - syn::Type::Slice(ty) => self.visit_type(&ty.elem), - syn::Type::TraitObject(ty) => { - for bound in &ty.bounds { - self.visit_type_param_bound(bound); - } - } - syn::Type::Tuple(ty) => { - for elem in &ty.elems { - self.visit_type(elem); - } - } - - syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {} - - _ => {} - } - } - - fn visit_path_segment(&mut self, segment: &'ast syn::PathSegment) { - self.visit_path_arguments(&segment.arguments); - } - - fn visit_path_arguments(&mut self, arguments: &'ast syn::PathArguments) { - match arguments { - syn::PathArguments::None => {} - syn::PathArguments::AngleBracketed(arguments) => { - for arg in &arguments.args { - match arg { - #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] - syn::GenericArgument::Type(arg) => self.visit_type(arg), - syn::GenericArgument::AssocType(arg) => self.visit_type(&arg.ty), - syn::GenericArgument::Lifetime(_) - | syn::GenericArgument::Const(_) - | syn::GenericArgument::AssocConst(_) - | syn::GenericArgument::Constraint(_) => {} - _ => {} - } - } - } - syn::PathArguments::Parenthesized(arguments) => { - for argument in &arguments.inputs { - self.visit_type(argument); - } - self.visit_return_type(&arguments.output); - } - } - } - - fn visit_return_type(&mut self, return_type: &'ast syn::ReturnType) { - match return_type { - syn::ReturnType::Default => {} - syn::ReturnType::Type(_, output) => self.visit_type(output), - } - } - - fn visit_type_param_bound(&mut self, bound: &'ast syn::TypeParamBound) { - match bound { - #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] - syn::TypeParamBound::Trait(bound) => self.visit_path(&bound.path), - syn::TypeParamBound::Lifetime(_) | syn::TypeParamBound::Verbatim(_) => {} - _ => {} - } - } - - // Type parameter should not be considered used by a macro path. - // - // struct TypeMacro<T> { - // mac: T!(), - // marker: PhantomData<T>, - // } - fn visit_macro(&mut self, _mac: &'ast syn::Macro) {} - } - - let all_type_params = generics - .type_params() - .map(|param| param.ident.clone()) - .collect(); - - let mut visitor = FindTyParams { - all_type_params, - relevant_type_params: HashSet::new(), - associated_type_usage: Vec::new(), - }; - match &cont.data { - Data::Enum(variants) => { - for variant in variants { - let relevant_fields = variant - .fields - .iter() - .filter(|field| filter(&field.attrs, Some(&variant.attrs))); - for field in relevant_fields { - visitor.visit_field(field.original); - } - } - } - Data::Struct(_, fields) => { - for field in fields.iter().filter(|field| filter(&field.attrs, None)) { - visitor.visit_field(field.original); - } - } - } - - let relevant_type_params = visitor.relevant_type_params; - let associated_type_usage = visitor.associated_type_usage; - let new_predicates = generics - .type_params() - .map(|param| param.ident.clone()) - .filter(|id| relevant_type_params.contains(id)) - .map(|id| syn::TypePath { - qself: None, - path: id.into(), - }) - .chain(associated_type_usage.into_iter().cloned()) - .map(|bounded_ty| { - syn::WherePredicate::Type(syn::PredicateType { - lifetimes: None, - // the type parameter that is being bounded e.g. T - bounded_ty: syn::Type::Path(bounded_ty), - colon_token: <Token![:]>::default(), - // the bound e.g. Serialize - bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound { - paren_token: None, - modifier: syn::TraitBoundModifier::None, - lifetimes: None, - path: bound.clone(), - })] - .into_iter() - .collect(), - }) - }); - - let mut generics = generics.clone(); - generics - .make_where_clause() - .predicates - .extend(new_predicates); - generics -} - -pub fn with_self_bound( - cont: &Container, - generics: &syn::Generics, - bound: &syn::Path, -) -> syn::Generics { - let mut generics = generics.clone(); - generics - .make_where_clause() - .predicates - .push(syn::WherePredicate::Type(syn::PredicateType { - lifetimes: None, - // the type that is being bounded e.g. MyStruct<'a, T> - bounded_ty: type_of_item(cont), - colon_token: <Token![:]>::default(), - // the bound e.g. Default - bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound { - paren_token: None, - modifier: syn::TraitBoundModifier::None, - lifetimes: None, - path: bound.clone(), - })] - .into_iter() - .collect(), - })); - generics -} - -pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics { - let bound = syn::Lifetime::new(lifetime, Span::call_site()); - let def = syn::LifetimeParam { - attrs: Vec::new(), - lifetime: bound.clone(), - colon_token: None, - bounds: Punctuated::new(), - }; - - let params = Some(syn::GenericParam::Lifetime(def)) - .into_iter() - .chain(generics.params.iter().cloned().map(|mut param| { - match &mut param { - syn::GenericParam::Lifetime(param) => { - param.bounds.push(bound.clone()); - } - syn::GenericParam::Type(param) => { - param - .bounds - .push(syn::TypeParamBound::Lifetime(bound.clone())); - } - syn::GenericParam::Const(_) => {} - } - param - })) - .collect(); - - syn::Generics { - params, - ..generics.clone() - } -} - -fn type_of_item(cont: &Container) -> syn::Type { - syn::Type::Path(syn::TypePath { - qself: None, - path: syn::Path { - leading_colon: None, - segments: vec![syn::PathSegment { - ident: cont.ident.clone(), - arguments: syn::PathArguments::AngleBracketed( - syn::AngleBracketedGenericArguments { - colon2_token: None, - lt_token: <Token![<]>::default(), - args: cont - .generics - .params - .iter() - .map(|param| match param { - syn::GenericParam::Type(param) => { - syn::GenericArgument::Type(syn::Type::Path(syn::TypePath { - qself: None, - path: param.ident.clone().into(), - })) - } - syn::GenericParam::Lifetime(param) => { - syn::GenericArgument::Lifetime(param.lifetime.clone()) - } - syn::GenericParam::Const(_) => { - panic!("Serde does not support const generics yet"); - } - }) - .collect(), - gt_token: <Token![>]>::default(), - }, - ), - }] - .into_iter() - .collect(), - }, - }) -} |