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