serde_derive/
de.rs

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