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