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