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