vendor/serde_derive-1.0.15/src/de.rs

   1 // Copyright 2017 Serde Developers
   2 //
   3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   6 // option. This file may not be copied, modified, or distributed
   7 // except according to those terms.
   8
   9 use syn::{self, Ident};
  10 use quote::{self, Tokens, ToTokens};
  11
  12 use bound;
  13 use fragment::{Fragment, Expr, Stmts, Match};
  14 use internals::ast::{Body, Container, Field, Style, Variant};
  15 use internals::{self, attr};
  16
  17 use std::collections::BTreeSet;
  18
  19 pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<Tokens, String> {
  20     let ctxt = internals::Ctxt::new();
  21     let cont = Container::from_ast(&ctxt, input);
  22     try!(ctxt.check());
  23
  24     let ident = &cont.ident;
  25     let params = Parameters::new(&cont);
  26     let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(&params);
  27     let dummy_const = Ident::new(format!("_IMPL_DESERIALIZE_FOR_{}", ident));
  28     let body = Stmts(deserialize_body(&cont, &params));
  29     let delife = params.borrowed.de_lifetime();
  30
  31     let impl_block = if let Some(remote) = cont.attrs.remote() {
  32         let vis = &input.vis;
  33         quote! {
  34             impl #de_impl_generics #ident #ty_generics #where_clause {
  35                 #vis fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<#remote #ty_generics, __D::Error>
  36                     where __D: _serde::Deserializer<#delife>
  37                 {
  38                     #body
  39                 }
  40             }
  41         }
  42     } else {
  43         quote! {
  44             #[automatically_derived]
  45             impl #de_impl_generics _serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
  46                 fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
  47                     where __D: _serde::Deserializer<#delife>
  48                 {
  49                     #body
  50                 }
  51             }
  52         }
  53     };
  54
  55     let generated = quote! {
  56         #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
  57         const #dummy_const: () = {
  58             extern crate serde as _serde;
  59             #impl_block
  60         };
  61     };
  62     Ok(generated)
  63 }
  64
  65 struct Parameters {
  66     /// Name of the type the `derive` is on.
  67     local: syn::Ident,
  68
  69     /// Path to the type the impl is for. Either a single `Ident` for local
  70     /// types or `some::remote::Ident` for remote types. Does not include
  71     /// generic parameters.
  72     this: syn::Path,
  73
  74     /// Generics including any explicit and inferred bounds for the impl.
  75     generics: syn::Generics,
  76
  77     /// Lifetimes borrowed from the deserializer. These will become bounds on
  78     /// the `'de` lifetime of the deserializer.
  79     borrowed: BorrowedLifetimes,
  80
  81     /// At least one field has a serde(getter) attribute, implying that the
  82     /// remote type has a private field.
  83     has_getter: bool,
  84 }
  85
  86 impl Parameters {
  87     fn new(cont: &Container) -> Self {
  88         let local = cont.ident.clone();
  89         let this = match cont.attrs.remote() {
  90             Some(remote) => remote.clone(),
  91             None => cont.ident.clone().into(),
  92         };
  93         let borrowed = borrowed_lifetimes(cont);
  94         let generics = build_generics(cont, &borrowed);
  95         let has_getter = cont.body.has_getter();
  96
  97         Parameters {
  98             local: local,
  99             this: this,
 100             generics: generics,
 101             borrowed: borrowed,
 102             has_getter: has_getter,
 103         }
 104     }
 105
 106     /// Type name to use in error messages and `&'static str` arguments to
 107     /// various Deserializer methods.
 108     fn type_name(&self) -> &str {
 109         self.this.segments.last().unwrap().ident.as_ref()
 110     }
 111 }
 112
 113 // All the generics in the input, plus a bound `T: Deserialize` for each generic
 114 // field type that will be deserialized by us, plus a bound `T: Default` for
 115 // each generic field type that will be set to a default value.
 116 fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generics {
 117     let generics = bound::without_defaults(cont.generics);
 118
 119     let generics = bound::with_where_predicates_from_fields(cont, &generics, attr::Field::de_bound);
 120
 121     match cont.attrs.de_bound() {
 122         Some(predicates) => bound::with_where_predicates(&generics, predicates),
 123         None => {
 124             let generics = match *cont.attrs.default() {
 125                 attr::Default::Default => {
 126                     bound::with_self_bound(cont, &generics, &path!(_serde::export::Default))
 127                 }
 128                 attr::Default::None |
 129                 attr::Default::Path(_) => generics,
 130             };
 131
 132             let delife = borrowed.de_lifetime();
 133             let generics = bound::with_bound(
 134                 cont,
 135                 &generics,
 136                 needs_deserialize_bound,
 137                 &path!(_serde::Deserialize<#delife>),
 138             );
 139
 140             bound::with_bound(
 141                 cont,
 142                 &generics,
 143                 requires_default,
 144                 &path!(_serde::export::Default),
 145             )
 146         }
 147     }
 148 }
 149
 150 // Fields with a `skip_deserializing` or `deserialize_with` attribute are not
 151 // deserialized by us so we do not generate a bound. Fields with a `bound`
 152 // attribute specify their own bound so we do not generate one. All other fields
 153 // may need a `T: Deserialize` bound where T is the type of the field.
 154 fn needs_deserialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
 155     !field.skip_deserializing() &&
 156     field.deserialize_with().is_none() &&
 157     field.de_bound().is_none() &&
 158     variant.map_or(true, |variant| variant.deserialize_with().is_none())
 159 }
 160
 161 // Fields with a `default` attribute (not `default=...`), and fields with a
 162 // `skip_deserializing` attribute that do not also have `default=...`.
 163 fn requires_default(field: &attr::Field, _variant: Option<&attr::Variant>) -> bool {
 164     field.default() == &attr::Default::Default
 165 }
 166
 167 enum BorrowedLifetimes {
 168     Borrowed(BTreeSet<syn::Lifetime>),
 169     Static,
 170 }
 171
 172 impl BorrowedLifetimes {
 173     fn de_lifetime(&self) -> syn::Lifetime {
 174         match *self {
 175             BorrowedLifetimes::Borrowed(_) => syn::Lifetime::new("'de"),
 176             BorrowedLifetimes::Static => syn::Lifetime::new("'static"),
 177         }
 178     }
 179
 180     fn de_lifetime_def(&self) -> Option<syn::LifetimeDef> {
 181         match *self {
 182             BorrowedLifetimes::Borrowed(ref bounds) => {
 183                 Some(syn::LifetimeDef {
 184                     attrs: Vec::new(),
 185                     lifetime: syn::Lifetime::new("'de"),
 186                     bounds: bounds.iter().cloned().collect(),
 187                 })
 188             }
 189             BorrowedLifetimes::Static => None,
 190         }
 191     }
 192 }
 193
 194 // The union of lifetimes borrowed by each field of the container.
 195 //
 196 // These turn into bounds on the `'de` lifetime of the Deserialize impl. If
 197 // lifetimes `'a` and `'b` are borrowed but `'c` is not, the impl is:
 198 //
 199 //     impl<'de: 'a + 'b, 'a, 'b, 'c> Deserialize<'de> for S<'a, 'b, 'c>
 200 //
 201 // If any borrowed lifetime is `'static`, then `'de: 'static` would be redundant
 202 // and we use plain `'static` instead of `'de`.
 203 fn borrowed_lifetimes(cont: &Container) -> BorrowedLifetimes {
 204     let mut lifetimes = BTreeSet::new();
 205     for field in cont.body.all_fields() {
 206         lifetimes.extend(field.attrs.borrowed_lifetimes().iter().cloned());
 207     }
 208     if lifetimes.iter().any(|b| b.ident == "'static") {
 209         BorrowedLifetimes::Static
 210     } else {
 211         BorrowedLifetimes::Borrowed(lifetimes)
 212     }
 213 }
 214
 215 fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
 216     if let Some(from_type) = cont.attrs.from_type() {
 217         deserialize_from(from_type)
 218     } else if let attr::Identifier::No = cont.attrs.identifier() {
 219         match cont.body {
 220             Body::Enum(ref variants) => deserialize_enum(params, variants, &cont.attrs),
 221             Body::Struct(Style::Struct, ref fields) => {
 222                 if fields.iter().any(|field| field.ident.is_none()) {
 223                     panic!("struct has unnamed fields");
 224                 }
 225                 deserialize_struct(None, params, fields, &cont.attrs, None, Untagged::No)
 226             }
 227             Body::Struct(Style::Tuple, ref fields) |
 228             Body::Struct(Style::Newtype, ref fields) => {
 229                 if fields.iter().any(|field| field.ident.is_some()) {
 230                     panic!("tuple struct has named fields");
 231                 }
 232                 deserialize_tuple(None, params, fields, &cont.attrs, None)
 233             }
 234             Body::Struct(Style::Unit, _) => deserialize_unit_struct(params, &cont.attrs),
 235         }
 236     } else {
 237         match cont.body {
 238             Body::Enum(ref variants) => {
 239                 deserialize_custom_identifier(params, variants, &cont.attrs)
 240             }
 241             Body::Struct(_, _) => unreachable!("checked in serde_derive_internals"),
 242         }
 243     }
 244 }
 245
 246 fn deserialize_from(from_type: &syn::Ty) -> Fragment {
 247     quote_block! {
 248         _serde::export::Result::map(
 249             <#from_type as _serde::Deserialize>::deserialize(__deserializer),
 250             _serde::export::From::from)
 251     }
 252 }
 253
 254 fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fragment {
 255     let this = &params.this;
 256     let type_name = cattrs.name().deserialize_name();
 257
 258     let expecting = format!("unit struct {}", params.type_name());
 259
 260     quote_block! {
 261         struct __Visitor;
 262
 263         impl<'de> _serde::de::Visitor<'de> for __Visitor {
 264             type Value = #this;
 265
 266             fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
 267                 _serde::export::Formatter::write_str(formatter, #expecting)
 268             }
 269
 270             #[inline]
 271             fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
 272                 where __E: _serde::de::Error
 273             {
 274                 _serde::export::Ok(#this)
 275             }
 276         }
 277
 278         _serde::Deserializer::deserialize_unit_struct(__deserializer, #type_name, __Visitor)
 279     }
 280 }
 281
 282 fn deserialize_tuple(
 283     variant_ident: Option<&syn::Ident>,
 284     params: &Parameters,
 285     fields: &[Field],
 286     cattrs: &attr::Container,
 287     deserializer: Option<Tokens>,
 288 ) -> Fragment {
 289     let this = &params.this;
 290     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
 291     let delife = params.borrowed.de_lifetime();
 292
 293     // If there are getters (implying private fields), construct the local type
 294     // and use an `Into` conversion to get the remote type. If there are no
 295     // getters then construct the target type directly.
 296     let construct = if params.has_getter {
 297         let local = &params.local;
 298         quote!(#local)
 299     } else {
 300         quote!(#this)
 301     };
 302
 303     let is_enum = variant_ident.is_some();
 304     let type_path = match variant_ident {
 305         Some(variant_ident) => quote!(#construct::#variant_ident),
 306         None => construct,
 307     };
 308     let expecting = match variant_ident {
 309         Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
 310         None => format!("tuple struct {}", params.type_name()),
 311     };
 312
 313     let nfields = fields.len();
 314
 315     let visit_newtype_struct = if !is_enum && nfields == 1 {
 316         Some(deserialize_newtype_struct(&type_path, params, &fields[0]))
 317     } else {
 318         None
 319     };
 320
 321     let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, false, cattrs));
 322
 323     let visitor_expr = quote! {
 324         __Visitor {
 325             marker: _serde::export::PhantomData::<#this #ty_generics>,
 326             lifetime: _serde::export::PhantomData,
 327         }
 328     };
 329     let dispatch = if let Some(deserializer) = deserializer {
 330         quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #nfields, #visitor_expr))
 331     } else if is_enum {
 332         quote!(_serde::de::VariantAccess::tuple_variant(__variant, #nfields, #visitor_expr))
 333     } else if nfields == 1 {
 334         let type_name = cattrs.name().deserialize_name();
 335         quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr))
 336     } else {
 337         let type_name = cattrs.name().deserialize_name();
 338         quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
 339     };
 340
 341     let all_skipped = fields
 342         .iter()
 343         .all(|field| field.attrs.skip_deserializing());
 344     let visitor_var = if all_skipped {
 345         quote!(_)
 346     } else {
 347         quote!(mut __seq)
 348     };
 349
 350     quote_block! {
 351         struct __Visitor #de_impl_generics #where_clause {
 352             marker: _serde::export::PhantomData<#this #ty_generics>,
 353             lifetime: _serde::export::PhantomData<&#delife ()>,
 354         }
 355
 356         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
 357             type Value = #this #ty_generics;
 358
 359             fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
 360                 _serde::export::Formatter::write_str(formatter, #expecting)
 361             }
 362
 363             #visit_newtype_struct
 364
 365             #[inline]
 366             fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
 367                 where __A: _serde::de::SeqAccess<#delife>
 368             {
 369                 #visit_seq
 370             }
 371         }
 372
 373         #dispatch
 374     }
 375 }
 376
 377 fn deserialize_seq(
 378     type_path: &Tokens,
 379     params: &Parameters,
 380     fields: &[Field],
 381     is_struct: bool,
 382     cattrs: &attr::Container,
 383 ) -> Fragment {
 384     let vars = (0..fields.len()).map(field_i as fn(_) -> _);
 385
 386     let deserialized_count = fields
 387         .iter()
 388         .filter(|field| !field.attrs.skip_deserializing())
 389         .count();
 390     let expecting = format!("tuple of {} elements", deserialized_count);
 391
 392     let mut index_in_seq = 0usize;
 393     let let_values = vars.clone().zip(fields)
 394         .map(|(var, field)| {
 395             if field.attrs.skip_deserializing() {
 396                 let default = Expr(expr_is_missing(&field, cattrs));
 397                 quote! {
 398                     let #var = #default;
 399                 }
 400             } else {
 401                 let visit = match field.attrs.deserialize_with() {
 402                     None => {
 403                         let field_ty = &field.ty;
 404                         quote!(try!(_serde::de::SeqAccess::next_element::<#field_ty>(&mut __seq)))
 405                     }
 406                     Some(path) => {
 407                         let (wrapper, wrapper_ty) = wrap_deserialize_field_with(
 408                             params, field.ty, path);
 409                         quote!({
 410                             #wrapper
 411                             _serde::export::Option::map(
 412                                 try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)),
 413                                 |__wrap| __wrap.value)
 414                         })
 415                     }
 416                 };
 417                 let assign = quote! {
 418                     let #var = match #visit {
 419                         Some(__value) => __value,
 420                         None => {
 421                             return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
 422                         }
 423                     };
 424                 };
 425                 index_in_seq += 1;
 426                 assign
 427             }
 428         });
 429
 430     let mut result = if is_struct {
 431         let names = fields.iter().map(|f| &f.ident);
 432         quote! {
 433             #type_path { #( #names: #vars ),* }
 434         }
 435     } else {
 436         quote! {
 437             #type_path ( #(#vars),* )
 438         }
 439     };
 440
 441     if params.has_getter {
 442         let this = &params.this;
 443         result = quote! {
 444             _serde::export::Into::<#this>::into(#result)
 445         };
 446     }
 447
 448     quote_block! {
 449         #(#let_values)*
 450         _serde::export::Ok(#result)
 451     }
 452 }
 453
 454 fn deserialize_newtype_struct(type_path: &Tokens, params: &Parameters, field: &Field) -> Tokens {
 455     let delife = params.borrowed.de_lifetime();
 456
 457     let value = match field.attrs.deserialize_with() {
 458         None => {
 459             let field_ty = &field.ty;
 460             quote! {
 461                 try!(<#field_ty as _serde::Deserialize>::deserialize(__e))
 462             }
 463         }
 464         Some(path) => {
 465             let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
 466             quote!({
 467                 #wrapper
 468                 try!(<#wrapper_ty as _serde::Deserialize>::deserialize(__e)).value
 469             })
 470         }
 471     };
 472
 473     let mut result = quote!(#type_path(#value));
 474     if params.has_getter {
 475         let this = &params.this;
 476         result = quote! {
 477             _serde::export::Into::<#this>::into(#result)
 478         };
 479     }
 480
 481     quote! {
 482         #[inline]
 483         fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error>
 484             where __E: _serde::Deserializer<#delife>
 485         {
 486             _serde::export::Ok(#result)
 487         }
 488     }
 489 }
 490
 491 enum Untagged {
 492     Yes,
 493     No,
 494 }
 495
 496 fn deserialize_struct(
 497     variant_ident: Option<&syn::Ident>,
 498     params: &Parameters,
 499     fields: &[Field],
 500     cattrs: &attr::Container,
 501     deserializer: Option<Tokens>,
 502     untagged: Untagged,
 503 ) -> Fragment {
 504     let is_enum = variant_ident.is_some();
 505
 506     let this = &params.this;
 507     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
 508     let delife = params.borrowed.de_lifetime();
 509
 510     // If there are getters (implying private fields), construct the local type
 511     // and use an `Into` conversion to get the remote type. If there are no
 512     // getters then construct the target type directly.
 513     let construct = if params.has_getter {
 514         let local = &params.local;
 515         quote!(#local)
 516     } else {
 517         quote!(#this)
 518     };
 519
 520     let type_path = match variant_ident {
 521         Some(variant_ident) => quote!(#construct::#variant_ident),
 522         None => construct,
 523     };
 524     let expecting = match variant_ident {
 525         Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
 526         None => format!("struct {}", params.type_name()),
 527     };
 528
 529     let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, true, cattrs));
 530
 531     let (field_visitor, fields_stmt, visit_map) =
 532         deserialize_struct_visitor(type_path, params, fields, cattrs);
 533     let field_visitor = Stmts(field_visitor);
 534     let fields_stmt = Stmts(fields_stmt);
 535     let visit_map = Stmts(visit_map);
 536
 537     let visitor_expr = quote! {
 538         __Visitor {
 539             marker: _serde::export::PhantomData::<#this #ty_generics>,
 540             lifetime: _serde::export::PhantomData,
 541         }
 542     };
 543     let dispatch = if let Some(deserializer) = deserializer {
 544         quote! {
 545             _serde::Deserializer::deserialize_any(#deserializer, #visitor_expr)
 546         }
 547     } else if is_enum {
 548         quote! {
 549             _serde::de::VariantAccess::struct_variant(__variant, FIELDS, #visitor_expr)
 550         }
 551     } else {
 552         let type_name = cattrs.name().deserialize_name();
 553         quote! {
 554             _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, #visitor_expr)
 555         }
 556     };
 557
 558     let all_skipped = fields
 559         .iter()
 560         .all(|field| field.attrs.skip_deserializing());
 561     let visitor_var = if all_skipped {
 562         quote!(_)
 563     } else {
 564         quote!(mut __seq)
 565     };
 566
 567     // untagged struct variants do not get a visit_seq method
 568     let visit_seq = match untagged {
 569         Untagged::Yes => None,
 570         Untagged::No => {
 571             Some(quote! {
 572                 #[inline]
 573                 fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
 574                     where __A: _serde::de::SeqAccess<#delife>
 575                 {
 576                     #visit_seq
 577                 }
 578             })
 579         }
 580     };
 581
 582     quote_block! {
 583         #field_visitor
 584
 585         struct __Visitor #de_impl_generics #where_clause {
 586             marker: _serde::export::PhantomData<#this #ty_generics>,
 587             lifetime: _serde::export::PhantomData<&#delife ()>,
 588         }
 589
 590         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
 591             type Value = #this #ty_generics;
 592
 593             fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
 594                 _serde::export::Formatter::write_str(formatter, #expecting)
 595             }
 596
 597             #visit_seq
 598
 599             #[inline]
 600             fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
 601                 where __A: _serde::de::MapAccess<#delife>
 602             {
 603                 #visit_map
 604             }
 605         }
 606
 607         #fields_stmt
 608
 609         #dispatch
 610     }
 611 }
 612
 613 fn deserialize_enum(
 614     params: &Parameters,
 615     variants: &[Variant],
 616     cattrs: &attr::Container,
 617 ) -> Fragment {
 618     match *cattrs.tag() {
 619         attr::EnumTag::External => deserialize_externally_tagged_enum(params, variants, cattrs),
 620         attr::EnumTag::Internal { ref tag } => {
 621             deserialize_internally_tagged_enum(params, variants, cattrs, tag)
 622         }
 623         attr::EnumTag::Adjacent {
 624             ref tag,
 625             ref content,
 626         } => deserialize_adjacently_tagged_enum(params, variants, cattrs, tag, content),
 627         attr::EnumTag::None => deserialize_untagged_enum(params, variants, cattrs),
 628     }
 629 }
 630
 631 fn deserialize_externally_tagged_enum(
 632     params: &Parameters,
 633     variants: &[Variant],
 634     cattrs: &attr::Container,
 635 ) -> Fragment {
 636     let this = &params.this;
 637     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
 638     let delife = params.borrowed.de_lifetime();
 639
 640     let type_name = cattrs.name().deserialize_name();
 641
 642     let expecting = format!("enum {}", params.type_name());
 643
 644     let variant_names_idents: Vec<_> = variants
 645         .iter()
 646         .enumerate()
 647         .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
 648         .map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)),)
 649         .collect();
 650
 651     let variants_stmt = {
 652         let variant_names = variant_names_idents.iter().map(|&(ref name, _)| name);
 653         quote! {
 654             const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
 655         }
 656     };
 657
 658     let variant_visitor = Stmts(deserialize_generated_identifier(variant_names_idents, cattrs, true),);
 659
 660     // Match arms to extract a variant from a string
 661     let variant_arms = variants
 662         .iter()
 663         .enumerate()
 664         .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
 665         .map(
 666             |(i, variant)| {
 667                 let variant_name = field_i(i);
 668
 669                 let block = Match(deserialize_externally_tagged_variant(params, variant, cattrs),);
 670
 671                 quote! {
 672                     (__Field::#variant_name, __variant) => #block
 673                 }
 674             },
 675         );
 676
 677     let all_skipped = variants
 678         .iter()
 679         .all(|variant| variant.attrs.skip_deserializing());
 680     let match_variant = if all_skipped {
 681         // This is an empty enum like `enum Impossible {}` or an enum in which
 682         // all variants have `#[serde(skip_deserializing)]`.
 683         quote! {
 684             // FIXME: Once we drop support for Rust 1.15:
 685             // let _serde::export::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
 686             // _serde::export::Err(__err)
 687             _serde::export::Result::map(
 688                 _serde::de::EnumAccess::variant::<__Field>(__data),
 689                 |(__impossible, _)| match __impossible {})
 690         }
 691     } else {
 692         quote! {
 693             match try!(_serde::de::EnumAccess::variant(__data)) {
 694                 #(#variant_arms)*
 695             }
 696         }
 697     };
 698
 699     quote_block! {
 700         #variant_visitor
 701
 702         struct __Visitor #de_impl_generics #where_clause {
 703             marker: _serde::export::PhantomData<#this #ty_generics>,
 704             lifetime: _serde::export::PhantomData<&#delife ()>,
 705         }
 706
 707         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
 708             type Value = #this #ty_generics;
 709
 710             fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
 711                 _serde::export::Formatter::write_str(formatter, #expecting)
 712             }
 713
 714             fn visit_enum<__A>(self, __data: __A) -> _serde::export::Result<Self::Value, __A::Error>
 715                 where __A: _serde::de::EnumAccess<#delife>
 716             {
 717                 #match_variant
 718             }
 719         }
 720
 721         #variants_stmt
 722
 723         _serde::Deserializer::deserialize_enum(__deserializer, #type_name, VARIANTS,
 724                                                __Visitor {
 725                                                    marker: _serde::export::PhantomData::<#this #ty_generics>,
 726                                                    lifetime: _serde::export::PhantomData,
 727                                                })
 728     }
 729 }
 730
 731 fn deserialize_internally_tagged_enum(
 732     params: &Parameters,
 733     variants: &[Variant],
 734     cattrs: &attr::Container,
 735     tag: &str,
 736 ) -> Fragment {
 737     let variant_names_idents: Vec<_> = variants
 738         .iter()
 739         .enumerate()
 740         .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
 741         .map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)),)
 742         .collect();
 743
 744     let variants_stmt = {
 745         let variant_names = variant_names_idents.iter().map(|&(ref name, _)| name);
 746         quote! {
 747             const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
 748         }
 749     };
 750
 751     let variant_visitor = Stmts(deserialize_generated_identifier(variant_names_idents, cattrs, true),);
 752
 753     // Match arms to extract a variant from a string
 754     let variant_arms = variants.iter()
 755         .enumerate()
 756         .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
 757         .map(|(i, variant)| {
 758             let variant_name = field_i(i);
 759
 760             let block = Match(deserialize_internally_tagged_variant(
 761                 params,
 762                 variant,
 763                 cattrs,
 764                 quote!(_serde::private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)),
 765             ));
 766
 767             quote! {
 768                 __Field::#variant_name => #block
 769             }
 770         });
 771
 772     quote_block! {
 773         #variant_visitor
 774
 775         #variants_stmt
 776
 777         let __tagged = try!(_serde::Deserializer::deserialize_any(
 778             __deserializer,
 779             _serde::private::de::TaggedContentVisitor::<__Field>::new(#tag)));
 780
 781         match __tagged.tag {
 782             #(#variant_arms)*
 783         }
 784     }
 785 }
 786
 787 fn deserialize_adjacently_tagged_enum(
 788     params: &Parameters,
 789     variants: &[Variant],
 790     cattrs: &attr::Container,
 791     tag: &str,
 792     content: &str,
 793 ) -> Fragment {
 794     let this = &params.this;
 795     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
 796     let delife = params.borrowed.de_lifetime();
 797
 798     let variant_names_idents: Vec<_> = variants
 799         .iter()
 800         .enumerate()
 801         .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
 802         .map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)),)
 803         .collect();
 804
 805     let variants_stmt = {
 806         let variant_names = variant_names_idents.iter().map(|&(ref name, _)| name);
 807         quote! {
 808             const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
 809         }
 810     };
 811
 812     let variant_visitor = Stmts(deserialize_generated_identifier(variant_names_idents, cattrs, true),);
 813
 814     let ref variant_arms: Vec<_> = variants
 815         .iter()
 816         .enumerate()
 817         .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
 818         .map(
 819             |(i, variant)| {
 820                 let variant_index = field_i(i);
 821
 822                 let block = Match(
 823                     deserialize_untagged_variant(
 824                         params,
 825                         variant,
 826                         cattrs,
 827                         quote!(__deserializer),
 828                     ),
 829                 );
 830
 831                 quote! {
 832                     __Field::#variant_index => #block
 833                 }
 834             },
 835         )
 836         .collect();
 837
 838     let expecting = format!("adjacently tagged enum {}", params.type_name());
 839     let type_name = cattrs.name().deserialize_name();
 840     let deny_unknown_fields = cattrs.deny_unknown_fields();
 841
 842     // If unknown fields are allowed, we pick the visitor that can step over
 843     // those. Otherwise we pick the visitor that fails on unknown keys.
 844     let field_visitor_ty = if deny_unknown_fields {
 845         quote! { _serde::private::de::TagOrContentFieldVisitor }
 846     } else {
 847         quote! { _serde::private::de::TagContentOtherFieldVisitor }
 848     };
 849
 850     let tag_or_content = quote! {
 851         #field_visitor_ty {
 852             tag: #tag,
 853             content: #content,
 854         }
 855     };
 856
 857     fn is_unit(variant: &Variant) -> bool {
 858         match variant.style {
 859             Style::Unit => true,
 860             Style::Struct | Style::Tuple | Style::Newtype => false,
 861         }
 862     }
 863
 864     let mut missing_content = quote! {
 865         _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
 866     };
 867     if variants.iter().any(is_unit) {
 868         let fallthrough = if variants.iter().all(is_unit) {
 869             None
 870         } else {
 871             Some(
 872                 quote! {
 873                     _ => #missing_content
 874                 },
 875             )
 876         };
 877         let arms = variants
 878             .iter()
 879             .enumerate()
 880             .filter(|&(_, variant)| !variant.attrs.skip_deserializing() && is_unit(variant),)
 881             .map(
 882                 |(i, variant)| {
 883                     let variant_index = field_i(i);
 884                     let variant_ident = &variant.ident;
 885                     quote! {
 886                         __Field::#variant_index => _serde::export::Ok(#this::#variant_ident),
 887                     }
 888                 },
 889             );
 890         missing_content = quote! {
 891             match __field {
 892                 #(#arms)*
 893                 #fallthrough
 894             }
 895         };
 896     }
 897
 898     // Advance the map by one key, returning early in case of error.
 899     let next_key = quote! {
 900         try!(_serde::de::MapAccess::next_key_seed(&mut __map, #tag_or_content))
 901     };
 902
 903     // When allowing unknown fields, we want to transparently step through keys
 904     // we don't care about until we find `tag`, `content`, or run out of keys.
 905     let next_relevant_key = if deny_unknown_fields {
 906         next_key
 907     } else {
 908         quote! {
 909             {
 910                 let mut __rk : _serde::export::Option<_serde::private::de::TagOrContentField> = _serde::export::None;
 911                 while let _serde::export::Some(__k) = #next_key {
 912                     match __k {
 913                         _serde::private::de::TagContentOtherField::Other => {
 914                             try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map));
 915                             continue;
 916                         },
 917                         _serde::private::de::TagContentOtherField::Tag => {
 918                             __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Tag);
 919                             break;
 920                         }
 921                         _serde::private::de::TagContentOtherField::Content => {
 922                             __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Content);
 923                             break;
 924                         }
 925                     }
 926                 }
 927
 928                 __rk
 929             }
 930         }
 931     };
 932
 933     // Step through remaining keys, looking for duplicates of previously-seen
 934     // keys. When unknown fields are denied, any key that isn't a duplicate will
 935     // at this point immediately produce an error.
 936     let visit_remaining_keys = quote! {
 937         match #next_relevant_key {
 938             _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
 939                 _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
 940             }
 941             _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
 942                 _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
 943             }
 944             _serde::export::None => _serde::export::Ok(__ret),
 945         }
 946     };
 947
 948     quote_block! {
 949         #variant_visitor
 950
 951         #variants_stmt
 952
 953         struct __Seed #de_impl_generics #where_clause {
 954             field: __Field,
 955             marker: _serde::export::PhantomData<#this #ty_generics>,
 956             lifetime: _serde::export::PhantomData<&#delife ()>,
 957         }
 958
 959         impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
 960             type Value = #this #ty_generics;
 961
 962             fn deserialize<__D>(self, __deserializer: __D) -> _serde::export::Result<Self::Value, __D::Error>
 963                 where __D: _serde::Deserializer<#delife>
 964             {
 965                 match self.field {
 966                     #(#variant_arms)*
 967                 }
 968             }
 969         }
 970
 971         struct __Visitor #de_impl_generics #where_clause {
 972             marker: _serde::export::PhantomData<#this #ty_generics>,
 973             lifetime: _serde::export::PhantomData<&#delife ()>,
 974         }
 975
 976         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
 977             type Value = #this #ty_generics;
 978
 979             fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
 980                 _serde::export::Formatter::write_str(formatter, #expecting)
 981             }
 982
 983             fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
 984                 where __A: _serde::de::MapAccess<#delife>
 985             {
 986                 // Visit the first relevant key.
 987                 match #next_relevant_key {
 988                     // First key is the tag.
 989                     _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
 990                         // Parse the tag.
 991                         let __field = try!(_serde::de::MapAccess::next_value(&mut __map));
 992                         // Visit the second key.
 993                         match #next_relevant_key {
 994                             // Second key is a duplicate of the tag.
 995                             _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
 996                                 _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
 997                             }
 998                             // Second key is the content.
 999                             _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
1000                                 let __ret = try!(_serde::de::MapAccess::next_value_seed(&mut __map,
1001                                     __Seed {
1002                                         field: __field,
1003                                         marker: _serde::export::PhantomData,
1004                                         lifetime: _serde::export::PhantomData,
1005                                     }));
1006                                 // Visit remaining keys, looking for duplicates.
1007                                 #visit_remaining_keys
1008                             }
1009                             // There is no second key; might be okay if the we have a unit variant.
1010                             _serde::export::None => #missing_content
1011                         }
1012                     }
1013                     // First key is the content.
1014                     _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
1015                         // Buffer up the content.
1016                         let __content = try!(_serde::de::MapAccess::next_value::<_serde::private::de::Content>(&mut __map));
1017                         // Visit the second key.
1018                         match #next_relevant_key {
1019                             // Second key is the tag.
1020                             _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
1021                                 let __deserializer = _serde::private::de::ContentDeserializer::<__A::Error>::new(__content);
1022                                 // Parse the tag.
1023                                 let __ret = try!(match try!(_serde::de::MapAccess::next_value(&mut __map)) {
1024                                     // Deserialize the buffered content now that we know the variant.
1025                                     #(#variant_arms)*
1026                                 });
1027                                 // Visit remaining keys, looking for duplicates.
1028                                 #visit_remaining_keys
1029                             }
1030                             // Second key is a duplicate of the content.
1031                             _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
1032                                 _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
1033                             }
1034                             // There is no second key.
1035                             _serde::export::None => {
1036                                 _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
1037                             }
1038                         }
1039                     }
1040                     // There is no first key.
1041                     _serde::export::None => {
1042                         _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
1043                     }
1044                 }
1045             }
1046
1047             fn visit_seq<__A>(self, mut __seq: __A) -> _serde::export::Result<Self::Value, __A::Error>
1048                 where __A: _serde::de::SeqAccess<#delife>
1049             {
1050                 // Visit the first element - the tag.
1051                 match try!(_serde::de::SeqAccess::next_element(&mut __seq)) {
1052                     _serde::export::Some(__field) => {
1053                         // Visit the second element - the content.
1054                         match try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
1055                                 __Seed {
1056                                     field: __field,
1057                                     marker: _serde::export::PhantomData,
1058                                     lifetime: _serde::export::PhantomData,
1059                                 })) {
1060                             _serde::export::Some(__ret) => _serde::export::Ok(__ret),
1061                             // There is no second element.
1062                             _serde::export::None => {
1063                                 _serde::export::Err(_serde::de::Error::invalid_length(1, &self))
1064                             }
1065                         }
1066                     }
1067                     // There is no first element.
1068                     _serde::export::None => {
1069                         _serde::export::Err(_serde::de::Error::invalid_length(0, &self))
1070                     }
1071                 }
1072             }
1073         }
1074
1075         const FIELDS: &'static [&'static str] = &[#tag, #content];
1076         _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS,
1077             __Visitor {
1078                 marker: _serde::export::PhantomData::<#this #ty_generics>,
1079                 lifetime: _serde::export::PhantomData,
1080             })
1081     }
1082 }
1083
1084 fn deserialize_untagged_enum(
1085     params: &Parameters,
1086     variants: &[Variant],
1087     cattrs: &attr::Container,
1088 ) -> Fragment {
1089     let attempts = variants
1090         .iter()
1091         .filter(|variant| !variant.attrs.skip_deserializing())
1092         .map(
1093             |variant| {
1094                 Expr(deserialize_untagged_variant(
1095                 params,
1096                 variant,
1097                 cattrs,
1098                 quote!(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)),
1099             ))
1100             },
1101         );
1102
1103     // TODO this message could be better by saving the errors from the failed
1104     // attempts. The heuristic used by TOML was to count the number of fields
1105     // processed before an error, and use the error that happened after the
1106     // largest number of fields. I'm not sure I like that. Maybe it would be
1107     // better to save all the errors and combine them into one message that
1108     // explains why none of the variants matched.
1109     let fallthrough_msg =
1110         format!("data did not match any variant of untagged enum {}", params.type_name());
1111
1112     quote_block! {
1113         let __content = try!(<_serde::private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
1114
1115         #(
1116             if let _serde::export::Ok(__ok) = #attempts {
1117                 return _serde::export::Ok(__ok);
1118             }
1119         )*
1120
1121         _serde::export::Err(_serde::de::Error::custom(#fallthrough_msg))
1122     }
1123 }
1124
1125 fn deserialize_externally_tagged_variant(
1126     params: &Parameters,
1127     variant: &Variant,
1128     cattrs: &attr::Container,
1129 ) -> Fragment {
1130     if let Some(path) = variant.attrs.deserialize_with() {
1131         let (wrapper, wrapper_ty, unwrap_fn) =
1132             wrap_deserialize_variant_with(params, &variant, path);
1133         return quote_block! {
1134             #wrapper
1135             _serde::export::Result::map(
1136                 _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant), #unwrap_fn)
1137         };
1138     }
1139
1140     let variant_ident = &variant.ident;
1141
1142     match variant.style {
1143         Style::Unit => {
1144             let this = &params.this;
1145             quote_block! {
1146                 try!(_serde::de::VariantAccess::unit_variant(__variant));
1147                 _serde::export::Ok(#this::#variant_ident)
1148             }
1149         }
1150         Style::Newtype => {
1151             deserialize_externally_tagged_newtype_variant(variant_ident, params, &variant.fields[0])
1152         }
1153         Style::Tuple => {
1154             deserialize_tuple(Some(variant_ident), params, &variant.fields, cattrs, None)
1155         }
1156         Style::Struct => {
1157             deserialize_struct(Some(variant_ident), params, &variant.fields, cattrs, None, Untagged::No)
1158         }
1159     }
1160 }
1161
1162 fn deserialize_internally_tagged_variant(
1163     params: &Parameters,
1164     variant: &Variant,
1165     cattrs: &attr::Container,
1166     deserializer: Tokens,
1167 ) -> Fragment {
1168     if variant.attrs.deserialize_with().is_some() {
1169         return deserialize_untagged_variant(params, variant, cattrs, deserializer);
1170     }
1171
1172     let variant_ident = &variant.ident;
1173
1174     match variant.style {
1175         Style::Unit => {
1176             let this = &params.this;
1177             let type_name = params.type_name();
1178             let variant_name = variant.ident.as_ref();
1179             quote_block! {
1180                 try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
1181                 _serde::export::Ok(#this::#variant_ident)
1182             }
1183         }
1184         Style::Newtype => {
1185             deserialize_untagged_newtype_variant(
1186                 variant_ident,
1187                 params,
1188                 &variant.fields[0],
1189                 deserializer,
1190             )
1191         }
1192         Style::Struct => {
1193             deserialize_struct(
1194                 Some(variant_ident),
1195                 params,
1196                 &variant.fields,
1197                 cattrs,
1198                 Some(deserializer),
1199                 Untagged::No,
1200             )
1201         }
1202         Style::Tuple => unreachable!("checked in serde_derive_internals"),
1203     }
1204 }
1205
1206 fn deserialize_untagged_variant(
1207     params: &Parameters,
1208     variant: &Variant,
1209     cattrs: &attr::Container,
1210     deserializer: Tokens,
1211 ) -> Fragment {
1212     if let Some(path) = variant.attrs.deserialize_with() {
1213         let (wrapper, wrapper_ty, unwrap_fn) =
1214             wrap_deserialize_variant_with(params, &variant, path);
1215         return quote_block! {
1216             #wrapper
1217             _serde::export::Result::map(
1218                 <#wrapper_ty as _serde::Deserialize>::deserialize(#deserializer), #unwrap_fn)
1219         };
1220     }
1221
1222     let variant_ident = &variant.ident;
1223
1224     match variant.style {
1225         Style::Unit => {
1226             let this = &params.this;
1227             let type_name = params.type_name();
1228             let variant_name = variant.ident.as_ref();
1229             quote_expr! {
1230                 _serde::export::Result::map(
1231                     _serde::Deserializer::deserialize_any(
1232                         #deserializer,
1233                         _serde::private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
1234                     ),
1235                     |()| #this::#variant_ident)
1236             }
1237         }
1238         Style::Newtype => {
1239             deserialize_untagged_newtype_variant(
1240                 variant_ident,
1241                 params,
1242                 &variant.fields[0],
1243                 deserializer,
1244             )
1245         }
1246         Style::Tuple => {
1247             deserialize_tuple(
1248                 Some(variant_ident),
1249                 params,
1250                 &variant.fields,
1251                 cattrs,
1252                 Some(deserializer),
1253             )
1254         }
1255         Style::Struct => {
1256             deserialize_struct(
1257                 Some(variant_ident),
1258                 params,
1259                 &variant.fields,
1260                 cattrs,
1261                 Some(deserializer),
1262                 Untagged::Yes,
1263             )
1264         }
1265     }
1266 }
1267
1268 fn deserialize_externally_tagged_newtype_variant(
1269     variant_ident: &syn::Ident,
1270     params: &Parameters,
1271     field: &Field,
1272 ) -> Fragment {
1273     let this = &params.this;
1274     match field.attrs.deserialize_with() {
1275         None => {
1276             let field_ty = &field.ty;
1277             quote_expr! {
1278                 _serde::export::Result::map(
1279                     _serde::de::VariantAccess::newtype_variant::<#field_ty>(__variant),
1280                     #this::#variant_ident)
1281             }
1282         }
1283         Some(path) => {
1284             let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
1285             quote_block! {
1286                 #wrapper
1287                 _serde::export::Result::map(
1288                     _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
1289                     |__wrapper| #this::#variant_ident(__wrapper.value))
1290             }
1291         }
1292     }
1293 }
1294
1295 fn deserialize_untagged_newtype_variant(
1296     variant_ident: &syn::Ident,
1297     params: &Parameters,
1298     field: &Field,
1299     deserializer: Tokens,
1300 ) -> Fragment {
1301     let this = &params.this;
1302     match field.attrs.deserialize_with() {
1303         None => {
1304             let field_ty = &field.ty;
1305             quote_expr! {
1306                 _serde::export::Result::map(
1307                     <#field_ty as _serde::Deserialize>::deserialize(#deserializer),
1308                     #this::#variant_ident)
1309             }
1310         }
1311         Some(path) => {
1312             let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
1313             quote_block! {
1314                 #wrapper
1315                 _serde::export::Result::map(
1316                     <#wrapper_ty as _serde::Deserialize>::deserialize(#deserializer),
1317                     |__wrapper| #this::#variant_ident(__wrapper.value))
1318             }
1319         }
1320     }
1321 }
1322
1323 fn deserialize_generated_identifier(
1324     fields: Vec<(String, Ident)>,
1325     cattrs: &attr::Container,
1326     is_variant: bool,
1327 ) -> Fragment {
1328     let this = quote!(__Field);
1329     let field_idents: &Vec<_> = &fields.iter().map(|&(_, ref ident)| ident).collect();
1330
1331     let (ignore_variant, fallthrough) = if is_variant || cattrs.deny_unknown_fields() {
1332         (None, None)
1333     } else {
1334         let ignore_variant = quote!(__ignore,);
1335         let fallthrough = quote!(_serde::export::Ok(__Field::__ignore));
1336         (Some(ignore_variant), Some(fallthrough))
1337     };
1338
1339     let visitor_impl = Stmts(deserialize_identifier(this, &fields, is_variant, fallthrough),);
1340
1341     quote_block! {
1342         #[allow(non_camel_case_types)]
1343         enum __Field {
1344             #(#field_idents,)*
1345             #ignore_variant
1346         }
1347
1348         struct __FieldVisitor;
1349
1350         impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1351             type Value = __Field;
1352
1353             #visitor_impl
1354         }
1355
1356         impl<'de> _serde::Deserialize<'de> for __Field {
1357             #[inline]
1358             fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
1359                 where __D: _serde::Deserializer<'de>
1360             {
1361                 _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
1362             }
1363         }
1364     }
1365 }
1366
1367 fn deserialize_custom_identifier(
1368     params: &Parameters,
1369     variants: &[Variant],
1370     cattrs: &attr::Container,
1371 ) -> Fragment {
1372     let is_variant = match cattrs.identifier() {
1373         attr::Identifier::Variant => true,
1374         attr::Identifier::Field => false,
1375         attr::Identifier::No => unreachable!(),
1376     };
1377
1378     let this = &params.this;
1379     let this = quote!(#this);
1380
1381     let (ordinary, fallthrough) = if let Some(last) = variants.last() {
1382         let last_ident = &last.ident;
1383         if last.attrs.other() {
1384             let ordinary = &variants[..variants.len() - 1];
1385             let fallthrough = quote!(_serde::export::Ok(#this::#last_ident));
1386             (ordinary, Some(fallthrough))
1387         } else if let Style::Newtype = last.style {
1388             let ordinary = &variants[..variants.len() - 1];
1389             let deserializer = quote!(_serde::private::de::IdentifierDeserializer::from(__value));
1390             let fallthrough = quote! {
1391                 _serde::export::Result::map(
1392                     _serde::Deserialize::deserialize(#deserializer),
1393                     #this::#last_ident)
1394             };
1395             (ordinary, Some(fallthrough))
1396         } else {
1397             (variants, None)
1398         }
1399     } else {
1400         (variants, None)
1401     };
1402
1403     let names_idents: Vec<_> = ordinary
1404         .iter()
1405         .map(|variant| (variant.attrs.name().deserialize_name(), variant.ident.clone()),)
1406         .collect();
1407
1408     let names = names_idents.iter().map(|&(ref name, _)| name);
1409
1410     let names_const = if fallthrough.is_some() {
1411         None
1412     } else if is_variant {
1413         let variants = quote! {
1414             const VARIANTS: &'static [&'static str] = &[ #(#names),* ];
1415         };
1416         Some(variants)
1417     } else {
1418         let fields = quote! {
1419             const FIELDS: &'static [&'static str] = &[ #(#names),* ];
1420         };
1421         Some(fields)
1422     };
1423
1424     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
1425     let delife = params.borrowed.de_lifetime();
1426     let visitor_impl =
1427         Stmts(deserialize_identifier(this.clone(), &names_idents, is_variant, fallthrough),);
1428
1429     quote_block! {
1430         #names_const
1431
1432         struct __FieldVisitor #de_impl_generics #where_clause {
1433             marker: _serde::export::PhantomData<#this #ty_generics>,
1434             lifetime: _serde::export::PhantomData<&#delife ()>,
1435         }
1436
1437         impl #de_impl_generics _serde::de::Visitor<#delife> for __FieldVisitor #de_ty_generics #where_clause {
1438             type Value = #this #ty_generics;
1439
1440             #visitor_impl
1441         }
1442
1443         let __visitor = __FieldVisitor {
1444             marker: _serde::export::PhantomData::<#this #ty_generics>,
1445             lifetime: _serde::export::PhantomData,
1446         };
1447         _serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
1448     }
1449 }
1450
1451 fn deserialize_identifier(
1452     this: Tokens,
1453     fields: &[(String, Ident)],
1454     is_variant: bool,
1455     fallthrough: Option<Tokens>,
1456 ) -> Fragment {
1457     let field_strs = fields.iter().map(|&(ref name, _)| name);
1458     let field_bytes = fields.iter().map(|&(ref name, _)| quote::ByteStr(name));
1459
1460     let constructors: &Vec<_> = &fields
1461                                      .iter()
1462                                      .map(|&(_, ref ident)| quote!(#this::#ident))
1463                                      .collect();
1464
1465     let expecting = if is_variant {
1466         "variant identifier"
1467     } else {
1468         "field identifier"
1469     };
1470
1471     let index_expecting = if is_variant {
1472         "variant"
1473     } else {
1474         "field"
1475     };
1476
1477     let variant_indices = 0u64..;
1478     let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
1479     let visit_index = quote! {
1480         fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
1481             where __E: _serde::de::Error
1482         {
1483             match __value {
1484                 #(
1485                     #variant_indices => _serde::export::Ok(#constructors),
1486                 )*
1487                 _ => _serde::export::Err(_serde::de::Error::invalid_value(
1488                             _serde::de::Unexpected::Unsigned(__value),
1489                             &#fallthrough_msg))
1490             }
1491         }
1492     };
1493
1494     let bytes_to_str = if fallthrough.is_some() {
1495         None
1496     } else {
1497         let conversion = quote! {
1498             let __value = &_serde::export::from_utf8_lossy(__value);
1499         };
1500         Some(conversion)
1501     };
1502
1503     let fallthrough_arm = if let Some(fallthrough) = fallthrough {
1504         fallthrough
1505     } else if is_variant {
1506         quote! {
1507             _serde::export::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
1508         }
1509     } else {
1510         quote! {
1511             _serde::export::Err(_serde::de::Error::unknown_field(__value, FIELDS))
1512         }
1513     };
1514
1515     quote_block! {
1516         fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
1517             _serde::export::Formatter::write_str(formatter, #expecting)
1518         }
1519
1520         #visit_index
1521
1522         fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
1523             where __E: _serde::de::Error
1524         {
1525             match __value {
1526                 #(
1527                     #field_strs => _serde::export::Ok(#constructors),
1528                 )*
1529                 _ => #fallthrough_arm
1530             }
1531         }
1532
1533         fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::export::Result<Self::Value, __E>
1534             where __E: _serde::de::Error
1535         {
1536             match __value {
1537                 #(
1538                     #field_bytes => _serde::export::Ok(#constructors),
1539                 )*
1540                 _ => {
1541                     #bytes_to_str
1542                     #fallthrough_arm
1543                 }
1544             }
1545         }
1546     }
1547 }
1548
1549 fn deserialize_struct_visitor(
1550     struct_path: Tokens,
1551     params: &Parameters,
1552     fields: &[Field],
1553     cattrs: &attr::Container,
1554 ) -> (Fragment, Fragment, Fragment) {
1555     let field_names_idents: Vec<_> = fields
1556         .iter()
1557         .enumerate()
1558         .filter(|&(_, field)| !field.attrs.skip_deserializing())
1559         .map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)),)
1560         .collect();
1561
1562     let fields_stmt = {
1563         let field_names = field_names_idents.iter().map(|&(ref name, _)| name);
1564         quote_block! {
1565             const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
1566         }
1567     };
1568
1569     let field_visitor = deserialize_generated_identifier(field_names_idents, cattrs, false);
1570
1571     let visit_map = deserialize_map(struct_path, params, fields, cattrs);
1572
1573     (field_visitor, fields_stmt, visit_map)
1574 }
1575
1576 fn deserialize_map(
1577     struct_path: Tokens,
1578     params: &Parameters,
1579     fields: &[Field],
1580     cattrs: &attr::Container,
1581 ) -> Fragment {
1582     // Create the field names for the fields.
1583     let fields_names: Vec<_> = fields
1584         .iter()
1585         .enumerate()
1586         .map(|(i, field)| (field, field_i(i)))
1587         .collect();
1588
1589     // Declare each field that will be deserialized.
1590     let let_values = fields_names
1591         .iter()
1592         .filter(|&&(field, _)| !field.attrs.skip_deserializing())
1593         .map(
1594             |&(field, ref name)| {
1595                 let field_ty = &field.ty;
1596                 quote! {
1597                     let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
1598                 }
1599             },
1600         );
1601
1602     // Match arms to extract a value for a field.
1603     let value_arms = fields_names.iter()
1604         .filter(|&&(field, _)| !field.attrs.skip_deserializing())
1605         .map(|&(field, ref name)| {
1606             let deser_name = field.attrs.name().deserialize_name();
1607
1608             let visit = match field.attrs.deserialize_with() {
1609                 None => {
1610                     let field_ty = &field.ty;
1611                     quote! {
1612                         try!(_serde::de::MapAccess::next_value::<#field_ty>(&mut __map))
1613                     }
1614                 }
1615                 Some(path) => {
1616                     let (wrapper, wrapper_ty) = wrap_deserialize_field_with(
1617                         params, field.ty, path);
1618                     quote!({
1619                         #wrapper
1620                         try!(_serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map)).value
1621                     })
1622                 }
1623             };
1624             quote! {
1625                 __Field::#name => {
1626                     if _serde::export::Option::is_some(&#name) {
1627                         return _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
1628                     }
1629                     #name = _serde::export::Some(#visit);
1630                 }
1631             }
1632         });
1633
1634     // Visit ignored values to consume them
1635     let ignored_arm = if cattrs.deny_unknown_fields() {
1636         None
1637     } else {
1638         Some(quote! {
1639             _ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); }
1640         })
1641     };
1642
1643     let all_skipped = fields
1644         .iter()
1645         .all(|field| field.attrs.skip_deserializing());
1646     let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
1647         quote! {
1648             // FIXME: Once we drop support for Rust 1.15:
1649             // let _serde::export::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
1650             _serde::export::Option::map(
1651                 try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
1652                 |__impossible| match __impossible {});
1653         }
1654     } else {
1655         quote! {
1656             while let _serde::export::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
1657                 match __key {
1658                     #(#value_arms)*
1659                     #ignored_arm
1660                 }
1661             }
1662         }
1663     };
1664
1665     let extract_values = fields_names
1666         .iter()
1667         .filter(|&&(field, _)| !field.attrs.skip_deserializing())
1668         .map(
1669             |&(field, ref name)| {
1670                 let missing_expr = Match(expr_is_missing(&field, cattrs));
1671
1672                 quote! {
1673                     let #name = match #name {
1674                         _serde::export::Some(#name) => #name,
1675                         _serde::export::None => #missing_expr
1676                     };
1677                 }
1678             },
1679         );
1680
1681     let result = fields_names
1682         .iter()
1683         .map(
1684             |&(field, ref name)| {
1685                 let ident = field
1686                     .ident
1687                     .clone()
1688                     .expect("struct contains unnamed fields");
1689                 if field.attrs.skip_deserializing() {
1690                     let value = Expr(expr_is_missing(&field, cattrs));
1691                     quote!(#ident: #value)
1692                 } else {
1693                     quote!(#ident: #name)
1694                 }
1695             },
1696         );
1697
1698     let let_default = match *cattrs.default() {
1699         attr::Default::Default => {
1700             Some(
1701                 quote!(
1702                 let __default: Self::Value = _serde::export::Default::default();
1703             ),
1704             )
1705         }
1706         attr::Default::Path(ref path) => {
1707             Some(
1708                 quote!(
1709                 let __default: Self::Value = #path();
1710             ),
1711             )
1712         }
1713         attr::Default::None => {
1714             // We don't need the default value, to prevent an unused variable warning
1715             // we'll leave the line empty.
1716             None
1717         }
1718     };
1719
1720     let mut result = quote!(#struct_path { #(#result),* });
1721     if params.has_getter {
1722         let this = &params.this;
1723         result = quote! {
1724             _serde::export::Into::<#this>::into(#result)
1725         };
1726     }
1727
1728     quote_block! {
1729         #(#let_values)*
1730
1731         #match_keys
1732
1733         #let_default
1734
1735         #(#extract_values)*
1736
1737         _serde::export::Ok(#result)
1738     }
1739 }
1740
1741 fn field_i(i: usize) -> Ident {
1742     Ident::new(format!("__field{}", i))
1743 }
1744
1745 /// This function wraps the expression in `#[serde(deserialize_with = "...")]`
1746 /// in a trait to prevent it from accessing the internal `Deserialize` state.
1747 fn wrap_deserialize_with(
1748     params: &Parameters,
1749     value_ty: Tokens,
1750     deserialize_with: &syn::Path,
1751 ) -> (Tokens, Tokens) {
1752     let this = &params.this;
1753     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
1754     let delife = params.borrowed.de_lifetime();
1755
1756     let wrapper = quote! {
1757         struct __DeserializeWith #de_impl_generics #where_clause {
1758             value: #value_ty,
1759             phantom: _serde::export::PhantomData<#this #ty_generics>,
1760             lifetime: _serde::export::PhantomData<&#delife ()>,
1761         }
1762
1763         impl #de_impl_generics _serde::Deserialize<#delife> for __DeserializeWith #de_ty_generics #where_clause {
1764             fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
1765                 where __D: _serde::Deserializer<#delife>
1766             {
1767                 _serde::export::Ok(__DeserializeWith {
1768                     value: try!(#deserialize_with(__deserializer)),
1769                     phantom: _serde::export::PhantomData,
1770                     lifetime: _serde::export::PhantomData,
1771                 })
1772             }
1773         }
1774     };
1775
1776     let wrapper_ty = quote!(__DeserializeWith #de_ty_generics);
1777
1778     (wrapper, wrapper_ty)
1779 }
1780
1781 fn wrap_deserialize_field_with(
1782     params: &Parameters,
1783     field_ty: &syn::Ty,
1784     deserialize_with: &syn::Path,
1785 ) -> (Tokens, Tokens) {
1786     wrap_deserialize_with(params, quote!(#field_ty), deserialize_with)
1787 }
1788
1789 fn wrap_deserialize_variant_with(
1790     params: &Parameters,
1791     variant: &Variant,
1792     deserialize_with: &syn::Path,
1793 ) -> (Tokens, Tokens, Tokens) {
1794     let this = &params.this;
1795     let variant_ident = &variant.ident;
1796
1797     let field_tys = variant.fields.iter().map(|field| field.ty);
1798     let (wrapper, wrapper_ty) =
1799         wrap_deserialize_with(params, quote!((#(#field_tys),*)), deserialize_with);
1800
1801     let field_access = (0..variant.fields.len()).map(|n| Ident::new(format!("{}", n)));
1802     let unwrap_fn = match variant.style {
1803         Style::Struct => {
1804             let field_idents = variant.fields.iter().map(|field| field.ident.as_ref().unwrap());
1805             quote! {
1806                 {
1807                     |__wrap| {
1808                         #this::#variant_ident { #(#field_idents: __wrap.value.#field_access),* }
1809                     }
1810                 }
1811             }
1812         }
1813         Style::Tuple => {
1814             quote! {
1815                 {
1816                     |__wrap| {
1817                         #this::#variant_ident(#(__wrap.value.#field_access),*)
1818                     }
1819                 }
1820             }
1821         }
1822         Style::Newtype => {
1823             quote! {
1824                 {
1825                     |__wrap| {
1826                         #this::#variant_ident(__wrap.value)
1827                     }
1828                 }
1829             }
1830         }
1831         Style::Unit => {
1832             quote! {
1833                 {
1834                     |__wrap| { #this::#variant_ident }
1835                 }
1836             }
1837         }
1838     };
1839
1840     (wrapper, wrapper_ty, unwrap_fn)
1841 }
1842
1843 fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
1844     match *field.attrs.default() {
1845         attr::Default::Default => {
1846             return quote_expr!(_serde::export::Default::default());
1847         }
1848         attr::Default::Path(ref path) => {
1849             return quote_expr!(#path());
1850         }
1851         attr::Default::None => { /* below */ }
1852     }
1853
1854     match *cattrs.default() {
1855         attr::Default::Default |
1856         attr::Default::Path(_) => {
1857             let ident = &field.ident;
1858             return quote_expr!(__default.#ident);
1859         }
1860         attr::Default::None => { /* below */ }
1861     }
1862
1863     let name = field.attrs.name().deserialize_name();
1864     match field.attrs.deserialize_with() {
1865         None => {
1866             quote_expr! {
1867                 try!(_serde::private::de::missing_field(#name))
1868             }
1869         }
1870         Some(_) => {
1871             quote_expr! {
1872                 return _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
1873             }
1874         }
1875     }
1876 }
1877
1878 struct DeImplGenerics<'a>(&'a Parameters);
1879
1880 impl<'a> ToTokens for DeImplGenerics<'a> {
1881     fn to_tokens(&self, tokens: &mut Tokens) {
1882         let mut generics = self.0.generics.clone();
1883         if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
1884             generics.lifetimes.insert(0, de_lifetime);
1885         }
1886         let (impl_generics, _, _) = generics.split_for_impl();
1887         impl_generics.to_tokens(tokens);
1888     }
1889 }
1890
1891 struct DeTyGenerics<'a>(&'a Parameters);
1892
1893 impl<'a> ToTokens for DeTyGenerics<'a> {
1894     fn to_tokens(&self, tokens: &mut Tokens) {
1895         let mut generics = self.0.generics.clone();
1896         if self.0.borrowed.de_lifetime_def().is_some() {
1897             generics
1898                 .lifetimes
1899                 .insert(0, syn::LifetimeDef::new("'de"));
1900         }
1901         let (_, ty_generics, _) = generics.split_for_impl();
1902         ty_generics.to_tokens(tokens);
1903     }
1904 }
1905
1906 fn split_with_de_lifetime(params: &Parameters,)
1907     -> (DeImplGenerics, DeTyGenerics, syn::TyGenerics, &syn::WhereClause) {
1908     let de_impl_generics = DeImplGenerics(&params);
1909     let de_ty_generics = DeTyGenerics(&params);
1910     let (_, ty_generics, where_clause) = params.generics.split_for_impl();
1911     (de_impl_generics, de_ty_generics, ty_generics, where_clause)
1912 }