vendor/serde_derive/src/bound.rs

   1 use std::collections::HashSet;
   2
   3 use syn;
   4 use syn::punctuated::{Pair, Punctuated};
   5
   6 use internals::ast::{Container, Data};
   7 use internals::{attr, ungroup};
   8
   9 use proc_macro2::Span;
  10
  11 // Remove the default from every type parameter because in the generated impls
  12 // they look like associated types: "error: associated type bindings are not
  13 // allowed here".
  14 pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
  15     syn::Generics {
  16         params: generics
  17             .params
  18             .iter()
  19             .map(|param| match param {
  20                 syn::GenericParam::Type(param) => syn::GenericParam::Type(syn::TypeParam {
  21                     eq_token: None,
  22                     default: None,
  23                     ..param.clone()
  24                 }),
  25                 _ => param.clone(),
  26             })
  27             .collect(),
  28         ..generics.clone()
  29     }
  30 }
  31
  32 pub fn with_where_predicates(
  33     generics: &syn::Generics,
  34     predicates: &[syn::WherePredicate],
  35 ) -> syn::Generics {
  36     let mut generics = generics.clone();
  37     generics
  38         .make_where_clause()
  39         .predicates
  40         .extend(predicates.iter().cloned());
  41     generics
  42 }
  43
  44 pub fn with_where_predicates_from_fields(
  45     cont: &Container,
  46     generics: &syn::Generics,
  47     from_field: fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
  48 ) -> syn::Generics {
  49     let predicates = cont
  50         .data
  51         .all_fields()
  52         .filter_map(|field| from_field(&field.attrs))
  53         .flat_map(<[syn::WherePredicate]>::to_vec);
  54
  55     let mut generics = generics.clone();
  56     generics.make_where_clause().predicates.extend(predicates);
  57     generics
  58 }
  59
  60 pub fn with_where_predicates_from_variants(
  61     cont: &Container,
  62     generics: &syn::Generics,
  63     from_variant: fn(&attr::Variant) -> Option<&[syn::WherePredicate]>,
  64 ) -> syn::Generics {
  65     let variants = match &cont.data {
  66         Data::Enum(variants) => variants,
  67         Data::Struct(_, _) => {
  68             return generics.clone();
  69         }
  70     };
  71
  72     let predicates = variants
  73         .iter()
  74         .filter_map(|variant| from_variant(&variant.attrs))
  75         .flat_map(<[syn::WherePredicate]>::to_vec);
  76
  77     let mut generics = generics.clone();
  78     generics.make_where_clause().predicates.extend(predicates);
  79     generics
  80 }
  81
  82 // Puts the given bound on any generic type parameters that are used in fields
  83 // for which filter returns true.
  84 //
  85 // For example, the following struct needs the bound `A: Serialize, B:
  86 // Serialize`.
  87 //
  88 //     struct S<'b, A, B: 'b, C> {
  89 //         a: A,
  90 //         b: Option<&'b B>
  91 //         #[serde(skip_serializing)]
  92 //         c: C,
  93 //     }
  94 pub fn with_bound(
  95     cont: &Container,
  96     generics: &syn::Generics,
  97     filter: fn(&attr::Field, Option<&attr::Variant>) -> bool,
  98     bound: &syn::Path,
  99 ) -> syn::Generics {
 100     struct FindTyParams<'ast> {
 101         // Set of all generic type parameters on the current struct (A, B, C in
 102         // the example). Initialized up front.
 103         all_type_params: HashSet<syn::Ident>,
 104
 105         // Set of generic type parameters used in fields for which filter
 106         // returns true (A and B in the example). Filled in as the visitor sees
 107         // them.
 108         relevant_type_params: HashSet<syn::Ident>,
 109
 110         // Fields whose type is an associated type of one of the generic type
 111         // parameters.
 112         associated_type_usage: Vec<&'ast syn::TypePath>,
 113     }
 114
 115     impl<'ast> FindTyParams<'ast> {
 116         fn visit_field(&mut self, field: &'ast syn::Field) {
 117             if let syn::Type::Path(ty) = ungroup(&field.ty) {
 118                 if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
 119                     if self.all_type_params.contains(&t.ident) {
 120                         self.associated_type_usage.push(ty);
 121                     }
 122                 }
 123             }
 124             self.visit_type(&field.ty);
 125         }
 126
 127         fn visit_path(&mut self, path: &'ast syn::Path) {
 128             if let Some(seg) = path.segments.last() {
 129                 if seg.ident == "PhantomData" {
 130                     // Hardcoded exception, because PhantomData<T> implements
 131                     // Serialize and Deserialize whether or not T implements it.
 132                     return;
 133                 }
 134             }
 135             if path.leading_colon.is_none() && path.segments.len() == 1 {
 136                 let id = &path.segments[0].ident;
 137                 if self.all_type_params.contains(id) {
 138                     self.relevant_type_params.insert(id.clone());
 139                 }
 140             }
 141             for segment in &path.segments {
 142                 self.visit_path_segment(segment);
 143             }
 144         }
 145
 146         // Everything below is simply traversing the syntax tree.
 147
 148         fn visit_type(&mut self, ty: &'ast syn::Type) {
 149             match ty {
 150                 syn::Type::Array(ty) => self.visit_type(&ty.elem),
 151                 syn::Type::BareFn(ty) => {
 152                     for arg in &ty.inputs {
 153                         self.visit_type(&arg.ty);
 154                     }
 155                     self.visit_return_type(&ty.output);
 156                 }
 157                 syn::Type::Group(ty) => self.visit_type(&ty.elem),
 158                 syn::Type::ImplTrait(ty) => {
 159                     for bound in &ty.bounds {
 160                         self.visit_type_param_bound(bound);
 161                     }
 162                 }
 163                 syn::Type::Macro(ty) => self.visit_macro(&ty.mac),
 164                 syn::Type::Paren(ty) => self.visit_type(&ty.elem),
 165                 syn::Type::Path(ty) => {
 166                     if let Some(qself) = &ty.qself {
 167                         self.visit_type(&qself.ty);
 168                     }
 169                     self.visit_path(&ty.path);
 170                 }
 171                 syn::Type::Ptr(ty) => self.visit_type(&ty.elem),
 172                 syn::Type::Reference(ty) => self.visit_type(&ty.elem),
 173                 syn::Type::Slice(ty) => self.visit_type(&ty.elem),
 174                 syn::Type::TraitObject(ty) => {
 175                     for bound in &ty.bounds {
 176                         self.visit_type_param_bound(bound);
 177                     }
 178                 }
 179                 syn::Type::Tuple(ty) => {
 180                     for elem in &ty.elems {
 181                         self.visit_type(elem);
 182                     }
 183                 }
 184
 185                 syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}
 186
 187                 #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
 188                 _ => {}
 189             }
 190         }
 191
 192         fn visit_path_segment(&mut self, segment: &'ast syn::PathSegment) {
 193             self.visit_path_arguments(&segment.arguments);
 194         }
 195
 196         fn visit_path_arguments(&mut self, arguments: &'ast syn::PathArguments) {
 197             match arguments {
 198                 syn::PathArguments::None => {}
 199                 syn::PathArguments::AngleBracketed(arguments) => {
 200                     for arg in &arguments.args {
 201                         match arg {
 202                             syn::GenericArgument::Type(arg) => self.visit_type(arg),
 203                             syn::GenericArgument::Binding(arg) => self.visit_type(&arg.ty),
 204                             syn::GenericArgument::Lifetime(_)
 205                             | syn::GenericArgument::Constraint(_)
 206                             | syn::GenericArgument::Const(_) => {}
 207                         }
 208                     }
 209                 }
 210                 syn::PathArguments::Parenthesized(arguments) => {
 211                     for argument in &arguments.inputs {
 212                         self.visit_type(argument);
 213                     }
 214                     self.visit_return_type(&arguments.output);
 215                 }
 216             }
 217         }
 218
 219         fn visit_return_type(&mut self, return_type: &'ast syn::ReturnType) {
 220             match return_type {
 221                 syn::ReturnType::Default => {}
 222                 syn::ReturnType::Type(_, output) => self.visit_type(output),
 223             }
 224         }
 225
 226         fn visit_type_param_bound(&mut self, bound: &'ast syn::TypeParamBound) {
 227             match bound {
 228                 syn::TypeParamBound::Trait(bound) => self.visit_path(&bound.path),
 229                 syn::TypeParamBound::Lifetime(_) => {}
 230             }
 231         }
 232
 233         // Type parameter should not be considered used by a macro path.
 234         //
 235         //     struct TypeMacro<T> {
 236         //         mac: T!(),
 237         //         marker: PhantomData<T>,
 238         //     }
 239         fn visit_macro(&mut self, _mac: &'ast syn::Macro) {}
 240     }
 241
 242     let all_type_params = generics
 243         .type_params()
 244         .map(|param| param.ident.clone())
 245         .collect();
 246
 247     let mut visitor = FindTyParams {
 248         all_type_params,
 249         relevant_type_params: HashSet::new(),
 250         associated_type_usage: Vec::new(),
 251     };
 252     match &cont.data {
 253         Data::Enum(variants) => {
 254             for variant in variants.iter() {
 255                 let relevant_fields = variant
 256                     .fields
 257                     .iter()
 258                     .filter(|field| filter(&field.attrs, Some(&variant.attrs)));
 259                 for field in relevant_fields {
 260                     visitor.visit_field(field.original);
 261                 }
 262             }
 263         }
 264         Data::Struct(_, fields) => {
 265             for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
 266                 visitor.visit_field(field.original);
 267             }
 268         }
 269     }
 270
 271     let relevant_type_params = visitor.relevant_type_params;
 272     let associated_type_usage = visitor.associated_type_usage;
 273     let new_predicates = generics
 274         .type_params()
 275         .map(|param| param.ident.clone())
 276         .filter(|id| relevant_type_params.contains(id))
 277         .map(|id| syn::TypePath {
 278             qself: None,
 279             path: id.into(),
 280         })
 281         .chain(associated_type_usage.into_iter().cloned())
 282         .map(|bounded_ty| {
 283             syn::WherePredicate::Type(syn::PredicateType {
 284                 lifetimes: None,
 285                 // the type parameter that is being bounded e.g. T
 286                 bounded_ty: syn::Type::Path(bounded_ty),
 287                 colon_token: <Token![:]>::default(),
 288                 // the bound e.g. Serialize
 289                 bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
 290                     paren_token: None,
 291                     modifier: syn::TraitBoundModifier::None,
 292                     lifetimes: None,
 293                     path: bound.clone(),
 294                 })]
 295                 .into_iter()
 296                 .collect(),
 297             })
 298         });
 299
 300     let mut generics = generics.clone();
 301     generics
 302         .make_where_clause()
 303         .predicates
 304         .extend(new_predicates);
 305     generics
 306 }
 307
 308 pub fn with_self_bound(
 309     cont: &Container,
 310     generics: &syn::Generics,
 311     bound: &syn::Path,
 312 ) -> syn::Generics {
 313     let mut generics = generics.clone();
 314     generics
 315         .make_where_clause()
 316         .predicates
 317         .push(syn::WherePredicate::Type(syn::PredicateType {
 318             lifetimes: None,
 319             // the type that is being bounded e.g. MyStruct<'a, T>
 320             bounded_ty: type_of_item(cont),
 321             colon_token: <Token![:]>::default(),
 322             // the bound e.g. Default
 323             bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
 324                 paren_token: None,
 325                 modifier: syn::TraitBoundModifier::None,
 326                 lifetimes: None,
 327                 path: bound.clone(),
 328             })]
 329             .into_iter()
 330             .collect(),
 331         }));
 332     generics
 333 }
 334
 335 pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics {
 336     let bound = syn::Lifetime::new(lifetime, Span::call_site());
 337     let def = syn::LifetimeDef {
 338         attrs: Vec::new(),
 339         lifetime: bound.clone(),
 340         colon_token: None,
 341         bounds: Punctuated::new(),
 342     };
 343
 344     let params = Some(syn::GenericParam::Lifetime(def))
 345         .into_iter()
 346         .chain(generics.params.iter().cloned().map(|mut param| {
 347             match &mut param {
 348                 syn::GenericParam::Lifetime(param) => {
 349                     param.bounds.push(bound.clone());
 350                 }
 351                 syn::GenericParam::Type(param) => {
 352                     param
 353                         .bounds
 354                         .push(syn::TypeParamBound::Lifetime(bound.clone()));
 355                 }
 356                 syn::GenericParam::Const(_) => {}
 357             }
 358             param
 359         }))
 360         .collect();
 361
 362     syn::Generics {
 363         params,
 364         ..generics.clone()
 365     }
 366 }
 367
 368 fn type_of_item(cont: &Container) -> syn::Type {
 369     syn::Type::Path(syn::TypePath {
 370         qself: None,
 371         path: syn::Path {
 372             leading_colon: None,
 373             segments: vec![syn::PathSegment {
 374                 ident: cont.ident.clone(),
 375                 arguments: syn::PathArguments::AngleBracketed(
 376                     syn::AngleBracketedGenericArguments {
 377                         colon2_token: None,
 378                         lt_token: <Token![<]>::default(),
 379                         args: cont
 380                             .generics
 381                             .params
 382                             .iter()
 383                             .map(|param| match param {
 384                                 syn::GenericParam::Type(param) => {
 385                                     syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
 386                                         qself: None,
 387                                         path: param.ident.clone().into(),
 388                                     }))
 389                                 }
 390                                 syn::GenericParam::Lifetime(param) => {
 391                                     syn::GenericArgument::Lifetime(param.lifetime.clone())
 392                                 }
 393                                 syn::GenericParam::Const(_) => {
 394                                     panic!("Serde does not support const generics yet");
 395                                 }
 396                             })
 397                             .collect(),
 398                         gt_token: <Token![>]>::default(),
 399                     },
 400                 ),
 401             }]
 402             .into_iter()
 403             .collect(),
 404         },
 405     })
 406 }