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