serde_derive/
de.rs

1use proc_macro2::{Literal, Span, TokenStream};
2use quote::ToTokens;
3use syn::punctuated::Punctuated;
4use syn::spanned::Spanned;
5use syn::{self, Ident, Index, Member};
6
7use bound;
8use dummy;
9use fragment::{Expr, Fragment, Match, Stmts};
10use internals::ast::{Container, Data, Field, Style, Variant};
11use internals::{attr, Ctxt, Derive};
12use pretend;
13
14use std::collections::BTreeSet;
15
16pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
17    let ctxt = Ctxt::new();
18    let cont = match Container::from_ast(&ctxt, input, Derive::Deserialize) {
19        Some(cont) => cont,
20        None => return Err(ctxt.check().unwrap_err()),
21    };
22    precondition(&ctxt, &cont);
23    ctxt.check()?;
24
25    let ident = &cont.ident;
26    let params = Parameters::new(&cont);
27    let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(&params);
28    let body = Stmts(deserialize_body(&cont, &params));
29    let delife = params.borrowed.de_lifetime();
30    let serde = cont.attrs.serde_path();
31
32    let impl_block = if let Some(remote) = cont.attrs.remote() {
33        let vis = &input.vis;
34        let used = pretend::pretend_used(&cont);
35        quote! {
36            impl #de_impl_generics #ident #ty_generics #where_clause {
37                #vis fn deserialize<__D>(__deserializer: __D) -> #serde::export::Result<#remote #ty_generics, __D::Error>
38                where
39                    __D: #serde::Deserializer<#delife>,
40                {
41                    #used
42                    #body
43                }
44            }
45        }
46    } else {
47        let fn_deserialize_in_place = deserialize_in_place_body(&cont, &params);
48
49        quote! {
50            #[automatically_derived]
51            impl #de_impl_generics #serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
52                fn deserialize<__D>(__deserializer: __D) -> #serde::export::Result<Self, __D::Error>
53                where
54                    __D: #serde::Deserializer<#delife>,
55                {
56                    #body
57                }
58
59                #fn_deserialize_in_place
60            }
61        }
62    };
63
64    Ok(dummy::wrap_in_const(
65        cont.attrs.custom_serde_path(),
66        "DESERIALIZE",
67        ident,
68        impl_block,
69    ))
70}
71
72fn precondition(cx: &Ctxt, cont: &Container) {
73    precondition_sized(cx, cont);
74    precondition_no_de_lifetime(cx, cont);
75}
76
77fn precondition_sized(cx: &Ctxt, cont: &Container) {
78    if let Data::Struct(_, fields) = &cont.data {
79        if let Some(last) = fields.last() {
80            if let syn::Type::Slice(_) = *last.ty {
81                cx.error_spanned_by(
82                    cont.original,
83                    "cannot deserialize a dynamically sized struct",
84                );
85            }
86        }
87    }
88}
89
90fn precondition_no_de_lifetime(cx: &Ctxt, cont: &Container) {
91    if let BorrowedLifetimes::Borrowed(_) = borrowed_lifetimes(cont) {
92        for param in cont.generics.lifetimes() {
93            if param.lifetime.to_string() == "'de" {
94                cx.error_spanned_by(
95                    &param.lifetime,
96                    "cannot deserialize when there is a lifetime parameter called 'de",
97                );
98                return;
99            }
100        }
101    }
102}
103
104struct Parameters {
105    /// Name of the type the `derive` is on.
106    local: syn::Ident,
107
108    /// Path to the type the impl is for. Either a single `Ident` for local
109    /// types or `some::remote::Ident` for remote types. Does not include
110    /// generic parameters.
111    this: syn::Path,
112
113    /// Generics including any explicit and inferred bounds for the impl.
114    generics: syn::Generics,
115
116    /// Lifetimes borrowed from the deserializer. These will become bounds on
117    /// the `'de` lifetime of the deserializer.
118    borrowed: BorrowedLifetimes,
119
120    /// At least one field has a serde(getter) attribute, implying that the
121    /// remote type has a private field.
122    has_getter: bool,
123}
124
125impl Parameters {
126    fn new(cont: &Container) -> Self {
127        let local = cont.ident.clone();
128        let this = match cont.attrs.remote() {
129            Some(remote) => remote.clone(),
130            None => cont.ident.clone().into(),
131        };
132        let borrowed = borrowed_lifetimes(cont);
133        let generics = build_generics(cont, &borrowed);
134        let has_getter = cont.data.has_getter();
135
136        Parameters {
137            local: local,
138            this: this,
139            generics: generics,
140            borrowed: borrowed,
141            has_getter: has_getter,
142        }
143    }
144
145    /// Type name to use in error messages and `&'static str` arguments to
146    /// various Deserializer methods.
147    fn type_name(&self) -> String {
148        self.this.segments.last().unwrap().ident.to_string()
149    }
150}
151
152// All the generics in the input, plus a bound `T: Deserialize` for each generic
153// field type that will be deserialized by us, plus a bound `T: Default` for
154// each generic field type that will be set to a default value.
155fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generics {
156    let generics = bound::without_defaults(cont.generics);
157
158    let generics = bound::with_where_predicates_from_fields(cont, &generics, attr::Field::de_bound);
159
160    let generics =
161        bound::with_where_predicates_from_variants(cont, &generics, attr::Variant::de_bound);
162
163    match cont.attrs.de_bound() {
164        Some(predicates) => bound::with_where_predicates(&generics, predicates),
165        None => {
166            let generics = match *cont.attrs.default() {
167                attr::Default::Default => {
168                    bound::with_self_bound(cont, &generics, &parse_quote!(_serde::export::Default))
169                }
170                attr::Default::None | attr::Default::Path(_) => generics,
171            };
172
173            let delife = borrowed.de_lifetime();
174            let generics = bound::with_bound(
175                cont,
176                &generics,
177                needs_deserialize_bound,
178                &parse_quote!(_serde::Deserialize<#delife>),
179            );
180
181            bound::with_bound(
182                cont,
183                &generics,
184                requires_default,
185                &parse_quote!(_serde::export::Default),
186            )
187        }
188    }
189}
190
191// Fields with a `skip_deserializing` or `deserialize_with` attribute, or which
192// belong to a variant with a `skip_deserializing` or `deserialize_with`
193// attribute, are not deserialized by us so we do not generate a bound. Fields
194// with a `bound` attribute specify their own bound so we do not generate one.
195// All other fields may need a `T: Deserialize` bound where T is the type of the
196// field.
197fn needs_deserialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
198    !field.skip_deserializing()
199        && field.deserialize_with().is_none()
200        && field.de_bound().is_none()
201        && variant.map_or(true, |variant| {
202            !variant.skip_deserializing()
203                && variant.deserialize_with().is_none()
204                && variant.de_bound().is_none()
205        })
206}
207
208// Fields with a `default` attribute (not `default=...`), and fields with a
209// `skip_deserializing` attribute that do not also have `default=...`.
210fn requires_default(field: &attr::Field, _variant: Option<&attr::Variant>) -> bool {
211    if let attr::Default::Default = *field.default() {
212        true
213    } else {
214        false
215    }
216}
217
218enum BorrowedLifetimes {
219    Borrowed(BTreeSet<syn::Lifetime>),
220    Static,
221}
222
223impl BorrowedLifetimes {
224    fn de_lifetime(&self) -> syn::Lifetime {
225        match *self {
226            BorrowedLifetimes::Borrowed(_) => syn::Lifetime::new("'de", Span::call_site()),
227            BorrowedLifetimes::Static => syn::Lifetime::new("'static", Span::call_site()),
228        }
229    }
230
231    fn de_lifetime_def(&self) -> Option<syn::LifetimeDef> {
232        match self {
233            BorrowedLifetimes::Borrowed(bounds) => Some(syn::LifetimeDef {
234                attrs: Vec::new(),
235                lifetime: syn::Lifetime::new("'de", Span::call_site()),
236                colon_token: None,
237                bounds: bounds.iter().cloned().collect(),
238            }),
239            BorrowedLifetimes::Static => None,
240        }
241    }
242}
243
244// The union of lifetimes borrowed by each field of the container.
245//
246// These turn into bounds on the `'de` lifetime of the Deserialize impl. If
247// lifetimes `'a` and `'b` are borrowed but `'c` is not, the impl is:
248//
249//     impl<'de: 'a + 'b, 'a, 'b, 'c> Deserialize<'de> for S<'a, 'b, 'c>
250//
251// If any borrowed lifetime is `'static`, then `'de: 'static` would be redundant
252// and we use plain `'static` instead of `'de`.
253fn borrowed_lifetimes(cont: &Container) -> BorrowedLifetimes {
254    let mut lifetimes = BTreeSet::new();
255    for field in cont.data.all_fields() {
256        if !field.attrs.skip_deserializing() {
257            lifetimes.extend(field.attrs.borrowed_lifetimes().iter().cloned());
258        }
259    }
260    if lifetimes.iter().any(|b| b.to_string() == "'static") {
261        BorrowedLifetimes::Static
262    } else {
263        BorrowedLifetimes::Borrowed(lifetimes)
264    }
265}
266
267fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
268    if cont.attrs.transparent() {
269        deserialize_transparent(cont, params)
270    } else if let Some(type_from) = cont.attrs.type_from() {
271        deserialize_from(type_from)
272    } else if let Some(type_try_from) = cont.attrs.type_try_from() {
273        deserialize_try_from(type_try_from)
274    } else if let attr::Identifier::No = cont.attrs.identifier() {
275        match &cont.data {
276            Data::Enum(variants) => deserialize_enum(params, variants, &cont.attrs),
277            Data::Struct(Style::Struct, fields) => {
278                deserialize_struct(None, params, fields, &cont.attrs, None, &Untagged::No)
279            }
280            Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
281                deserialize_tuple(None, params, fields, &cont.attrs, None)
282            }
283            Data::Struct(Style::Unit, _) => deserialize_unit_struct(params, &cont.attrs),
284        }
285    } else {
286        match &cont.data {
287            Data::Enum(variants) => deserialize_custom_identifier(params, variants, &cont.attrs),
288            Data::Struct(_, _) => unreachable!("checked in serde_derive_internals"),
289        }
290    }
291}
292
293#[cfg(feature = "deserialize_in_place")]
294fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<Stmts> {
295    // Only remote derives have getters, and we do not generate
296    // deserialize_in_place for remote derives.
297    assert!(!params.has_getter);
298
299    if cont.attrs.transparent()
300        || cont.attrs.type_from().is_some()
301        || cont.attrs.type_try_from().is_some()
302        || cont.attrs.identifier().is_some()
303        || cont
304            .data
305            .all_fields()
306            .all(|f| f.attrs.deserialize_with().is_some())
307    {
308        return None;
309    }
310
311    let code = match &cont.data {
312        Data::Struct(Style::Struct, fields) => {
313            if let Some(code) = deserialize_struct_in_place(None, params, fields, &cont.attrs, None)
314            {
315                code
316            } else {
317                return None;
318            }
319        }
320        Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
321            deserialize_tuple_in_place(None, params, fields, &cont.attrs, None)
322        }
323        Data::Enum(_) | Data::Struct(Style::Unit, _) => {
324            return None;
325        }
326    };
327
328    let delife = params.borrowed.de_lifetime();
329    let stmts = Stmts(code);
330
331    let fn_deserialize_in_place = quote_block! {
332        fn deserialize_in_place<__D>(__deserializer: __D, __place: &mut Self) -> _serde::export::Result<(), __D::Error>
333        where
334            __D: _serde::Deserializer<#delife>,
335        {
336            #stmts
337        }
338    };
339
340    Some(Stmts(fn_deserialize_in_place))
341}
342
343#[cfg(not(feature = "deserialize_in_place"))]
344fn deserialize_in_place_body(_cont: &Container, _params: &Parameters) -> Option<Stmts> {
345    None
346}
347
348fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
349    let fields = match &cont.data {
350        Data::Struct(_, fields) => fields,
351        Data::Enum(_) => unreachable!(),
352    };
353
354    let this = &params.this;
355    let transparent_field = fields.iter().find(|f| f.attrs.transparent()).unwrap();
356
357    let path = match transparent_field.attrs.deserialize_with() {
358        Some(path) => quote!(#path),
359        None => {
360            let span = transparent_field.original.span();
361            quote_spanned!(span=> _serde::Deserialize::deserialize)
362        }
363    };
364
365    let assign = fields.iter().map(|field| {
366        let member = &field.member;
367        if field as *const Field == transparent_field as *const Field {
368            quote!(#member: __transparent)
369        } else {
370            let value = match field.attrs.default() {
371                attr::Default::Default => quote!(_serde::export::Default::default()),
372                attr::Default::Path(path) => quote!(#path()),
373                attr::Default::None => quote!(_serde::export::PhantomData),
374            };
375            quote!(#member: #value)
376        }
377    });
378
379    quote_block! {
380        _serde::export::Result::map(
381            #path(__deserializer),
382            |__transparent| #this { #(#assign),* })
383    }
384}
385
386fn deserialize_from(type_from: &syn::Type) -> Fragment {
387    quote_block! {
388        _serde::export::Result::map(
389            <#type_from as _serde::Deserialize>::deserialize(__deserializer),
390            _serde::export::From::from)
391    }
392}
393
394fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
395    quote_block! {
396        _serde::export::Result::and_then(
397            <#type_try_from as _serde::Deserialize>::deserialize(__deserializer),
398            |v| _serde::export::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
399    }
400}
401
402fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fragment {
403    let this = &params.this;
404    let type_name = cattrs.name().deserialize_name();
405
406    let expecting = format!("unit struct {}", params.type_name());
407
408    quote_block! {
409        struct __Visitor;
410
411        impl<'de> _serde::de::Visitor<'de> for __Visitor {
412            type Value = #this;
413
414            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
415                _serde::export::Formatter::write_str(__formatter, #expecting)
416            }
417
418            #[inline]
419            fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
420            where
421                __E: _serde::de::Error,
422            {
423                _serde::export::Ok(#this)
424            }
425        }
426
427        _serde::Deserializer::deserialize_unit_struct(__deserializer, #type_name, __Visitor)
428    }
429}
430
431fn deserialize_tuple(
432    variant_ident: Option<&syn::Ident>,
433    params: &Parameters,
434    fields: &[Field],
435    cattrs: &attr::Container,
436    deserializer: Option<TokenStream>,
437) -> Fragment {
438    let this = &params.this;
439    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
440        split_with_de_lifetime(params);
441    let delife = params.borrowed.de_lifetime();
442
443    assert!(!cattrs.has_flatten());
444
445    // If there are getters (implying private fields), construct the local type
446    // and use an `Into` conversion to get the remote type. If there are no
447    // getters then construct the target type directly.
448    let construct = if params.has_getter {
449        let local = &params.local;
450        quote!(#local)
451    } else {
452        quote!(#this)
453    };
454
455    let is_enum = variant_ident.is_some();
456    let type_path = match variant_ident {
457        Some(variant_ident) => quote!(#construct::#variant_ident),
458        None => construct,
459    };
460    let expecting = match variant_ident {
461        Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
462        None => format!("tuple struct {}", params.type_name()),
463    };
464
465    let nfields = fields.len();
466
467    let visit_newtype_struct = if !is_enum && nfields == 1 {
468        Some(deserialize_newtype_struct(&type_path, params, &fields[0]))
469    } else {
470        None
471    };
472
473    let visit_seq = Stmts(deserialize_seq(
474        &type_path, params, fields, false, cattrs, &expecting,
475    ));
476
477    let visitor_expr = quote! {
478        __Visitor {
479            marker: _serde::export::PhantomData::<#this #ty_generics>,
480            lifetime: _serde::export::PhantomData,
481        }
482    };
483    let dispatch = if let Some(deserializer) = deserializer {
484        quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #nfields, #visitor_expr))
485    } else if is_enum {
486        quote!(_serde::de::VariantAccess::tuple_variant(__variant, #nfields, #visitor_expr))
487    } else if nfields == 1 {
488        let type_name = cattrs.name().deserialize_name();
489        quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr))
490    } else {
491        let type_name = cattrs.name().deserialize_name();
492        quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
493    };
494
495    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
496    let visitor_var = if all_skipped {
497        quote!(_)
498    } else {
499        quote!(mut __seq)
500    };
501
502    quote_block! {
503        struct __Visitor #de_impl_generics #where_clause {
504            marker: _serde::export::PhantomData<#this #ty_generics>,
505            lifetime: _serde::export::PhantomData<&#delife ()>,
506        }
507
508        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
509            type Value = #this #ty_generics;
510
511            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
512                _serde::export::Formatter::write_str(__formatter, #expecting)
513            }
514
515            #visit_newtype_struct
516
517            #[inline]
518            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
519            where
520                __A: _serde::de::SeqAccess<#delife>,
521            {
522                #visit_seq
523            }
524        }
525
526        #dispatch
527    }
528}
529
530#[cfg(feature = "deserialize_in_place")]
531fn deserialize_tuple_in_place(
532    variant_ident: Option<syn::Ident>,
533    params: &Parameters,
534    fields: &[Field],
535    cattrs: &attr::Container,
536    deserializer: Option<TokenStream>,
537) -> Fragment {
538    let this = &params.this;
539    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
540        split_with_de_lifetime(params);
541    let delife = params.borrowed.de_lifetime();
542
543    assert!(!cattrs.has_flatten());
544
545    let is_enum = variant_ident.is_some();
546    let expecting = match variant_ident {
547        Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
548        None => format!("tuple struct {}", params.type_name()),
549    };
550
551    let nfields = fields.len();
552
553    let visit_newtype_struct = if !is_enum && nfields == 1 {
554        Some(deserialize_newtype_struct_in_place(params, &fields[0]))
555    } else {
556        None
557    };
558
559    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, &expecting));
560
561    let visitor_expr = quote! {
562        __Visitor {
563            place: __place,
564            lifetime: _serde::export::PhantomData,
565        }
566    };
567
568    let dispatch = if let Some(deserializer) = deserializer {
569        quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #nfields, #visitor_expr))
570    } else if is_enum {
571        quote!(_serde::de::VariantAccess::tuple_variant(__variant, #nfields, #visitor_expr))
572    } else if nfields == 1 {
573        let type_name = cattrs.name().deserialize_name();
574        quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr))
575    } else {
576        let type_name = cattrs.name().deserialize_name();
577        quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
578    };
579
580    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
581    let visitor_var = if all_skipped {
582        quote!(_)
583    } else {
584        quote!(mut __seq)
585    };
586
587    let in_place_impl_generics = de_impl_generics.in_place();
588    let in_place_ty_generics = de_ty_generics.in_place();
589    let place_life = place_lifetime();
590
591    quote_block! {
592        struct __Visitor #in_place_impl_generics #where_clause {
593            place: &#place_life mut #this #ty_generics,
594            lifetime: _serde::export::PhantomData<&#delife ()>,
595        }
596
597        impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
598            type Value = ();
599
600            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
601                _serde::export::Formatter::write_str(__formatter, #expecting)
602            }
603
604            #visit_newtype_struct
605
606            #[inline]
607            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
608            where
609                __A: _serde::de::SeqAccess<#delife>,
610            {
611                #visit_seq
612            }
613        }
614
615        #dispatch
616    }
617}
618
619fn deserialize_seq(
620    type_path: &TokenStream,
621    params: &Parameters,
622    fields: &[Field],
623    is_struct: bool,
624    cattrs: &attr::Container,
625    expecting: &str,
626) -> Fragment {
627    let vars = (0..fields.len()).map(field_i as fn(_) -> _);
628
629    let deserialized_count = fields
630        .iter()
631        .filter(|field| !field.attrs.skip_deserializing())
632        .count();
633    let expecting = if deserialized_count == 1 {
634        format!("{} with 1 element", expecting)
635    } else {
636        format!("{} with {} elements", expecting, deserialized_count)
637    };
638
639    let mut index_in_seq = 0_usize;
640    let let_values = vars.clone().zip(fields).map(|(var, field)| {
641        if field.attrs.skip_deserializing() {
642            let default = Expr(expr_is_missing(field, cattrs));
643            quote! {
644                let #var = #default;
645            }
646        } else {
647            let visit = match field.attrs.deserialize_with() {
648                None => {
649                    let field_ty = field.ty;
650                    let span = field.original.span();
651                    let func =
652                        quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>);
653                    quote!(try!(#func(&mut __seq)))
654                }
655                Some(path) => {
656                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
657                    quote!({
658                        #wrapper
659                        _serde::export::Option::map(
660                            try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)),
661                            |__wrap| __wrap.value)
662                    })
663                }
664            };
665            let value_if_none = match field.attrs.default() {
666                attr::Default::Default => quote!(_serde::export::Default::default()),
667                attr::Default::Path(path) => quote!(#path()),
668                attr::Default::None => quote!(
669                    return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
670                ),
671            };
672            let assign = quote! {
673                let #var = match #visit {
674                    _serde::export::Some(__value) => __value,
675                    _serde::export::None => {
676                        #value_if_none
677                    }
678                };
679            };
680            index_in_seq += 1;
681            assign
682        }
683    });
684
685    let mut result = if is_struct {
686        let names = fields.iter().map(|f| &f.member);
687        quote! {
688            #type_path { #( #names: #vars ),* }
689        }
690    } else {
691        quote! {
692            #type_path ( #(#vars),* )
693        }
694    };
695
696    if params.has_getter {
697        let this = &params.this;
698        result = quote! {
699            _serde::export::Into::<#this>::into(#result)
700        };
701    }
702
703    let let_default = match cattrs.default() {
704        attr::Default::Default => Some(quote!(
705            let __default: Self::Value = _serde::export::Default::default();
706        )),
707        attr::Default::Path(path) => Some(quote!(
708            let __default: Self::Value = #path();
709        )),
710        attr::Default::None => {
711            // We don't need the default value, to prevent an unused variable warning
712            // we'll leave the line empty.
713            None
714        }
715    };
716
717    quote_block! {
718        #let_default
719        #(#let_values)*
720        _serde::export::Ok(#result)
721    }
722}
723
724#[cfg(feature = "deserialize_in_place")]
725fn deserialize_seq_in_place(
726    params: &Parameters,
727    fields: &[Field],
728    cattrs: &attr::Container,
729    expecting: &str,
730) -> Fragment {
731    let deserialized_count = fields
732        .iter()
733        .filter(|field| !field.attrs.skip_deserializing())
734        .count();
735    let expecting = if deserialized_count == 1 {
736        format!("{} with 1 element", expecting)
737    } else {
738        format!("{} with {} elements", expecting, deserialized_count)
739    };
740
741    let mut index_in_seq = 0usize;
742    let write_values = fields.iter().map(|field| {
743        let member = &field.member;
744
745        if field.attrs.skip_deserializing() {
746            let default = Expr(expr_is_missing(field, cattrs));
747            quote! {
748                self.place.#member = #default;
749            }
750        } else {
751            let value_if_none = match field.attrs.default() {
752                attr::Default::Default => quote!(
753                    self.place.#member = _serde::export::Default::default();
754                ),
755                attr::Default::Path(path) => quote!(
756                    self.place.#member = #path();
757                ),
758                attr::Default::None => quote!(
759                    return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
760                ),
761            };
762            let write = match field.attrs.deserialize_with() {
763                None => {
764                    quote! {
765                        if let _serde::export::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
766                            _serde::private::de::InPlaceSeed(&mut self.place.#member)))
767                        {
768                            #value_if_none
769                        }
770                    }
771                }
772                Some(path) => {
773                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
774                    quote!({
775                        #wrapper
776                        match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) {
777                            _serde::export::Some(__wrap) => {
778                                self.place.#member = __wrap.value;
779                            }
780                            _serde::export::None => {
781                                #value_if_none
782                            }
783                        }
784                    })
785                }
786            };
787            index_in_seq += 1;
788            write
789        }
790    });
791
792    let this = &params.this;
793    let (_, ty_generics, _) = params.generics.split_for_impl();
794    let let_default = match cattrs.default() {
795        attr::Default::Default => Some(quote!(
796            let __default: #this #ty_generics  = _serde::export::Default::default();
797        )),
798        attr::Default::Path(path) => Some(quote!(
799            let __default: #this #ty_generics  = #path();
800        )),
801        attr::Default::None => {
802            // We don't need the default value, to prevent an unused variable warning
803            // we'll leave the line empty.
804            None
805        }
806    };
807
808    quote_block! {
809        #let_default
810        #(#write_values)*
811        _serde::export::Ok(())
812    }
813}
814
815fn deserialize_newtype_struct(
816    type_path: &TokenStream,
817    params: &Parameters,
818    field: &Field,
819) -> TokenStream {
820    let delife = params.borrowed.de_lifetime();
821    let field_ty = field.ty;
822
823    let value = match field.attrs.deserialize_with() {
824        None => {
825            let span = field.original.span();
826            let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
827            quote! {
828                try!(#func(__e))
829            }
830        }
831        Some(path) => {
832            quote! {
833                try!(#path(__e))
834            }
835        }
836    };
837
838    let mut result = quote!(#type_path(__field0));
839    if params.has_getter {
840        let this = &params.this;
841        result = quote! {
842            _serde::export::Into::<#this>::into(#result)
843        };
844    }
845
846    quote! {
847        #[inline]
848        fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error>
849        where
850            __E: _serde::Deserializer<#delife>,
851        {
852            let __field0: #field_ty = #value;
853            _serde::export::Ok(#result)
854        }
855    }
856}
857
858#[cfg(feature = "deserialize_in_place")]
859fn deserialize_newtype_struct_in_place(params: &Parameters, field: &Field) -> TokenStream {
860    // We do not generate deserialize_in_place if every field has a
861    // deserialize_with.
862    assert!(field.attrs.deserialize_with().is_none());
863
864    let delife = params.borrowed.de_lifetime();
865
866    quote! {
867        #[inline]
868        fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error>
869        where
870            __E: _serde::Deserializer<#delife>,
871        {
872            _serde::Deserialize::deserialize_in_place(__e, &mut self.place.0)
873        }
874    }
875}
876
877enum Untagged {
878    Yes,
879    No,
880}
881
882fn deserialize_struct(
883    variant_ident: Option<&syn::Ident>,
884    params: &Parameters,
885    fields: &[Field],
886    cattrs: &attr::Container,
887    deserializer: Option<TokenStream>,
888    untagged: &Untagged,
889) -> Fragment {
890    let is_enum = variant_ident.is_some();
891
892    let this = &params.this;
893    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
894        split_with_de_lifetime(params);
895    let delife = params.borrowed.de_lifetime();
896
897    // If there are getters (implying private fields), construct the local type
898    // and use an `Into` conversion to get the remote type. If there are no
899    // getters then construct the target type directly.
900    let construct = if params.has_getter {
901        let local = &params.local;
902        quote!(#local)
903    } else {
904        quote!(#this)
905    };
906
907    let type_path = match variant_ident {
908        Some(variant_ident) => quote!(#construct::#variant_ident),
909        None => construct,
910    };
911    let expecting = match variant_ident {
912        Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
913        None => format!("struct {}", params.type_name()),
914    };
915
916    let visit_seq = Stmts(deserialize_seq(
917        &type_path, params, fields, true, cattrs, &expecting,
918    ));
919
920    let (field_visitor, fields_stmt, visit_map) = if cattrs.has_flatten() {
921        deserialize_struct_as_map_visitor(&type_path, params, fields, cattrs)
922    } else {
923        deserialize_struct_as_struct_visitor(&type_path, params, fields, cattrs)
924    };
925    let field_visitor = Stmts(field_visitor);
926    let fields_stmt = fields_stmt.map(Stmts);
927    let visit_map = Stmts(visit_map);
928
929    let visitor_expr = quote! {
930        __Visitor {
931            marker: _serde::export::PhantomData::<#this #ty_generics>,
932            lifetime: _serde::export::PhantomData,
933        }
934    };
935    let dispatch = if let Some(deserializer) = deserializer {
936        quote! {
937            _serde::Deserializer::deserialize_any(#deserializer, #visitor_expr)
938        }
939    } else if is_enum && cattrs.has_flatten() {
940        quote! {
941            _serde::de::VariantAccess::newtype_variant_seed(__variant, #visitor_expr)
942        }
943    } else if is_enum {
944        quote! {
945            _serde::de::VariantAccess::struct_variant(__variant, FIELDS, #visitor_expr)
946        }
947    } else if cattrs.has_flatten() {
948        quote! {
949            _serde::Deserializer::deserialize_map(__deserializer, #visitor_expr)
950        }
951    } else {
952        let type_name = cattrs.name().deserialize_name();
953        quote! {
954            _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, #visitor_expr)
955        }
956    };
957
958    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
959    let visitor_var = if all_skipped {
960        quote!(_)
961    } else {
962        quote!(mut __seq)
963    };
964
965    // untagged struct variants do not get a visit_seq method. The same applies to
966    // structs that only have a map representation.
967    let visit_seq = match *untagged {
968        Untagged::No if !cattrs.has_flatten() => Some(quote! {
969            #[inline]
970            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
971            where
972                __A: _serde::de::SeqAccess<#delife>,
973            {
974                #visit_seq
975            }
976        }),
977        _ => None,
978    };
979
980    let visitor_seed = if is_enum && cattrs.has_flatten() {
981        Some(quote! {
982            impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
983                type Value = #this #ty_generics;
984
985                fn deserialize<__D>(self, __deserializer: __D) -> _serde::export::Result<Self::Value, __D::Error>
986                where
987                    __D: _serde::Deserializer<'de>,
988                {
989                    _serde::Deserializer::deserialize_map(__deserializer, self)
990                }
991            }
992        })
993    } else {
994        None
995    };
996
997    quote_block! {
998        #field_visitor
999
1000        struct __Visitor #de_impl_generics #where_clause {
1001            marker: _serde::export::PhantomData<#this #ty_generics>,
1002            lifetime: _serde::export::PhantomData<&#delife ()>,
1003        }
1004
1005        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
1006            type Value = #this #ty_generics;
1007
1008            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
1009                _serde::export::Formatter::write_str(__formatter, #expecting)
1010            }
1011
1012            #visit_seq
1013
1014            #[inline]
1015            fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
1016            where
1017                __A: _serde::de::MapAccess<#delife>,
1018            {
1019                #visit_map
1020            }
1021        }
1022
1023        #visitor_seed
1024
1025        #fields_stmt
1026
1027        #dispatch
1028    }
1029}
1030
1031#[cfg(feature = "deserialize_in_place")]
1032fn deserialize_struct_in_place(
1033    variant_ident: Option<syn::Ident>,
1034    params: &Parameters,
1035    fields: &[Field],
1036    cattrs: &attr::Container,
1037    deserializer: Option<TokenStream>,
1038) -> Option<Fragment> {
1039    let is_enum = variant_ident.is_some();
1040
1041    // for now we do not support in_place deserialization for structs that
1042    // are represented as map.
1043    if cattrs.has_flatten() {
1044        return None;
1045    }
1046
1047    let this = &params.this;
1048    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
1049        split_with_de_lifetime(params);
1050    let delife = params.borrowed.de_lifetime();
1051
1052    let expecting = match variant_ident {
1053        Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
1054        None => format!("struct {}", params.type_name()),
1055    };
1056
1057    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, &expecting));
1058
1059    let (field_visitor, fields_stmt, visit_map) =
1060        deserialize_struct_as_struct_in_place_visitor(params, fields, cattrs);
1061
1062    let field_visitor = Stmts(field_visitor);
1063    let fields_stmt = Stmts(fields_stmt);
1064    let visit_map = Stmts(visit_map);
1065
1066    let visitor_expr = quote! {
1067        __Visitor {
1068            place: __place,
1069            lifetime: _serde::export::PhantomData,
1070        }
1071    };
1072    let dispatch = if let Some(deserializer) = deserializer {
1073        quote! {
1074            _serde::Deserializer::deserialize_any(#deserializer, #visitor_expr)
1075        }
1076    } else if is_enum {
1077        quote! {
1078            _serde::de::VariantAccess::struct_variant(__variant, FIELDS, #visitor_expr)
1079        }
1080    } else {
1081        let type_name = cattrs.name().deserialize_name();
1082        quote! {
1083            _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, #visitor_expr)
1084        }
1085    };
1086
1087    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
1088    let visitor_var = if all_skipped {
1089        quote!(_)
1090    } else {
1091        quote!(mut __seq)
1092    };
1093
1094    let visit_seq = quote! {
1095        #[inline]
1096        fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
1097        where
1098            __A: _serde::de::SeqAccess<#delife>,
1099        {
1100            #visit_seq
1101        }
1102    };
1103
1104    let in_place_impl_generics = de_impl_generics.in_place();
1105    let in_place_ty_generics = de_ty_generics.in_place();
1106    let place_life = place_lifetime();
1107
1108    Some(quote_block! {
1109        #field_visitor
1110
1111        struct __Visitor #in_place_impl_generics #where_clause {
1112            place: &#place_life mut #this #ty_generics,
1113            lifetime: _serde::export::PhantomData<&#delife ()>,
1114        }
1115
1116        impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
1117            type Value = ();
1118
1119            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
1120                _serde::export::Formatter::write_str(__formatter, #expecting)
1121            }
1122
1123            #visit_seq
1124
1125            #[inline]
1126            fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
1127            where
1128                __A: _serde::de::MapAccess<#delife>,
1129            {
1130                #visit_map
1131            }
1132        }
1133
1134        #fields_stmt
1135
1136        #dispatch
1137    })
1138}
1139
1140fn deserialize_enum(
1141    params: &Parameters,
1142    variants: &[Variant],
1143    cattrs: &attr::Container,
1144) -> Fragment {
1145    match cattrs.tag() {
1146        attr::TagType::External => deserialize_externally_tagged_enum(params, variants, cattrs),
1147        attr::TagType::Internal { tag } => {
1148            deserialize_internally_tagged_enum(params, variants, cattrs, tag)
1149        }
1150        attr::TagType::Adjacent { tag, content } => {
1151            deserialize_adjacently_tagged_enum(params, variants, cattrs, tag, content)
1152        }
1153        attr::TagType::None => deserialize_untagged_enum(params, variants, cattrs),
1154    }
1155}
1156
1157fn prepare_enum_variant_enum(
1158    variants: &[Variant],
1159    cattrs: &attr::Container,
1160) -> (TokenStream, Stmts) {
1161    let variant_names_idents: Vec<_> = variants
1162        .iter()
1163        .enumerate()
1164        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
1165        .map(|(i, variant)| {
1166            (
1167                variant.attrs.name().deserialize_name(),
1168                field_i(i),
1169                variant.attrs.aliases(),
1170            )
1171        })
1172        .collect();
1173
1174    let other_idx = variants.iter().position(|variant| variant.attrs.other());
1175
1176    let variants_stmt = {
1177        let variant_names = variant_names_idents.iter().map(|(name, _, _)| name);
1178        quote! {
1179            const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
1180        }
1181    };
1182
1183    let variant_visitor = Stmts(deserialize_generated_identifier(
1184        &variant_names_idents,
1185        cattrs,
1186        true,
1187        other_idx,
1188    ));
1189
1190    (variants_stmt, variant_visitor)
1191}
1192
1193fn deserialize_externally_tagged_enum(
1194    params: &Parameters,
1195    variants: &[Variant],
1196    cattrs: &attr::Container,
1197) -> Fragment {
1198    let this = &params.this;
1199    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
1200        split_with_de_lifetime(params);
1201    let delife = params.borrowed.de_lifetime();
1202
1203    let type_name = cattrs.name().deserialize_name();
1204    let expecting = format!("enum {}", params.type_name());
1205
1206    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
1207
1208    // Match arms to extract a variant from a string
1209    let variant_arms = variants
1210        .iter()
1211        .enumerate()
1212        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
1213        .map(|(i, variant)| {
1214            let variant_name = field_i(i);
1215
1216            let block = Match(deserialize_externally_tagged_variant(
1217                params, variant, cattrs,
1218            ));
1219
1220            quote! {
1221                (__Field::#variant_name, __variant) => #block
1222            }
1223        });
1224
1225    let all_skipped = variants
1226        .iter()
1227        .all(|variant| variant.attrs.skip_deserializing());
1228    let match_variant = if all_skipped {
1229        // This is an empty enum like `enum Impossible {}` or an enum in which
1230        // all variants have `#[serde(skip_deserializing)]`.
1231        quote! {
1232            // FIXME: Once we drop support for Rust 1.15:
1233            // let _serde::export::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
1234            // _serde::export::Err(__err)
1235            _serde::export::Result::map(
1236                _serde::de::EnumAccess::variant::<__Field>(__data),
1237                |(__impossible, _)| match __impossible {})
1238        }
1239    } else {
1240        quote! {
1241            match try!(_serde::de::EnumAccess::variant(__data)) {
1242                #(#variant_arms)*
1243            }
1244        }
1245    };
1246
1247    quote_block! {
1248        #variant_visitor
1249
1250        struct __Visitor #de_impl_generics #where_clause {
1251            marker: _serde::export::PhantomData<#this #ty_generics>,
1252            lifetime: _serde::export::PhantomData<&#delife ()>,
1253        }
1254
1255        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
1256            type Value = #this #ty_generics;
1257
1258            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
1259                _serde::export::Formatter::write_str(__formatter, #expecting)
1260            }
1261
1262            fn visit_enum<__A>(self, __data: __A) -> _serde::export::Result<Self::Value, __A::Error>
1263            where
1264                __A: _serde::de::EnumAccess<#delife>,
1265            {
1266                #match_variant
1267            }
1268        }
1269
1270        #variants_stmt
1271
1272        _serde::Deserializer::deserialize_enum(
1273            __deserializer,
1274            #type_name,
1275            VARIANTS,
1276            __Visitor {
1277                marker: _serde::export::PhantomData::<#this #ty_generics>,
1278                lifetime: _serde::export::PhantomData,
1279            },
1280        )
1281    }
1282}
1283
1284fn deserialize_internally_tagged_enum(
1285    params: &Parameters,
1286    variants: &[Variant],
1287    cattrs: &attr::Container,
1288    tag: &str,
1289) -> Fragment {
1290    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
1291
1292    // Match arms to extract a variant from a string
1293    let variant_arms = variants
1294        .iter()
1295        .enumerate()
1296        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
1297        .map(|(i, variant)| {
1298            let variant_name = field_i(i);
1299
1300            let block = Match(deserialize_internally_tagged_variant(
1301                params,
1302                variant,
1303                cattrs,
1304                quote! {
1305                    _serde::private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)
1306                },
1307            ));
1308
1309            quote! {
1310                __Field::#variant_name => #block
1311            }
1312        });
1313
1314    quote_block! {
1315        #variant_visitor
1316
1317        #variants_stmt
1318
1319        let __tagged = try!(_serde::Deserializer::deserialize_any(
1320            __deserializer,
1321            _serde::private::de::TaggedContentVisitor::<__Field>::new(#tag)));
1322
1323        match __tagged.tag {
1324            #(#variant_arms)*
1325        }
1326    }
1327}
1328
1329fn deserialize_adjacently_tagged_enum(
1330    params: &Parameters,
1331    variants: &[Variant],
1332    cattrs: &attr::Container,
1333    tag: &str,
1334    content: &str,
1335) -> Fragment {
1336    let this = &params.this;
1337    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
1338        split_with_de_lifetime(params);
1339    let delife = params.borrowed.de_lifetime();
1340
1341    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
1342
1343    let variant_arms: &Vec<_> = &variants
1344        .iter()
1345        .enumerate()
1346        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
1347        .map(|(i, variant)| {
1348            let variant_index = field_i(i);
1349
1350            let block = Match(deserialize_untagged_variant(
1351                params,
1352                variant,
1353                cattrs,
1354                quote!(__deserializer),
1355            ));
1356
1357            quote! {
1358                __Field::#variant_index => #block
1359            }
1360        })
1361        .collect();
1362
1363    let expecting = format!("adjacently tagged enum {}", params.type_name());
1364    let type_name = cattrs.name().deserialize_name();
1365    let deny_unknown_fields = cattrs.deny_unknown_fields();
1366
1367    // If unknown fields are allowed, we pick the visitor that can step over
1368    // those. Otherwise we pick the visitor that fails on unknown keys.
1369    let field_visitor_ty = if deny_unknown_fields {
1370        quote! { _serde::private::de::TagOrContentFieldVisitor }
1371    } else {
1372        quote! { _serde::private::de::TagContentOtherFieldVisitor }
1373    };
1374
1375    let tag_or_content = quote! {
1376        #field_visitor_ty {
1377            tag: #tag,
1378            content: #content,
1379        }
1380    };
1381
1382    fn is_unit(variant: &Variant) -> bool {
1383        match variant.style {
1384            Style::Unit => true,
1385            Style::Struct | Style::Tuple | Style::Newtype => false,
1386        }
1387    }
1388
1389    let mut missing_content = quote! {
1390        _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
1391    };
1392    if variants.iter().any(is_unit) {
1393        let fallthrough = if variants.iter().all(is_unit) {
1394            None
1395        } else {
1396            Some(quote! {
1397                _ => #missing_content
1398            })
1399        };
1400        let arms = variants
1401            .iter()
1402            .enumerate()
1403            .filter(|&(_, variant)| !variant.attrs.skip_deserializing() && is_unit(variant))
1404            .map(|(i, variant)| {
1405                let variant_index = field_i(i);
1406                let variant_ident = &variant.ident;
1407                quote! {
1408                    __Field::#variant_index => _serde::export::Ok(#this::#variant_ident),
1409                }
1410            });
1411        missing_content = quote! {
1412            match __field {
1413                #(#arms)*
1414                #fallthrough
1415            }
1416        };
1417    }
1418
1419    // Advance the map by one key, returning early in case of error.
1420    let next_key = quote! {
1421        try!(_serde::de::MapAccess::next_key_seed(&mut __map, #tag_or_content))
1422    };
1423
1424    // When allowing unknown fields, we want to transparently step through keys
1425    // we don't care about until we find `tag`, `content`, or run out of keys.
1426    let next_relevant_key = if deny_unknown_fields {
1427        next_key
1428    } else {
1429        quote!({
1430            let mut __rk : _serde::export::Option<_serde::private::de::TagOrContentField> = _serde::export::None;
1431            while let _serde::export::Some(__k) = #next_key {
1432                match __k {
1433                    _serde::private::de::TagContentOtherField::Other => {
1434                        try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map));
1435                        continue;
1436                    },
1437                    _serde::private::de::TagContentOtherField::Tag => {
1438                        __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Tag);
1439                        break;
1440                    }
1441                    _serde::private::de::TagContentOtherField::Content => {
1442                        __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Content);
1443                        break;
1444                    }
1445                }
1446            }
1447
1448            __rk
1449        })
1450    };
1451
1452    // Step through remaining keys, looking for duplicates of previously-seen
1453    // keys. When unknown fields are denied, any key that isn't a duplicate will
1454    // at this point immediately produce an error.
1455    let visit_remaining_keys = quote! {
1456        match #next_relevant_key {
1457            _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
1458                _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
1459            }
1460            _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
1461                _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
1462            }
1463            _serde::export::None => _serde::export::Ok(__ret),
1464        }
1465    };
1466
1467    let finish_content_then_tag = if variant_arms.is_empty() {
1468        quote! {
1469            match try!(_serde::de::MapAccess::next_value::<__Field>(&mut __map)) {}
1470        }
1471    } else {
1472        quote! {
1473            let __ret = try!(match try!(_serde::de::MapAccess::next_value(&mut __map)) {
1474                // Deserialize the buffered content now that we know the variant.
1475                #(#variant_arms)*
1476            });
1477            // Visit remaining keys, looking for duplicates.
1478            #visit_remaining_keys
1479        }
1480    };
1481
1482    quote_block! {
1483        #variant_visitor
1484
1485        #variants_stmt
1486
1487        struct __Seed #de_impl_generics #where_clause {
1488            field: __Field,
1489            marker: _serde::export::PhantomData<#this #ty_generics>,
1490            lifetime: _serde::export::PhantomData<&#delife ()>,
1491        }
1492
1493        impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
1494            type Value = #this #ty_generics;
1495
1496            fn deserialize<__D>(self, __deserializer: __D) -> _serde::export::Result<Self::Value, __D::Error>
1497            where
1498                __D: _serde::Deserializer<#delife>,
1499            {
1500                match self.field {
1501                    #(#variant_arms)*
1502                }
1503            }
1504        }
1505
1506        struct __Visitor #de_impl_generics #where_clause {
1507            marker: _serde::export::PhantomData<#this #ty_generics>,
1508            lifetime: _serde::export::PhantomData<&#delife ()>,
1509        }
1510
1511        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
1512            type Value = #this #ty_generics;
1513
1514            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
1515                _serde::export::Formatter::write_str(__formatter, #expecting)
1516            }
1517
1518            fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
1519            where
1520                __A: _serde::de::MapAccess<#delife>,
1521            {
1522                // Visit the first relevant key.
1523                match #next_relevant_key {
1524                    // First key is the tag.
1525                    _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
1526                        // Parse the tag.
1527                        let __field = try!(_serde::de::MapAccess::next_value(&mut __map));
1528                        // Visit the second key.
1529                        match #next_relevant_key {
1530                            // Second key is a duplicate of the tag.
1531                            _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
1532                                _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
1533                            }
1534                            // Second key is the content.
1535                            _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
1536                                let __ret = try!(_serde::de::MapAccess::next_value_seed(&mut __map,
1537                                    __Seed {
1538                                        field: __field,
1539                                        marker: _serde::export::PhantomData,
1540                                        lifetime: _serde::export::PhantomData,
1541                                    }));
1542                                // Visit remaining keys, looking for duplicates.
1543                                #visit_remaining_keys
1544                            }
1545                            // There is no second key; might be okay if the we have a unit variant.
1546                            _serde::export::None => #missing_content
1547                        }
1548                    }
1549                    // First key is the content.
1550                    _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
1551                        // Buffer up the content.
1552                        let __content = try!(_serde::de::MapAccess::next_value::<_serde::private::de::Content>(&mut __map));
1553                        // Visit the second key.
1554                        match #next_relevant_key {
1555                            // Second key is the tag.
1556                            _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
1557                                let __deserializer = _serde::private::de::ContentDeserializer::<__A::Error>::new(__content);
1558                                #finish_content_then_tag
1559                            }
1560                            // Second key is a duplicate of the content.
1561                            _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
1562                                _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
1563                            }
1564                            // There is no second key.
1565                            _serde::export::None => {
1566                                _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
1567                            }
1568                        }
1569                    }
1570                    // There is no first key.
1571                    _serde::export::None => {
1572                        _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
1573                    }
1574                }
1575            }
1576
1577            fn visit_seq<__A>(self, mut __seq: __A) -> _serde::export::Result<Self::Value, __A::Error>
1578            where
1579                __A: _serde::de::SeqAccess<#delife>,
1580            {
1581                // Visit the first element - the tag.
1582                match try!(_serde::de::SeqAccess::next_element(&mut __seq)) {
1583                    _serde::export::Some(__field) => {
1584                        // Visit the second element - the content.
1585                        match try!(_serde::de::SeqAccess::next_element_seed(
1586                            &mut __seq,
1587                            __Seed {
1588                                field: __field,
1589                                marker: _serde::export::PhantomData,
1590                                lifetime: _serde::export::PhantomData,
1591                            },
1592                        )) {
1593                            _serde::export::Some(__ret) => _serde::export::Ok(__ret),
1594                            // There is no second element.
1595                            _serde::export::None => {
1596                                _serde::export::Err(_serde::de::Error::invalid_length(1, &self))
1597                            }
1598                        }
1599                    }
1600                    // There is no first element.
1601                    _serde::export::None => {
1602                        _serde::export::Err(_serde::de::Error::invalid_length(0, &self))
1603                    }
1604                }
1605            }
1606        }
1607
1608        const FIELDS: &'static [&'static str] = &[#tag, #content];
1609        _serde::Deserializer::deserialize_struct(
1610            __deserializer,
1611            #type_name,
1612            FIELDS,
1613            __Visitor {
1614                marker: _serde::export::PhantomData::<#this #ty_generics>,
1615                lifetime: _serde::export::PhantomData,
1616            },
1617        )
1618    }
1619}
1620
1621fn deserialize_untagged_enum(
1622    params: &Parameters,
1623    variants: &[Variant],
1624    cattrs: &attr::Container,
1625) -> Fragment {
1626    let attempts = variants
1627        .iter()
1628        .filter(|variant| !variant.attrs.skip_deserializing())
1629        .map(|variant| {
1630            Expr(deserialize_untagged_variant(
1631                params,
1632                variant,
1633                cattrs,
1634                quote!(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)),
1635            ))
1636        });
1637
1638    // TODO this message could be better by saving the errors from the failed
1639    // attempts. The heuristic used by TOML was to count the number of fields
1640    // processed before an error, and use the error that happened after the
1641    // largest number of fields. I'm not sure I like that. Maybe it would be
1642    // better to save all the errors and combine them into one message that
1643    // explains why none of the variants matched.
1644    let fallthrough_msg = format!(
1645        "data did not match any variant of untagged enum {}",
1646        params.type_name()
1647    );
1648
1649    quote_block! {
1650        let __content = try!(<_serde::private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
1651
1652        #(
1653            if let _serde::export::Ok(__ok) = #attempts {
1654                return _serde::export::Ok(__ok);
1655            }
1656        )*
1657
1658        _serde::export::Err(_serde::de::Error::custom(#fallthrough_msg))
1659    }
1660}
1661
1662fn deserialize_externally_tagged_variant(
1663    params: &Parameters,
1664    variant: &Variant,
1665    cattrs: &attr::Container,
1666) -> Fragment {
1667    if let Some(path) = variant.attrs.deserialize_with() {
1668        let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
1669        return quote_block! {
1670            #wrapper
1671            _serde::export::Result::map(
1672                _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant), #unwrap_fn)
1673        };
1674    }
1675
1676    let variant_ident = &variant.ident;
1677
1678    match variant.style {
1679        Style::Unit => {
1680            let this = &params.this;
1681            quote_block! {
1682                try!(_serde::de::VariantAccess::unit_variant(__variant));
1683                _serde::export::Ok(#this::#variant_ident)
1684            }
1685        }
1686        Style::Newtype => deserialize_externally_tagged_newtype_variant(
1687            variant_ident,
1688            params,
1689            &variant.fields[0],
1690            cattrs,
1691        ),
1692        Style::Tuple => {
1693            deserialize_tuple(Some(variant_ident), params, &variant.fields, cattrs, None)
1694        }
1695        Style::Struct => deserialize_struct(
1696            Some(variant_ident),
1697            params,
1698            &variant.fields,
1699            cattrs,
1700            None,
1701            &Untagged::No,
1702        ),
1703    }
1704}
1705
1706fn deserialize_internally_tagged_variant(
1707    params: &Parameters,
1708    variant: &Variant,
1709    cattrs: &attr::Container,
1710    deserializer: TokenStream,
1711) -> Fragment {
1712    if variant.attrs.deserialize_with().is_some() {
1713        return deserialize_untagged_variant(params, variant, cattrs, deserializer);
1714    }
1715
1716    let variant_ident = &variant.ident;
1717
1718    match effective_style(variant) {
1719        Style::Unit => {
1720            let this = &params.this;
1721            let type_name = params.type_name();
1722            let variant_name = variant.ident.to_string();
1723            let default = variant.fields.get(0).map(|field| {
1724                let default = Expr(expr_is_missing(field, cattrs));
1725                quote!((#default))
1726            });
1727            quote_block! {
1728                try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
1729                _serde::export::Ok(#this::#variant_ident #default)
1730            }
1731        }
1732        Style::Newtype => deserialize_untagged_newtype_variant(
1733            variant_ident,
1734            params,
1735            &variant.fields[0],
1736            &deserializer,
1737        ),
1738        Style::Struct => deserialize_struct(
1739            Some(variant_ident),
1740            params,
1741            &variant.fields,
1742            cattrs,
1743            Some(deserializer),
1744            &Untagged::No,
1745        ),
1746        Style::Tuple => unreachable!("checked in serde_derive_internals"),
1747    }
1748}
1749
1750fn deserialize_untagged_variant(
1751    params: &Parameters,
1752    variant: &Variant,
1753    cattrs: &attr::Container,
1754    deserializer: TokenStream,
1755) -> Fragment {
1756    if let Some(path) = variant.attrs.deserialize_with() {
1757        let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
1758        return quote_block! {
1759            #wrapper
1760            _serde::export::Result::map(
1761                <#wrapper_ty as _serde::Deserialize>::deserialize(#deserializer), #unwrap_fn)
1762        };
1763    }
1764
1765    let variant_ident = &variant.ident;
1766
1767    match effective_style(variant) {
1768        Style::Unit => {
1769            let this = &params.this;
1770            let type_name = params.type_name();
1771            let variant_name = variant.ident.to_string();
1772            let default = variant.fields.get(0).map(|field| {
1773                let default = Expr(expr_is_missing(field, cattrs));
1774                quote!((#default))
1775            });
1776            quote_expr! {
1777                match _serde::Deserializer::deserialize_any(
1778                    #deserializer,
1779                    _serde::private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
1780                ) {
1781                    _serde::export::Ok(()) => _serde::export::Ok(#this::#variant_ident #default),
1782                    _serde::export::Err(__err) => _serde::export::Err(__err),
1783                }
1784            }
1785        }
1786        Style::Newtype => deserialize_untagged_newtype_variant(
1787            variant_ident,
1788            params,
1789            &variant.fields[0],
1790            &deserializer,
1791        ),
1792        Style::Tuple => deserialize_tuple(
1793            Some(variant_ident),
1794            params,
1795            &variant.fields,
1796            cattrs,
1797            Some(deserializer),
1798        ),
1799        Style::Struct => deserialize_struct(
1800            Some(variant_ident),
1801            params,
1802            &variant.fields,
1803            cattrs,
1804            Some(deserializer),
1805            &Untagged::Yes,
1806        ),
1807    }
1808}
1809
1810fn deserialize_externally_tagged_newtype_variant(
1811    variant_ident: &syn::Ident,
1812    params: &Parameters,
1813    field: &Field,
1814    cattrs: &attr::Container,
1815) -> Fragment {
1816    let this = &params.this;
1817
1818    if field.attrs.skip_deserializing() {
1819        let this = &params.this;
1820        let default = Expr(expr_is_missing(field, cattrs));
1821        return quote_block! {
1822            try!(_serde::de::VariantAccess::unit_variant(__variant));
1823            _serde::export::Ok(#this::#variant_ident(#default))
1824        };
1825    }
1826
1827    match field.attrs.deserialize_with() {
1828        None => {
1829            let field_ty = field.ty;
1830            let span = field.original.span();
1831            let func =
1832                quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
1833            quote_expr! {
1834                _serde::export::Result::map(#func(__variant), #this::#variant_ident)
1835            }
1836        }
1837        Some(path) => {
1838            let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
1839            quote_block! {
1840                #wrapper
1841                _serde::export::Result::map(
1842                    _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
1843                    |__wrapper| #this::#variant_ident(__wrapper.value))
1844            }
1845        }
1846    }
1847}
1848
1849fn deserialize_untagged_newtype_variant(
1850    variant_ident: &syn::Ident,
1851    params: &Parameters,
1852    field: &Field,
1853    deserializer: &TokenStream,
1854) -> Fragment {
1855    let this = &params.this;
1856    let field_ty = field.ty;
1857    match field.attrs.deserialize_with() {
1858        None => {
1859            let span = field.original.span();
1860            let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
1861            quote_expr! {
1862                _serde::export::Result::map(#func(#deserializer), #this::#variant_ident)
1863            }
1864        }
1865        Some(path) => {
1866            quote_block! {
1867                let __value: _serde::export::Result<#field_ty, _> = #path(#deserializer);
1868                _serde::export::Result::map(__value, #this::#variant_ident)
1869            }
1870        }
1871    }
1872}
1873
1874fn deserialize_generated_identifier(
1875    fields: &[(String, Ident, Vec<String>)],
1876    cattrs: &attr::Container,
1877    is_variant: bool,
1878    other_idx: Option<usize>,
1879) -> Fragment {
1880    let this = quote!(__Field);
1881    let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();
1882
1883    let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
1884        let ignore_variant = quote!(__other(_serde::private::de::Content<'de>),);
1885        let fallthrough = quote!(_serde::export::Ok(__Field::__other(__value)));
1886        (Some(ignore_variant), Some(fallthrough))
1887    } else if let Some(other_idx) = other_idx {
1888        let ignore_variant = fields[other_idx].1.clone();
1889        let fallthrough = quote!(_serde::export::Ok(__Field::#ignore_variant));
1890        (None, Some(fallthrough))
1891    } else if is_variant || cattrs.deny_unknown_fields() {
1892        (None, None)
1893    } else {
1894        let ignore_variant = quote!(__ignore,);
1895        let fallthrough = quote!(_serde::export::Ok(__Field::__ignore));
1896        (Some(ignore_variant), Some(fallthrough))
1897    };
1898
1899    let visitor_impl = Stmts(deserialize_identifier(
1900        &this,
1901        fields,
1902        is_variant,
1903        fallthrough,
1904        !is_variant && cattrs.has_flatten(),
1905    ));
1906
1907    let lifetime = if !is_variant && cattrs.has_flatten() {
1908        Some(quote!(<'de>))
1909    } else {
1910        None
1911    };
1912
1913    quote_block! {
1914        #[allow(non_camel_case_types)]
1915        enum __Field #lifetime {
1916            #(#field_idents,)*
1917            #ignore_variant
1918        }
1919
1920        struct __FieldVisitor;
1921
1922        impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1923            type Value = __Field #lifetime;
1924
1925            #visitor_impl
1926        }
1927
1928        impl<'de> _serde::Deserialize<'de> for __Field #lifetime {
1929            #[inline]
1930            fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
1931            where
1932                __D: _serde::Deserializer<'de>,
1933            {
1934                _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
1935            }
1936        }
1937    }
1938}
1939
1940fn deserialize_custom_identifier(
1941    params: &Parameters,
1942    variants: &[Variant],
1943    cattrs: &attr::Container,
1944) -> Fragment {
1945    let is_variant = match cattrs.identifier() {
1946        attr::Identifier::Variant => true,
1947        attr::Identifier::Field => false,
1948        attr::Identifier::No => unreachable!(),
1949    };
1950
1951    let this = &params.this;
1952    let this = quote!(#this);
1953
1954    let (ordinary, fallthrough) = if let Some(last) = variants.last() {
1955        let last_ident = &last.ident;
1956        if last.attrs.other() {
1957            let ordinary = &variants[..variants.len() - 1];
1958            let fallthrough = quote!(_serde::export::Ok(#this::#last_ident));
1959            (ordinary, Some(fallthrough))
1960        } else if let Style::Newtype = last.style {
1961            let ordinary = &variants[..variants.len() - 1];
1962            let deserializer = quote!(_serde::private::de::IdentifierDeserializer::from(__value));
1963            let fallthrough = quote! {
1964                _serde::export::Result::map(
1965                    _serde::Deserialize::deserialize(#deserializer),
1966                    #this::#last_ident)
1967            };
1968            (ordinary, Some(fallthrough))
1969        } else {
1970            (variants, None)
1971        }
1972    } else {
1973        (variants, None)
1974    };
1975
1976    let names_idents: Vec<_> = ordinary
1977        .iter()
1978        .map(|variant| {
1979            (
1980                variant.attrs.name().deserialize_name(),
1981                variant.ident.clone(),
1982                variant.attrs.aliases(),
1983            )
1984        })
1985        .collect();
1986
1987    let names = names_idents.iter().map(|(name, _, _)| name);
1988
1989    let names_const = if fallthrough.is_some() {
1990        None
1991    } else if is_variant {
1992        let variants = quote! {
1993            const VARIANTS: &'static [&'static str] = &[ #(#names),* ];
1994        };
1995        Some(variants)
1996    } else {
1997        let fields = quote! {
1998            const FIELDS: &'static [&'static str] = &[ #(#names),* ];
1999        };
2000        Some(fields)
2001    };
2002
2003    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
2004        split_with_de_lifetime(params);
2005    let delife = params.borrowed.de_lifetime();
2006    let visitor_impl = Stmts(deserialize_identifier(
2007        &this,
2008        &names_idents,
2009        is_variant,
2010        fallthrough,
2011        false,
2012    ));
2013
2014    quote_block! {
2015        #names_const
2016
2017        struct __FieldVisitor #de_impl_generics #where_clause {
2018            marker: _serde::export::PhantomData<#this #ty_generics>,
2019            lifetime: _serde::export::PhantomData<&#delife ()>,
2020        }
2021
2022        impl #de_impl_generics _serde::de::Visitor<#delife> for __FieldVisitor #de_ty_generics #where_clause {
2023            type Value = #this #ty_generics;
2024
2025            #visitor_impl
2026        }
2027
2028        let __visitor = __FieldVisitor {
2029            marker: _serde::export::PhantomData::<#this #ty_generics>,
2030            lifetime: _serde::export::PhantomData,
2031        };
2032        _serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
2033    }
2034}
2035
2036fn deserialize_identifier(
2037    this: &TokenStream,
2038    fields: &[(String, Ident, Vec<String>)],
2039    is_variant: bool,
2040    fallthrough: Option<TokenStream>,
2041    collect_other_fields: bool,
2042) -> Fragment {
2043    let mut flat_fields = Vec::new();
2044    for (_, ident, aliases) in fields {
2045        flat_fields.extend(aliases.iter().map(|alias| (alias, ident)))
2046    }
2047
2048    let field_strs = flat_fields.iter().map(|(name, _)| name);
2049    let field_borrowed_strs = flat_fields.iter().map(|(name, _)| name);
2050    let field_bytes = flat_fields
2051        .iter()
2052        .map(|(name, _)| Literal::byte_string(name.as_bytes()));
2053    let field_borrowed_bytes = flat_fields
2054        .iter()
2055        .map(|(name, _)| Literal::byte_string(name.as_bytes()));
2056
2057    let constructors: &Vec<_> = &flat_fields
2058        .iter()
2059        .map(|(_, ident)| quote!(#this::#ident))
2060        .collect();
2061    let main_constructors: &Vec<_> = &fields
2062        .iter()
2063        .map(|(_, ident, _)| quote!(#this::#ident))
2064        .collect();
2065
2066    let expecting = if is_variant {
2067        "variant identifier"
2068    } else {
2069        "field identifier"
2070    };
2071
2072    let index_expecting = if is_variant { "variant" } else { "field" };
2073
2074    let bytes_to_str = if fallthrough.is_some() || collect_other_fields {
2075        None
2076    } else {
2077        Some(quote! {
2078            let __value = &_serde::export::from_utf8_lossy(__value);
2079        })
2080    };
2081
2082    let (
2083        value_as_str_content,
2084        value_as_borrowed_str_content,
2085        value_as_bytes_content,
2086        value_as_borrowed_bytes_content,
2087    ) = if collect_other_fields {
2088        (
2089            Some(quote! {
2090                let __value = _serde::private::de::Content::String(_serde::export::ToString::to_string(__value));
2091            }),
2092            Some(quote! {
2093                let __value = _serde::private::de::Content::Str(__value);
2094            }),
2095            Some(quote! {
2096                let __value = _serde::private::de::Content::ByteBuf(__value.to_vec());
2097            }),
2098            Some(quote! {
2099                let __value = _serde::private::de::Content::Bytes(__value);
2100            }),
2101        )
2102    } else {
2103        (None, None, None, None)
2104    };
2105
2106    let fallthrough_arm = if let Some(fallthrough) = fallthrough {
2107        fallthrough
2108    } else if is_variant {
2109        quote! {
2110            _serde::export::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
2111        }
2112    } else {
2113        quote! {
2114            _serde::export::Err(_serde::de::Error::unknown_field(__value, FIELDS))
2115        }
2116    };
2117
2118    let variant_indices = 0_u64..;
2119    let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
2120    let visit_other = if collect_other_fields {
2121        quote! {
2122            fn visit_bool<__E>(self, __value: bool) -> _serde::export::Result<Self::Value, __E>
2123            where
2124                __E: _serde::de::Error,
2125            {
2126                _serde::export::Ok(__Field::__other(_serde::private::de::Content::Bool(__value)))
2127            }
2128
2129            fn visit_i8<__E>(self, __value: i8) -> _serde::export::Result<Self::Value, __E>
2130            where
2131                __E: _serde::de::Error,
2132            {
2133                _serde::export::Ok(__Field::__other(_serde::private::de::Content::I8(__value)))
2134            }
2135
2136            fn visit_i16<__E>(self, __value: i16) -> _serde::export::Result<Self::Value, __E>
2137            where
2138                __E: _serde::de::Error,
2139            {
2140                _serde::export::Ok(__Field::__other(_serde::private::de::Content::I16(__value)))
2141            }
2142
2143            fn visit_i32<__E>(self, __value: i32) -> _serde::export::Result<Self::Value, __E>
2144            where
2145                __E: _serde::de::Error,
2146            {
2147                _serde::export::Ok(__Field::__other(_serde::private::de::Content::I32(__value)))
2148            }
2149
2150            fn visit_i64<__E>(self, __value: i64) -> _serde::export::Result<Self::Value, __E>
2151            where
2152                __E: _serde::de::Error,
2153            {
2154                _serde::export::Ok(__Field::__other(_serde::private::de::Content::I64(__value)))
2155            }
2156
2157            fn visit_u8<__E>(self, __value: u8) -> _serde::export::Result<Self::Value, __E>
2158            where
2159                __E: _serde::de::Error,
2160            {
2161                _serde::export::Ok(__Field::__other(_serde::private::de::Content::U8(__value)))
2162            }
2163
2164            fn visit_u16<__E>(self, __value: u16) -> _serde::export::Result<Self::Value, __E>
2165            where
2166                __E: _serde::de::Error,
2167            {
2168                _serde::export::Ok(__Field::__other(_serde::private::de::Content::U16(__value)))
2169            }
2170
2171            fn visit_u32<__E>(self, __value: u32) -> _serde::export::Result<Self::Value, __E>
2172            where
2173                __E: _serde::de::Error,
2174            {
2175                _serde::export::Ok(__Field::__other(_serde::private::de::Content::U32(__value)))
2176            }
2177
2178            fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
2179            where
2180                __E: _serde::de::Error,
2181            {
2182                _serde::export::Ok(__Field::__other(_serde::private::de::Content::U64(__value)))
2183            }
2184
2185            fn visit_f32<__E>(self, __value: f32) -> _serde::export::Result<Self::Value, __E>
2186            where
2187                __E: _serde::de::Error,
2188            {
2189                _serde::export::Ok(__Field::__other(_serde::private::de::Content::F32(__value)))
2190            }
2191
2192            fn visit_f64<__E>(self, __value: f64) -> _serde::export::Result<Self::Value, __E>
2193            where
2194                __E: _serde::de::Error,
2195            {
2196                _serde::export::Ok(__Field::__other(_serde::private::de::Content::F64(__value)))
2197            }
2198
2199            fn visit_char<__E>(self, __value: char) -> _serde::export::Result<Self::Value, __E>
2200            where
2201                __E: _serde::de::Error,
2202            {
2203                _serde::export::Ok(__Field::__other(_serde::private::de::Content::Char(__value)))
2204            }
2205
2206            fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
2207            where
2208                __E: _serde::de::Error,
2209            {
2210                _serde::export::Ok(__Field::__other(_serde::private::de::Content::Unit))
2211            }
2212
2213            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::export::Result<Self::Value, __E>
2214            where
2215                __E: _serde::de::Error,
2216            {
2217                match __value {
2218                    #(
2219                        #field_borrowed_strs => _serde::export::Ok(#constructors),
2220                    )*
2221                    _ => {
2222                        #value_as_borrowed_str_content
2223                        #fallthrough_arm
2224                    }
2225                }
2226            }
2227
2228            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::export::Result<Self::Value, __E>
2229            where
2230                __E: _serde::de::Error,
2231            {
2232                match __value {
2233                    #(
2234                        #field_borrowed_bytes => _serde::export::Ok(#constructors),
2235                    )*
2236                    _ => {
2237                        #bytes_to_str
2238                        #value_as_borrowed_bytes_content
2239                        #fallthrough_arm
2240                    }
2241                }
2242            }
2243        }
2244    } else {
2245        quote! {
2246            fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
2247            where
2248                __E: _serde::de::Error,
2249            {
2250                match __value {
2251                    #(
2252                        #variant_indices => _serde::export::Ok(#main_constructors),
2253                    )*
2254                    _ => _serde::export::Err(_serde::de::Error::invalid_value(
2255                        _serde::de::Unexpected::Unsigned(__value),
2256                        &#fallthrough_msg,
2257                    ))
2258                }
2259            }
2260        }
2261    };
2262
2263    quote_block! {
2264        fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
2265            _serde::export::Formatter::write_str(__formatter, #expecting)
2266        }
2267
2268        #visit_other
2269
2270        fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
2271        where
2272            __E: _serde::de::Error,
2273        {
2274            match __value {
2275                #(
2276                    #field_strs => _serde::export::Ok(#constructors),
2277                )*
2278                _ => {
2279                    #value_as_str_content
2280                    #fallthrough_arm
2281                }
2282            }
2283        }
2284
2285        fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::export::Result<Self::Value, __E>
2286        where
2287            __E: _serde::de::Error,
2288        {
2289            match __value {
2290                #(
2291                    #field_bytes => _serde::export::Ok(#constructors),
2292                )*
2293                _ => {
2294                    #bytes_to_str
2295                    #value_as_bytes_content
2296                    #fallthrough_arm
2297                }
2298            }
2299        }
2300    }
2301}
2302
2303fn deserialize_struct_as_struct_visitor(
2304    struct_path: &TokenStream,
2305    params: &Parameters,
2306    fields: &[Field],
2307    cattrs: &attr::Container,
2308) -> (Fragment, Option<Fragment>, Fragment) {
2309    assert!(!cattrs.has_flatten());
2310
2311    let field_names_idents: Vec<_> = fields
2312        .iter()
2313        .enumerate()
2314        .filter(|&(_, field)| !field.attrs.skip_deserializing())
2315        .map(|(i, field)| {
2316            (
2317                field.attrs.name().deserialize_name(),
2318                field_i(i),
2319                field.attrs.aliases(),
2320            )
2321        })
2322        .collect();
2323
2324    let fields_stmt = {
2325        let field_names = field_names_idents.iter().map(|(name, _, _)| name);
2326        quote_block! {
2327            const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
2328        }
2329    };
2330
2331    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
2332
2333    let visit_map = deserialize_map(struct_path, params, fields, cattrs);
2334
2335    (field_visitor, Some(fields_stmt), visit_map)
2336}
2337
2338fn deserialize_struct_as_map_visitor(
2339    struct_path: &TokenStream,
2340    params: &Parameters,
2341    fields: &[Field],
2342    cattrs: &attr::Container,
2343) -> (Fragment, Option<Fragment>, Fragment) {
2344    let field_names_idents: Vec<_> = fields
2345        .iter()
2346        .enumerate()
2347        .filter(|&(_, field)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
2348        .map(|(i, field)| {
2349            (
2350                field.attrs.name().deserialize_name(),
2351                field_i(i),
2352                field.attrs.aliases(),
2353            )
2354        })
2355        .collect();
2356
2357    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
2358
2359    let visit_map = deserialize_map(struct_path, params, fields, cattrs);
2360
2361    (field_visitor, None, visit_map)
2362}
2363
2364fn deserialize_map(
2365    struct_path: &TokenStream,
2366    params: &Parameters,
2367    fields: &[Field],
2368    cattrs: &attr::Container,
2369) -> Fragment {
2370    // Create the field names for the fields.
2371    let fields_names: Vec<_> = fields
2372        .iter()
2373        .enumerate()
2374        .map(|(i, field)| (field, field_i(i)))
2375        .collect();
2376
2377    // Declare each field that will be deserialized.
2378    let let_values = fields_names
2379        .iter()
2380        .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
2381        .map(|(field, name)| {
2382            let field_ty = field.ty;
2383            quote! {
2384                let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
2385            }
2386        });
2387
2388    // Collect contents for flatten fields into a buffer
2389    let let_collect = if cattrs.has_flatten() {
2390        Some(quote! {
2391            let mut __collect = _serde::export::Vec::<_serde::export::Option<(
2392                _serde::private::de::Content,
2393                _serde::private::de::Content
2394            )>>::new();
2395        })
2396    } else {
2397        None
2398    };
2399
2400    // Match arms to extract a value for a field.
2401    let value_arms = fields_names
2402        .iter()
2403        .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
2404        .map(|(field, name)| {
2405            let deser_name = field.attrs.name().deserialize_name();
2406
2407            let visit = match field.attrs.deserialize_with() {
2408                None => {
2409                    let field_ty = field.ty;
2410                    let span = field.original.span();
2411                    let func =
2412                        quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>);
2413                    quote! {
2414                        try!(#func(&mut __map))
2415                    }
2416                }
2417                Some(path) => {
2418                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
2419                    quote!({
2420                        #wrapper
2421                        match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
2422                            _serde::export::Ok(__wrapper) => __wrapper.value,
2423                            _serde::export::Err(__err) => {
2424                                return _serde::export::Err(__err);
2425                            }
2426                        }
2427                    })
2428                }
2429            };
2430            quote! {
2431                __Field::#name => {
2432                    if _serde::export::Option::is_some(&#name) {
2433                        return _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
2434                    }
2435                    #name = _serde::export::Some(#visit);
2436                }
2437            }
2438        });
2439
2440    // Visit ignored values to consume them
2441    let ignored_arm = if cattrs.has_flatten() {
2442        Some(quote! {
2443            __Field::__other(__name) => {
2444                __collect.push(_serde::export::Some((
2445                    __name,
2446                    try!(_serde::de::MapAccess::next_value(&mut __map)))));
2447            }
2448        })
2449    } else if cattrs.deny_unknown_fields() {
2450        None
2451    } else {
2452        Some(quote! {
2453            _ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); }
2454        })
2455    };
2456
2457    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
2458    let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
2459        quote! {
2460            // FIXME: Once we drop support for Rust 1.15:
2461            // let _serde::export::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
2462            _serde::export::Option::map(
2463                try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
2464                |__impossible| match __impossible {});
2465        }
2466    } else {
2467        quote! {
2468            while let _serde::export::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
2469                match __key {
2470                    #(#value_arms)*
2471                    #ignored_arm
2472                }
2473            }
2474        }
2475    };
2476
2477    let extract_values = fields_names
2478        .iter()
2479        .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
2480        .map(|(field, name)| {
2481            let missing_expr = Match(expr_is_missing(field, cattrs));
2482
2483            quote! {
2484                let #name = match #name {
2485                    _serde::export::Some(#name) => #name,
2486                    _serde::export::None => #missing_expr
2487                };
2488            }
2489        });
2490
2491    let extract_collected = fields_names
2492        .iter()
2493        .filter(|&&(field, _)| field.attrs.flatten() && !field.attrs.skip_deserializing())
2494        .map(|(field, name)| {
2495            let field_ty = field.ty;
2496            let func = match field.attrs.deserialize_with() {
2497                None => {
2498                    let span = field.original.span();
2499                    quote_spanned!(span=> _serde::de::Deserialize::deserialize)
2500                }
2501                Some(path) => quote!(#path),
2502            };
2503            quote! {
2504                let #name: #field_ty = try!(#func(
2505                    _serde::private::de::FlatMapDeserializer(
2506                        &mut __collect,
2507                        _serde::export::PhantomData)));
2508            }
2509        });
2510
2511    let collected_deny_unknown_fields = if cattrs.has_flatten() && cattrs.deny_unknown_fields() {
2512        Some(quote! {
2513            if let _serde::export::Some(_serde::export::Some((__key, _))) =
2514                __collect.into_iter().filter(_serde::export::Option::is_some).next()
2515            {
2516                if let _serde::export::Some(__key) = __key.as_str() {
2517                    return _serde::export::Err(
2518                        _serde::de::Error::custom(format_args!("unknown field `{}`", &__key)));
2519                } else {
2520                    return _serde::export::Err(
2521                        _serde::de::Error::custom(format_args!("unexpected map key")));
2522                }
2523            }
2524        })
2525    } else {
2526        None
2527    };
2528
2529    let result = fields_names.iter().map(|(field, name)| {
2530        let member = &field.member;
2531        if field.attrs.skip_deserializing() {
2532            let value = Expr(expr_is_missing(field, cattrs));
2533            quote!(#member: #value)
2534        } else {
2535            quote!(#member: #name)
2536        }
2537    });
2538
2539    let let_default = match cattrs.default() {
2540        attr::Default::Default => Some(quote!(
2541            let __default: Self::Value = _serde::export::Default::default();
2542        )),
2543        attr::Default::Path(path) => Some(quote!(
2544            let __default: Self::Value = #path();
2545        )),
2546        attr::Default::None => {
2547            // We don't need the default value, to prevent an unused variable warning
2548            // we'll leave the line empty.
2549            None
2550        }
2551    };
2552
2553    let mut result = quote!(#struct_path { #(#result),* });
2554    if params.has_getter {
2555        let this = &params.this;
2556        result = quote! {
2557            _serde::export::Into::<#this>::into(#result)
2558        };
2559    }
2560
2561    quote_block! {
2562        #(#let_values)*
2563
2564        #let_collect
2565
2566        #match_keys
2567
2568        #let_default
2569
2570        #(#extract_values)*
2571
2572        #(#extract_collected)*
2573
2574        #collected_deny_unknown_fields
2575
2576        _serde::export::Ok(#result)
2577    }
2578}
2579
2580#[cfg(feature = "deserialize_in_place")]
2581fn deserialize_struct_as_struct_in_place_visitor(
2582    params: &Parameters,
2583    fields: &[Field],
2584    cattrs: &attr::Container,
2585) -> (Fragment, Fragment, Fragment) {
2586    assert!(!cattrs.has_flatten());
2587
2588    let field_names_idents: Vec<_> = fields
2589        .iter()
2590        .enumerate()
2591        .filter(|&(_, field)| !field.attrs.skip_deserializing())
2592        .map(|(i, field)| {
2593            (
2594                field.attrs.name().deserialize_name(),
2595                field_i(i),
2596                field.attrs.aliases(),
2597            )
2598        })
2599        .collect();
2600
2601    let fields_stmt = {
2602        let field_names = field_names_idents.iter().map(|(name, _, _)| name);
2603        quote_block! {
2604            const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
2605        }
2606    };
2607
2608    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
2609
2610    let visit_map = deserialize_map_in_place(params, fields, cattrs);
2611
2612    (field_visitor, fields_stmt, visit_map)
2613}
2614
2615#[cfg(feature = "deserialize_in_place")]
2616fn deserialize_map_in_place(
2617    params: &Parameters,
2618    fields: &[Field],
2619    cattrs: &attr::Container,
2620) -> Fragment {
2621    assert!(!cattrs.has_flatten());
2622
2623    // Create the field names for the fields.
2624    let fields_names: Vec<_> = fields
2625        .iter()
2626        .enumerate()
2627        .map(|(i, field)| (field, field_i(i)))
2628        .collect();
2629
2630    // For deserialize_in_place, declare booleans for each field that will be
2631    // deserialized.
2632    let let_flags = fields_names
2633        .iter()
2634        .filter(|&&(field, _)| !field.attrs.skip_deserializing())
2635        .map(|(_, name)| {
2636            quote! {
2637                let mut #name: bool = false;
2638            }
2639        });
2640
2641    // Match arms to extract a value for a field.
2642    let value_arms_from = fields_names
2643        .iter()
2644        .filter(|&&(field, _)| !field.attrs.skip_deserializing())
2645        .map(|(field, name)| {
2646            let deser_name = field.attrs.name().deserialize_name();
2647            let member = &field.member;
2648
2649            let visit = match field.attrs.deserialize_with() {
2650                None => {
2651                    quote! {
2652                        try!(_serde::de::MapAccess::next_value_seed(&mut __map, _serde::private::de::InPlaceSeed(&mut self.place.#member)))
2653                    }
2654                }
2655                Some(path) => {
2656                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
2657                    quote!({
2658                        #wrapper
2659                        self.place.#member = match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
2660                            _serde::export::Ok(__wrapper) => __wrapper.value,
2661                            _serde::export::Err(__err) => {
2662                                return _serde::export::Err(__err);
2663                            }
2664                        };
2665                    })
2666                }
2667            };
2668            quote! {
2669                __Field::#name => {
2670                    if #name {
2671                        return _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
2672                    }
2673                    #visit;
2674                    #name = true;
2675                }
2676            }
2677        });
2678
2679    // Visit ignored values to consume them
2680    let ignored_arm = if cattrs.deny_unknown_fields() {
2681        None
2682    } else {
2683        Some(quote! {
2684            _ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); }
2685        })
2686    };
2687
2688    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
2689
2690    let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
2691        quote! {
2692            // FIXME: Once we drop support for Rust 1.15:
2693            // let _serde::export::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
2694            _serde::export::Option::map(
2695                try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
2696                |__impossible| match __impossible {});
2697        }
2698    } else {
2699        quote! {
2700            while let _serde::export::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
2701                match __key {
2702                    #(#value_arms_from)*
2703                    #ignored_arm
2704                }
2705            }
2706        }
2707    };
2708
2709    let check_flags = fields_names
2710        .iter()
2711        .filter(|&&(field, _)| !field.attrs.skip_deserializing())
2712        .map(|(field, name)| {
2713            let missing_expr = expr_is_missing(field, cattrs);
2714            // If missing_expr unconditionally returns an error, don't try
2715            // to assign its value to self.place.
2716            if field.attrs.default().is_none()
2717                && cattrs.default().is_none()
2718                && field.attrs.deserialize_with().is_some()
2719            {
2720                let missing_expr = Stmts(missing_expr);
2721                quote! {
2722                    if !#name {
2723                        #missing_expr;
2724                    }
2725                }
2726            } else {
2727                let member = &field.member;
2728                let missing_expr = Expr(missing_expr);
2729                quote! {
2730                    if !#name {
2731                        self.place.#member = #missing_expr;
2732                    };
2733                }
2734            }
2735        });
2736
2737    let this = &params.this;
2738    let (_, _, ty_generics, _) = split_with_de_lifetime(params);
2739
2740    let let_default = match cattrs.default() {
2741        attr::Default::Default => Some(quote!(
2742            let __default: #this #ty_generics = _serde::export::Default::default();
2743        )),
2744        attr::Default::Path(path) => Some(quote!(
2745            let __default: #this #ty_generics = #path();
2746        )),
2747        attr::Default::None => {
2748            // We don't need the default value, to prevent an unused variable warning
2749            // we'll leave the line empty.
2750            None
2751        }
2752    };
2753
2754    quote_block! {
2755        #(#let_flags)*
2756
2757        #match_keys
2758
2759        #let_default
2760
2761        #(#check_flags)*
2762
2763        _serde::export::Ok(())
2764    }
2765}
2766
2767fn field_i(i: usize) -> Ident {
2768    Ident::new(&format!("__field{}", i), Span::call_site())
2769}
2770
2771/// This function wraps the expression in `#[serde(deserialize_with = "...")]`
2772/// in a trait to prevent it from accessing the internal `Deserialize` state.
2773fn wrap_deserialize_with(
2774    params: &Parameters,
2775    value_ty: &TokenStream,
2776    deserialize_with: &syn::ExprPath,
2777) -> (TokenStream, TokenStream) {
2778    let this = &params.this;
2779    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
2780        split_with_de_lifetime(params);
2781    let delife = params.borrowed.de_lifetime();
2782
2783    let wrapper = quote! {
2784        struct __DeserializeWith #de_impl_generics #where_clause {
2785            value: #value_ty,
2786            phantom: _serde::export::PhantomData<#this #ty_generics>,
2787            lifetime: _serde::export::PhantomData<&#delife ()>,
2788        }
2789
2790        impl #de_impl_generics _serde::Deserialize<#delife> for __DeserializeWith #de_ty_generics #where_clause {
2791            fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
2792            where
2793                __D: _serde::Deserializer<#delife>,
2794            {
2795                _serde::export::Ok(__DeserializeWith {
2796                    value: try!(#deserialize_with(__deserializer)),
2797                    phantom: _serde::export::PhantomData,
2798                    lifetime: _serde::export::PhantomData,
2799                })
2800            }
2801        }
2802    };
2803
2804    let wrapper_ty = quote!(__DeserializeWith #de_ty_generics);
2805
2806    (wrapper, wrapper_ty)
2807}
2808
2809fn wrap_deserialize_field_with(
2810    params: &Parameters,
2811    field_ty: &syn::Type,
2812    deserialize_with: &syn::ExprPath,
2813) -> (TokenStream, TokenStream) {
2814    wrap_deserialize_with(params, &quote!(#field_ty), deserialize_with)
2815}
2816
2817fn wrap_deserialize_variant_with(
2818    params: &Parameters,
2819    variant: &Variant,
2820    deserialize_with: &syn::ExprPath,
2821) -> (TokenStream, TokenStream, TokenStream) {
2822    let this = &params.this;
2823    let variant_ident = &variant.ident;
2824
2825    let field_tys = variant.fields.iter().map(|field| field.ty);
2826    let (wrapper, wrapper_ty) =
2827        wrap_deserialize_with(params, &quote!((#(#field_tys),*)), deserialize_with);
2828
2829    let field_access = (0..variant.fields.len()).map(|n| {
2830        Member::Unnamed(Index {
2831            index: n as u32,
2832            span: Span::call_site(),
2833        })
2834    });
2835    let unwrap_fn = match variant.style {
2836        Style::Struct if variant.fields.len() == 1 => {
2837            let member = &variant.fields[0].member;
2838            quote! {
2839                |__wrap| #this::#variant_ident { #member: __wrap.value }
2840            }
2841        }
2842        Style::Struct => {
2843            let members = variant.fields.iter().map(|field| &field.member);
2844            quote! {
2845                |__wrap| #this::#variant_ident { #(#members: __wrap.value.#field_access),* }
2846            }
2847        }
2848        Style::Tuple => quote! {
2849            |__wrap| #this::#variant_ident(#(__wrap.value.#field_access),*)
2850        },
2851        Style::Newtype => quote! {
2852            |__wrap| #this::#variant_ident(__wrap.value)
2853        },
2854        Style::Unit => quote! {
2855            |__wrap| #this::#variant_ident
2856        },
2857    };
2858
2859    (wrapper, wrapper_ty, unwrap_fn)
2860}
2861
2862fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
2863    match field.attrs.default() {
2864        attr::Default::Default => {
2865            let span = field.original.span();
2866            let func = quote_spanned!(span=> _serde::export::Default::default);
2867            return quote_expr!(#func());
2868        }
2869        attr::Default::Path(path) => {
2870            return quote_expr!(#path());
2871        }
2872        attr::Default::None => { /* below */ }
2873    }
2874
2875    match *cattrs.default() {
2876        attr::Default::Default | attr::Default::Path(_) => {
2877            let member = &field.member;
2878            return quote_expr!(__default.#member);
2879        }
2880        attr::Default::None => { /* below */ }
2881    }
2882
2883    let name = field.attrs.name().deserialize_name();
2884    match field.attrs.deserialize_with() {
2885        None => {
2886            let span = field.original.span();
2887            let func = quote_spanned!(span=> _serde::private::de::missing_field);
2888            quote_expr! {
2889                try!(#func(#name))
2890            }
2891        }
2892        Some(_) => {
2893            quote_expr! {
2894                return _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
2895            }
2896        }
2897    }
2898}
2899
2900fn effective_style(variant: &Variant) -> Style {
2901    match variant.style {
2902        Style::Newtype if variant.fields[0].attrs.skip_deserializing() => Style::Unit,
2903        other => other,
2904    }
2905}
2906
2907struct DeImplGenerics<'a>(&'a Parameters);
2908#[cfg(feature = "deserialize_in_place")]
2909struct InPlaceImplGenerics<'a>(&'a Parameters);
2910
2911impl<'a> ToTokens for DeImplGenerics<'a> {
2912    fn to_tokens(&self, tokens: &mut TokenStream) {
2913        let mut generics = self.0.generics.clone();
2914        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
2915            generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
2916                .into_iter()
2917                .chain(generics.params)
2918                .collect();
2919        }
2920        let (impl_generics, _, _) = generics.split_for_impl();
2921        impl_generics.to_tokens(tokens);
2922    }
2923}
2924
2925#[cfg(feature = "deserialize_in_place")]
2926impl<'a> ToTokens for InPlaceImplGenerics<'a> {
2927    fn to_tokens(&self, tokens: &mut TokenStream) {
2928        let place_lifetime = place_lifetime();
2929        let mut generics = self.0.generics.clone();
2930
2931        // Add lifetime for `&'place mut Self, and `'a: 'place`
2932        for param in &mut generics.params {
2933            match param {
2934                syn::GenericParam::Lifetime(param) => {
2935                    param.bounds.push(place_lifetime.lifetime.clone());
2936                }
2937                syn::GenericParam::Type(param) => {
2938                    param.bounds.push(syn::TypeParamBound::Lifetime(
2939                        place_lifetime.lifetime.clone(),
2940                    ));
2941                }
2942                syn::GenericParam::Const(_) => {}
2943            }
2944        }
2945        generics.params = Some(syn::GenericParam::Lifetime(place_lifetime))
2946            .into_iter()
2947            .chain(generics.params)
2948            .collect();
2949        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
2950            generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
2951                .into_iter()
2952                .chain(generics.params)
2953                .collect();
2954        }
2955        let (impl_generics, _, _) = generics.split_for_impl();
2956        impl_generics.to_tokens(tokens);
2957    }
2958}
2959
2960#[cfg(feature = "deserialize_in_place")]
2961impl<'a> DeImplGenerics<'a> {
2962    fn in_place(self) -> InPlaceImplGenerics<'a> {
2963        InPlaceImplGenerics(self.0)
2964    }
2965}
2966
2967struct DeTypeGenerics<'a>(&'a Parameters);
2968#[cfg(feature = "deserialize_in_place")]
2969struct InPlaceTypeGenerics<'a>(&'a Parameters);
2970
2971impl<'a> ToTokens for DeTypeGenerics<'a> {
2972    fn to_tokens(&self, tokens: &mut TokenStream) {
2973        let mut generics = self.0.generics.clone();
2974        if self.0.borrowed.de_lifetime_def().is_some() {
2975            let def = syn::LifetimeDef {
2976                attrs: Vec::new(),
2977                lifetime: syn::Lifetime::new("'de", Span::call_site()),
2978                colon_token: None,
2979                bounds: Punctuated::new(),
2980            };
2981            generics.params = Some(syn::GenericParam::Lifetime(def))
2982                .into_iter()
2983                .chain(generics.params)
2984                .collect();
2985        }
2986        let (_, ty_generics, _) = generics.split_for_impl();
2987        ty_generics.to_tokens(tokens);
2988    }
2989}
2990
2991#[cfg(feature = "deserialize_in_place")]
2992impl<'a> ToTokens for InPlaceTypeGenerics<'a> {
2993    fn to_tokens(&self, tokens: &mut TokenStream) {
2994        let mut generics = self.0.generics.clone();
2995        generics.params = Some(syn::GenericParam::Lifetime(place_lifetime()))
2996            .into_iter()
2997            .chain(generics.params)
2998            .collect();
2999
3000        if self.0.borrowed.de_lifetime_def().is_some() {
3001            let def = syn::LifetimeDef {
3002                attrs: Vec::new(),
3003                lifetime: syn::Lifetime::new("'de", Span::call_site()),
3004                colon_token: None,
3005                bounds: Punctuated::new(),
3006            };
3007            generics.params = Some(syn::GenericParam::Lifetime(def))
3008                .into_iter()
3009                .chain(generics.params)
3010                .collect();
3011        }
3012        let (_, ty_generics, _) = generics.split_for_impl();
3013        ty_generics.to_tokens(tokens);
3014    }
3015}
3016
3017#[cfg(feature = "deserialize_in_place")]
3018impl<'a> DeTypeGenerics<'a> {
3019    fn in_place(self) -> InPlaceTypeGenerics<'a> {
3020        InPlaceTypeGenerics(self.0)
3021    }
3022}
3023
3024#[cfg(feature = "deserialize_in_place")]
3025fn place_lifetime() -> syn::LifetimeDef {
3026    syn::LifetimeDef {
3027        attrs: Vec::new(),
3028        lifetime: syn::Lifetime::new("'place", Span::call_site()),
3029        colon_token: None,
3030        bounds: Punctuated::new(),
3031    }
3032}
3033
3034fn split_with_de_lifetime(
3035    params: &Parameters,
3036) -> (
3037    DeImplGenerics,
3038    DeTypeGenerics,
3039    syn::TypeGenerics,
3040    Option<&syn::WhereClause>,
3041) {
3042    let de_impl_generics = DeImplGenerics(params);
3043    let de_ty_generics = DeTypeGenerics(params);
3044    let (_, ty_generics, where_clause) = params.generics.split_for_impl();
3045    (de_impl_generics, de_ty_generics, ty_generics, where_clause)
3046}