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