pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-13 12:31:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fragments that keep track of type of syntax

Browse Source 
Fixes #777.
This commit is contained in:
David Tolnay
2017-02-20 14:43:51 -08:00
parent 3d6e086d3e
commit 599a1b6607
4 changed files with 225 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_derive/src/de.rs
+79 -73
View File
@@ -2,6 +2,7 @@ use syn::{self, Ident};
use quote::{self, Tokens}; use quote::{self, Tokens};
use bound; use bound;
use fragment::{Fragment, Expr, Stmts, Match};
use internals::ast::{Body, Field, Item, Style, Variant}; use internals::ast::{Body, Field, Item, Style, Variant};
use internals::{self, attr}; use internals::{self, attr};
@@ -18,7 +19,7 @@ pub fn expand_derive_deserialize(item: &syn::DeriveInput) -> Result<Tokens, Stri
let generics = build_generics(&item); let generics = build_generics(&item);
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
let dummy_const = Ident::new(format!("_IMPL_DESERIALIZE_FOR_{}", ident)); let dummy_const = Ident::new(format!("_IMPL_DESERIALIZE_FOR_{}", ident));
let body = deserialize_body(&item, &generics); let body = Stmts(deserialize_body(&item, &generics));
Ok(quote! { Ok(quote! {
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
@@ -28,7 +29,9 @@ pub fn expand_derive_deserialize(item: &syn::DeriveInput) -> Result<Tokens, Stri
impl #impl_generics _serde::Deserialize for #ident #ty_generics #where_clause { impl #impl_generics _serde::Deserialize for #ident #ty_generics #where_clause {
fn deserialize<__D>(deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where __D: _serde::Deserializer where __D: _serde::Deserializer
#body {
#body
}
} }
}; };
}) })
@@ -81,7 +84,7 @@ fn requires_default(attrs: &attr::Field) -> bool {
attrs.default() == &attr::Default::Default attrs.default() == &attr::Default::Default
} }
fn deserialize_body(item: &Item, generics: &syn::Generics) -> Tokens { fn deserialize_body(item: &Item, generics: &syn::Generics) -> Fragment {
match item.body { match item.body {
Body::Enum(ref variants) => { Body::Enum(ref variants) => {
deserialize_item_enum(&item.ident, generics, variants, &item.attrs) deserialize_item_enum(&item.ident, generics, variants, &item.attrs)
@@ -115,12 +118,12 @@ fn deserialize_body(item: &Item, generics: &syn::Generics) -> Tokens {
} }
} }
fn deserialize_unit_struct(ident: &syn::Ident, item_attrs: &attr::Item) -> Tokens { fn deserialize_unit_struct(ident: &syn::Ident, item_attrs: &attr::Item) -> Fragment {
let type_name = item_attrs.name().deserialize_name(); let type_name = item_attrs.name().deserialize_name();
let expecting = format!("unit struct {}", ident); let expecting = format!("unit struct {}", ident);
quote!({ quote_block! {
struct __Visitor; struct __Visitor;
impl _serde::de::Visitor for __Visitor { impl _serde::de::Visitor for __Visitor {
@@ -146,7 +149,7 @@ fn deserialize_unit_struct(ident: &syn::Ident, item_attrs: &attr::Item) -> Token
} }
deserializer.deserialize_unit_struct(#type_name, __Visitor) deserializer.deserialize_unit_struct(#type_name, __Visitor)
}) }
} }
fn deserialize_tuple(ident: &syn::Ident, fn deserialize_tuple(ident: &syn::Ident,
@@ -155,7 +158,7 @@ fn deserialize_tuple(ident: &syn::Ident,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item, item_attrs: &attr::Item,
deserializer: Option<Tokens>) deserializer: Option<Tokens>)
-> Tokens { -> Fragment {
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
let is_enum = variant_ident.is_some(); let is_enum = variant_ident.is_some();
@@ -176,7 +179,7 @@ fn deserialize_tuple(ident: &syn::Ident,
None None
}; };
let visit_seq = deserialize_seq(ident, &type_path, generics, fields, false, item_attrs); let visit_seq = Stmts(deserialize_seq(ident, &type_path, generics, fields, false, item_attrs));
let visitor_expr = quote! { let visitor_expr = quote! {
__Visitor { marker: _serde::export::PhantomData::<#ident #ty_generics> } __Visitor { marker: _serde::export::PhantomData::<#ident #ty_generics> }
@@ -200,7 +203,7 @@ fn deserialize_tuple(ident: &syn::Ident,
quote!(mut visitor) quote!(mut visitor)
}; };
quote!({ quote_block! {
struct __Visitor #impl_generics #where_clause { struct __Visitor #impl_generics #where_clause {
marker: _serde::export::PhantomData<#ident #ty_generics>, marker: _serde::export::PhantomData<#ident #ty_generics>,
} }
@@ -223,7 +226,7 @@ fn deserialize_tuple(ident: &syn::Ident,
} }
#dispatch #dispatch
}) }
} }
fn deserialize_seq(ident: &syn::Ident, fn deserialize_seq(ident: &syn::Ident,
@@ -232,7 +235,7 @@ fn deserialize_seq(ident: &syn::Ident,
fields: &[Field], fields: &[Field],
is_struct: bool, is_struct: bool,
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
let vars = (0..fields.len()).map(field_i as fn(_) -> _); let vars = (0..fields.len()).map(field_i as fn(_) -> _);
let deserialized_count = fields.iter() let deserialized_count = fields.iter()
@@ -244,7 +247,7 @@ fn deserialize_seq(ident: &syn::Ident,
let let_values = vars.clone().zip(fields) let let_values = vars.clone().zip(fields)
.map(|(var, field)| { .map(|(var, field)| {
if field.attrs.skip_deserializing() { if field.attrs.skip_deserializing() {
let default = expr_is_missing(&field, item_attrs); let default = Expr(expr_is_missing(&field, item_attrs));
quote! { quote! {
let #var = #default; let #var = #default;
} }
@@ -288,7 +291,7 @@ fn deserialize_seq(ident: &syn::Ident,
} }
}; };
quote! { quote_block! {
#(#let_values)* #(#let_values)*
_serde::export::Ok(#result) _serde::export::Ok(#result)
} }
@@ -331,7 +334,7 @@ fn deserialize_struct(ident: &syn::Ident,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item, item_attrs: &attr::Item,
deserializer: Option<Tokens>) deserializer: Option<Tokens>)
-> Tokens { -> Fragment {
let is_enum = variant_ident.is_some(); let is_enum = variant_ident.is_some();
let is_untagged = deserializer.is_some(); let is_untagged = deserializer.is_some();
@@ -346,10 +349,13 @@ fn deserialize_struct(ident: &syn::Ident,
None => format!("struct {}", ident), None => format!("struct {}", ident),
}; };
let visit_seq = deserialize_seq(ident, &type_path, generics, fields, true, item_attrs); let visit_seq = Stmts(deserialize_seq(ident, &type_path, generics, fields, true, item_attrs));
let (field_visitor, fields_stmt, visit_map) = let (field_visitor, fields_stmt, visit_map) =
deserialize_struct_visitor(ident, type_path, generics, fields, item_attrs); deserialize_struct_visitor(ident, type_path, generics, fields, item_attrs);
let field_visitor = Stmts(field_visitor);
let fields_stmt = Stmts(fields_stmt);
let visit_map = Stmts(visit_map);
let visitor_expr = quote! { let visitor_expr = quote! {
__Visitor { marker: _serde::export::PhantomData::<#ident #ty_generics> } __Visitor { marker: _serde::export::PhantomData::<#ident #ty_generics> }
@@ -390,7 +396,7 @@ fn deserialize_struct(ident: &syn::Ident,
}) })
}; };
quote!({ quote_block! {
#field_visitor #field_visitor
struct __Visitor #impl_generics #where_clause { struct __Visitor #impl_generics #where_clause {
@@ -417,14 +423,14 @@ fn deserialize_struct(ident: &syn::Ident,
#fields_stmt #fields_stmt
#dispatch #dispatch
}) }
} }
fn deserialize_item_enum(ident: &syn::Ident, fn deserialize_item_enum(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
variants: &[Variant], variants: &[Variant],
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
match *item_attrs.tag() { match *item_attrs.tag() {
attr::EnumTag::External => { attr::EnumTag::External => {
deserialize_externally_tagged_enum(ident, generics, variants, item_attrs) deserialize_externally_tagged_enum(ident, generics, variants, item_attrs)
@@ -447,7 +453,7 @@ fn deserialize_externally_tagged_enum(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
variants: &[Variant], variants: &[Variant],
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
let type_name = item_attrs.name().deserialize_name(); let type_name = item_attrs.name().deserialize_name();
@@ -467,7 +473,7 @@ fn deserialize_externally_tagged_enum(ident: &syn::Ident,
} }
}; };
let variant_visitor = deserialize_field_visitor(variant_names_idents, item_attrs, true); let variant_visitor = Stmts(deserialize_field_visitor(variant_names_idents, item_attrs, true));
// Match arms to extract a variant from a string // Match arms to extract a variant from a string
let variant_arms = variants.iter() let variant_arms = variants.iter()
@@ -476,10 +482,10 @@ fn deserialize_externally_tagged_enum(ident: &syn::Ident,
.map(|(i, variant)| { .map(|(i, variant)| {
let variant_name = field_i(i); let variant_name = field_i(i);
let block = deserialize_externally_tagged_variant(ident, let block = Match(deserialize_externally_tagged_variant(ident,
generics, generics,
variant, variant,
item_attrs); item_attrs));
quote! { quote! {
(__Field::#variant_name, visitor) => #block (__Field::#variant_name, visitor) => #block
@@ -505,7 +511,7 @@ fn deserialize_externally_tagged_enum(ident: &syn::Ident,
} }
}; };
quote!({ quote_block! {
#variant_visitor #variant_visitor
struct __Visitor #impl_generics #where_clause { struct __Visitor #impl_generics #where_clause {
@@ -532,7 +538,7 @@ fn deserialize_externally_tagged_enum(ident: &syn::Ident,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<#ident #ty_generics>, marker: _serde::export::PhantomData::<#ident #ty_generics>,
}) })
}) }
} }
fn deserialize_internally_tagged_enum(ident: &syn::Ident, fn deserialize_internally_tagged_enum(ident: &syn::Ident,
@@ -540,7 +546,7 @@ fn deserialize_internally_tagged_enum(ident: &syn::Ident,
variants: &[Variant], variants: &[Variant],
item_attrs: &attr::Item, item_attrs: &attr::Item,
tag: &str) tag: &str)
-> Tokens { -> Fragment {
let variant_names_idents: Vec<_> = variants.iter() let variant_names_idents: Vec<_> = variants.iter()
.enumerate() .enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing()) .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
@@ -554,7 +560,7 @@ fn deserialize_internally_tagged_enum(ident: &syn::Ident,
} }
}; };
let variant_visitor = deserialize_field_visitor(variant_names_idents, item_attrs, true); let variant_visitor = Stmts(deserialize_field_visitor(variant_names_idents, item_attrs, true));
// Match arms to extract a variant from a string // Match arms to extract a variant from a string
let variant_arms = variants.iter() let variant_arms = variants.iter()
@@ -563,20 +569,20 @@ fn deserialize_internally_tagged_enum(ident: &syn::Ident,
.map(|(i, variant)| { .map(|(i, variant)| {
let variant_name = field_i(i); let variant_name = field_i(i);
let block = deserialize_internally_tagged_variant( let block = Match(deserialize_internally_tagged_variant(
ident, ident,
generics, generics,
variant, variant,
item_attrs, item_attrs,
quote!(_serde::de::private::ContentDeserializer::<__D::Error>::new(_tagged.content)), quote!(_serde::de::private::ContentDeserializer::<__D::Error>::new(_tagged.content)),
); ));
quote! { quote! {
__Field::#variant_name => #block __Field::#variant_name => #block
} }
}); });
quote!({ quote_block! {
#variant_visitor #variant_visitor
#variants_stmt #variants_stmt
@@ -588,24 +594,24 @@ fn deserialize_internally_tagged_enum(ident: &syn::Ident,
match _tagged.tag { match _tagged.tag {
#(#variant_arms)* #(#variant_arms)*
} }
}) }
} }
fn deserialize_untagged_enum(ident: &syn::Ident, fn deserialize_untagged_enum(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
variants: &[Variant], variants: &[Variant],
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
let attempts = variants.iter() let attempts = variants.iter()
.filter(|variant| !variant.attrs.skip_deserializing()) .filter(|variant| !variant.attrs.skip_deserializing())
.map(|variant| { .map(|variant| {
deserialize_untagged_variant( Expr(deserialize_untagged_variant(
ident, ident,
generics, generics,
variant, variant,
item_attrs, item_attrs,
quote!(_serde::de::private::ContentRefDeserializer::<__D::Error>::new(&_content)), quote!(_serde::de::private::ContentRefDeserializer::<__D::Error>::new(&_content)),
) ))
}); });
// TODO this message could be better by saving the errors from the failed // TODO this message could be better by saving the errors from the failed
@@ -616,7 +622,7 @@ fn deserialize_untagged_enum(ident: &syn::Ident,
// explains why none of the variants matched. // explains why none of the variants matched.
let fallthrough_msg = format!("data did not match any variant of untagged enum {}", ident); let fallthrough_msg = format!("data did not match any variant of untagged enum {}", ident);
quote!({ quote_block! {
let _content = try!(<_serde::de::private::Content as _serde::Deserialize>::deserialize(deserializer)); let _content = try!(<_serde::de::private::Content as _serde::Deserialize>::deserialize(deserializer));
#( #(
@@ -626,22 +632,22 @@ fn deserialize_untagged_enum(ident: &syn::Ident,
)* )*
_serde::export::Err(_serde::de::Error::custom(#fallthrough_msg)) _serde::export::Err(_serde::de::Error::custom(#fallthrough_msg))
}) }
} }
fn deserialize_externally_tagged_variant(ident: &syn::Ident, fn deserialize_externally_tagged_variant(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
variant: &Variant, variant: &Variant,
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
let variant_ident = &variant.ident; let variant_ident = &variant.ident;
match variant.style { match variant.style {
Style::Unit => { Style::Unit => {
quote!({ quote_block! {
try!(_serde::de::VariantVisitor::visit_unit(visitor)); try!(_serde::de::VariantVisitor::visit_unit(visitor));
_serde::export::Ok(#ident::#variant_ident) _serde::export::Ok(#ident::#variant_ident)
}) }
} }
Style::Newtype => { Style::Newtype => {
deserialize_externally_tagged_newtype_variant(ident, deserialize_externally_tagged_newtype_variant(ident,
@@ -673,17 +679,17 @@ fn deserialize_internally_tagged_variant(ident: &syn::Ident,
variant: &Variant, variant: &Variant,
item_attrs: &attr::Item, item_attrs: &attr::Item,
deserializer: Tokens) deserializer: Tokens)
-> Tokens { -> Fragment {
let variant_ident = &variant.ident; let variant_ident = &variant.ident;
match variant.style { match variant.style {
Style::Unit => { Style::Unit => {
let type_name = ident.as_ref(); let type_name = ident.as_ref();
let variant_name = variant.ident.as_ref(); let variant_name = variant.ident.as_ref();
quote!({ quote_block! {
try!(_serde::Deserializer::deserialize(#deserializer, _serde::de::private::InternallyTaggedUnitVisitor::new(#type_name, #variant_name))); try!(_serde::Deserializer::deserialize(#deserializer, _serde::de::private::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
_serde::export::Ok(#ident::#variant_ident) _serde::export::Ok(#ident::#variant_ident)
}) }
} }
Style::Newtype | Style::Struct => { Style::Newtype | Style::Struct => {
deserialize_untagged_variant(ident, deserialize_untagged_variant(ident,
@@ -701,14 +707,14 @@ fn deserialize_untagged_variant(ident: &syn::Ident,
variant: &Variant, variant: &Variant,
item_attrs: &attr::Item, item_attrs: &attr::Item,
deserializer: Tokens) deserializer: Tokens)
-> Tokens { -> Fragment {
let variant_ident = &variant.ident; let variant_ident = &variant.ident;
match variant.style { match variant.style {
Style::Unit => { Style::Unit => {
let type_name = ident.as_ref(); let type_name = ident.as_ref();
let variant_name = variant.ident.as_ref(); let variant_name = variant.ident.as_ref();
quote! { quote_expr! {
_serde::export::Result::map( _serde::export::Result::map(
_serde::Deserializer::deserialize( _serde::Deserializer::deserialize(
#deserializer, #deserializer,
@@ -747,25 +753,25 @@ fn deserialize_externally_tagged_newtype_variant(ident: &syn::Ident,
variant_ident: &syn::Ident, variant_ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
field: &Field) field: &Field)
-> Tokens { -> Fragment {
match field.attrs.deserialize_with() { match field.attrs.deserialize_with() {
None => { None => {
let field_ty = &field.ty; let field_ty = &field.ty;
quote! { quote_expr! {
_serde::export::Result::map( _serde::export::Result::map(
_serde::de::VariantVisitor::visit_newtype::<#field_ty>(visitor), _serde::de::VariantVisitor::visit_newtype::<#field_ty>(visitor),
#ident::#variant_ident), #ident::#variant_ident)
} }
} }
Some(path) => { Some(path) => {
let (wrapper, wrapper_ty) = let (wrapper, wrapper_ty) =
wrap_deserialize_with(ident, generics, field.ty, path); wrap_deserialize_with(ident, generics, field.ty, path);
quote!({ quote_block! {
#wrapper #wrapper
_serde::export::Result::map( _serde::export::Result::map(
_serde::de::VariantVisitor::visit_newtype::<#wrapper_ty>(visitor), _serde::de::VariantVisitor::visit_newtype::<#wrapper_ty>(visitor),
|_wrapper| #ident::#variant_ident(_wrapper.value)) |_wrapper| #ident::#variant_ident(_wrapper.value))
}) }
} }
} }
} }
@@ -775,25 +781,25 @@ fn deserialize_untagged_newtype_variant(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
field: &Field, field: &Field,
deserializer: Tokens) deserializer: Tokens)
-> Tokens { -> Fragment {
match field.attrs.deserialize_with() { match field.attrs.deserialize_with() {
None => { None => {
let field_ty = &field.ty; let field_ty = &field.ty;
quote!({ quote_expr! {
_serde::export::Result::map( _serde::export::Result::map(
<#field_ty as _serde::Deserialize>::deserialize(#deserializer), <#field_ty as _serde::Deserialize>::deserialize(#deserializer),
#ident::#variant_ident) #ident::#variant_ident)
}) }
} }
Some(path) => { Some(path) => {
let (wrapper, wrapper_ty) = let (wrapper, wrapper_ty) =
wrap_deserialize_with(ident, generics, field.ty, path); wrap_deserialize_with(ident, generics, field.ty, path);
quote!({ quote_block! {
#wrapper #wrapper
_serde::export::Result::map( _serde::export::Result::map(
<#wrapper_ty as _serde::Deserialize>::deserialize(#deserializer), <#wrapper_ty as _serde::Deserialize>::deserialize(#deserializer),
|_wrapper| #ident::#variant_ident(_wrapper.value)) |_wrapper| #ident::#variant_ident(_wrapper.value))
}) }
} }
} }
} }
@@ -801,7 +807,7 @@ fn deserialize_untagged_newtype_variant(ident: &syn::Ident,
fn deserialize_field_visitor(fields: Vec<(String, Ident)>, fn deserialize_field_visitor(fields: Vec<(String, Ident)>,
item_attrs: &attr::Item, item_attrs: &attr::Item,
is_variant: bool) is_variant: bool)
-> Tokens { -> Fragment {
let field_strs = fields.iter().map(|&(ref name, _)| name); let field_strs = fields.iter().map(|&(ref name, _)| name);
let field_bytes = fields.iter().map(|&(ref name, _)| quote::ByteStr(name)); let field_bytes = fields.iter().map(|&(ref name, _)| quote::ByteStr(name));
let field_idents: &Vec<_> = &fields.iter().map(|&(_, ref ident)| ident).collect(); let field_idents: &Vec<_> = &fields.iter().map(|&(_, ref ident)| ident).collect();
@@ -855,7 +861,7 @@ fn deserialize_field_visitor(fields: Vec<(String, Ident)>,
None None
}; };
quote! { quote_block! {
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
enum __Field { enum __Field {
#(#field_idents,)* #(#field_idents,)*
@@ -915,7 +921,7 @@ fn deserialize_struct_visitor(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> (Tokens, Tokens, Tokens) { -> (Fragment, Fragment, Fragment) {
let field_names_idents: Vec<_> = fields.iter() let field_names_idents: Vec<_> = fields.iter()
.enumerate() .enumerate()
.filter(|&(_, field)| !field.attrs.skip_deserializing()) .filter(|&(_, field)| !field.attrs.skip_deserializing())
@@ -924,7 +930,7 @@ fn deserialize_struct_visitor(ident: &syn::Ident,
let fields_stmt = { let fields_stmt = {
let field_names = field_names_idents.iter().map(|&(ref name, _)| name); let field_names = field_names_idents.iter().map(|&(ref name, _)| name);
quote! { quote_block! {
const FIELDS: &'static [&'static str] = &[ #(#field_names),* ]; const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
} }
}; };
@@ -941,7 +947,7 @@ fn deserialize_map(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
// Create the field names for the fields. // Create the field names for the fields.
let fields_names: Vec<_> = fields.iter() let fields_names: Vec<_> = fields.iter()
.enumerate() .enumerate()
@@ -1021,7 +1027,7 @@ fn deserialize_map(ident: &syn::Ident,
let extract_values = fields_names.iter() let extract_values = fields_names.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing()) .filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| { .map(|&(field, ref name)| {
let missing_expr = expr_is_missing(&field, item_attrs); let missing_expr = Match(expr_is_missing(&field, item_attrs));
quote! { quote! {
let #name = match #name { let #name = match #name {
@@ -1034,12 +1040,12 @@ fn deserialize_map(ident: &syn::Ident,
let result = fields_names.iter() let result = fields_names.iter()
.map(|&(field, ref name)| { .map(|&(field, ref name)| {
let ident = field.ident.clone().expect("struct contains unnamed fields"); let ident = field.ident.clone().expect("struct contains unnamed fields");
let value = if field.attrs.skip_deserializing() { if field.attrs.skip_deserializing() {
expr_is_missing(&field, item_attrs) let value = Expr(expr_is_missing(&field, item_attrs));
quote!(#ident: #value)
} else { } else {
quote!(#name) quote!(#ident: #name)
}; }
quote!(#ident: #value)
}); });
let let_default = match *item_attrs.default() { let let_default = match *item_attrs.default() {
@@ -1060,7 +1066,7 @@ fn deserialize_map(ident: &syn::Ident,
} }
}; };
quote! { quote_block! {
#(#let_values)* #(#let_values)*
#match_keys #match_keys
@@ -1110,13 +1116,13 @@ fn wrap_deserialize_with(ident: &syn::Ident,
(wrapper, wrapper_ty) (wrapper, wrapper_ty)
} }
fn expr_is_missing(field: &Field, item_attrs: &attr::Item) -> Tokens { fn expr_is_missing(field: &Field, item_attrs: &attr::Item) -> Fragment {
match *field.attrs.default() { match *field.attrs.default() {
attr::Default::Default => { attr::Default::Default => {
return quote!(_serde::export::Default::default()); return quote_expr!(_serde::export::Default::default());
} }
attr::Default::Path(ref path) => { attr::Default::Path(ref path) => {
return quote!(#path()); return quote_expr!(#path());
} }
attr::Default::None => { /* below */ } attr::Default::None => { /* below */ }
} }
@@ -1124,7 +1130,7 @@ fn expr_is_missing(field: &Field, item_attrs: &attr::Item) -> Tokens {
match *item_attrs.default() { match *item_attrs.default() {
attr::Default::Default | attr::Default::Path(_) => { attr::Default::Default | attr::Default::Path(_) => {
let ident = &field.ident; let ident = &field.ident;
return quote!(__default.#ident); return quote_expr!(__default.#ident);
} }
attr::Default::None => { /* below */ } attr::Default::None => { /* below */ }
} }
@@ -1132,12 +1138,12 @@ fn expr_is_missing(field: &Field, item_attrs: &attr::Item) -> Tokens {
let name = field.attrs.name().deserialize_name(); let name = field.attrs.name().deserialize_name();
match field.attrs.deserialize_with() { match field.attrs.deserialize_with() {
None => { None => {
quote! { quote_expr! {
try!(_serde::de::private::missing_field(#name)) try!(_serde::de::private::missing_field(#name))
} }
} }
Some(_) => { Some(_) => {
quote! { quote_expr! {
return _serde::export::Err(<__V::Error as _serde::de::Error>::missing_field(#name)) return _serde::export::Err(<__V::Error as _serde::de::Error>::missing_field(#name))
} }
} }
serde_derive/src/fragment.rs
+67
View File
@@ -0,0 +1,67 @@
use quote::{Tokens, ToTokens};
pub enum Fragment {
/// Tokens that can be used as an expression.
Expr(Tokens),
/// Tokens that can be used inside a block. The surrounding curly braces are
/// not part of these tokens.
Block(Tokens),
}
macro_rules! quote_expr {
($($tt:tt)*) => {
$crate::fragment::Fragment::Expr(quote!($($tt)*))
}
}
macro_rules! quote_block {
($($tt:tt)*) => {
$crate::fragment::Fragment::Block(quote!($($tt)*))
}
}
/// Interpolate a fragment in place of an expression. This involves surrounding
/// Block fragments in curly braces.
pub struct Expr(pub Fragment);
impl ToTokens for Expr {
fn to_tokens(&self, out: &mut Tokens) {
match self.0 {
Fragment::Expr(ref expr) => expr.to_tokens(out),
Fragment::Block(ref block) => {
out.append("{");
block.to_tokens(out);
out.append("}");
}
}
}
}
/// Interpolate a fragment as the statements of a block.
pub struct Stmts(pub Fragment);
impl ToTokens for Stmts {
fn to_tokens(&self, out: &mut Tokens) {
match self.0 {
Fragment::Expr(ref expr) => expr.to_tokens(out),
Fragment::Block(ref block) => block.to_tokens(out),
}
}
}
/// Interpolate a fragment as the value part of a `match` expression. This
/// involves putting a comma after expressions and curly braces around blocks.
pub struct Match(pub Fragment);
impl ToTokens for Match {
fn to_tokens(&self, out: &mut Tokens) {
match self.0 {
Fragment::Expr(ref expr) => {
expr.to_tokens(out);
out.append(",");
}
Fragment::Block(ref block) => {
out.append("{");
block.to_tokens(out);
out.append("}");
}
}
}
}
serde_derive/src/lib.rs
+4 -1
View File
@@ -15,8 +15,11 @@ use proc_macro::TokenStream;
#[macro_use] #[macro_use]
mod bound; mod bound;
mod de; #[macro_use]
mod fragment;
mod ser; mod ser;
mod de;
#[proc_macro_derive(Serialize, attributes(serde))] #[proc_macro_derive(Serialize, attributes(serde))]
pub fn derive_serialize(input: TokenStream) -> TokenStream { pub fn derive_serialize(input: TokenStream) -> TokenStream {
serde_derive/src/ser.rs
+75 -95
View File
@@ -2,6 +2,7 @@ use syn::{self, Ident};
use quote::Tokens; use quote::Tokens;
use bound; use bound;
use fragment::{Fragment, Stmts, Match};
use internals::ast::{Body, Field, Item, Style, Variant}; use internals::ast::{Body, Field, Item, Style, Variant};
use internals::{self, attr}; use internals::{self, attr};
@@ -14,7 +15,7 @@ pub fn expand_derive_serialize(item: &syn::DeriveInput) -> Result<Tokens, String
let generics = build_generics(&item); let generics = build_generics(&item);
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
let dummy_const = Ident::new(format!("_IMPL_SERIALIZE_FOR_{}", ident)); let dummy_const = Ident::new(format!("_IMPL_SERIALIZE_FOR_{}", ident));
let body = serialize_body(&item, &generics); let body = Stmts(serialize_body(&item, &generics));
Ok(quote! { Ok(quote! {
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
@@ -59,7 +60,7 @@ fn needs_serialize_bound(attrs: &attr::Field) -> bool {
!attrs.skip_serializing() && attrs.serialize_with().is_none() && attrs.ser_bound().is_none() !attrs.skip_serializing() && attrs.serialize_with().is_none() && attrs.ser_bound().is_none()
} }
fn serialize_body(item: &Item, generics: &syn::Generics) -> Tokens { fn serialize_body(item: &Item, generics: &syn::Generics) -> Fragment {
match item.body { match item.body {
Body::Enum(ref variants) => { Body::Enum(ref variants) => {
serialize_item_enum(&item.ident, generics, variants, &item.attrs) serialize_item_enum(&item.ident, generics, variants, &item.attrs)
@@ -85,10 +86,10 @@ fn serialize_body(item: &Item, generics: &syn::Generics) -> Tokens {
} }
} }
fn serialize_unit_struct(item_attrs: &attr::Item) -> Tokens { fn serialize_unit_struct(item_attrs: &attr::Item) -> Fragment {
let type_name = item_attrs.name().serialize_name(); let type_name = item_attrs.name().serialize_name();
quote! { quote_expr! {
_serde::Serializer::serialize_unit_struct(_serializer, #type_name) _serde::Serializer::serialize_unit_struct(_serializer, #type_name)
} }
} }
@@ -97,7 +98,7 @@ fn serialize_newtype_struct(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
field: &Field, field: &Field,
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
let type_name = item_attrs.name().serialize_name(); let type_name = item_attrs.name().serialize_name();
let mut field_expr = quote!(&self.0); let mut field_expr = quote!(&self.0);
@@ -105,7 +106,7 @@ fn serialize_newtype_struct(ident: &syn::Ident,
field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr); field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr);
} }
quote! { quote_expr! {
_serde::Serializer::serialize_newtype_struct(_serializer, #type_name, #field_expr) _serde::Serializer::serialize_newtype_struct(_serializer, #type_name, #field_expr)
} }
} }
@@ -114,7 +115,7 @@ fn serialize_tuple_struct(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
let serialize_stmts = let serialize_stmts =
serialize_tuple_struct_visitor(ident, serialize_tuple_struct_visitor(ident,
fields, fields,
@@ -126,7 +127,7 @@ fn serialize_tuple_struct(ident: &syn::Ident,
let len = serialize_stmts.len(); let len = serialize_stmts.len();
let let_mut = mut_if(len > 0); let let_mut = mut_if(len > 0);
quote! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_struct(_serializer, #type_name, #len)); let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_struct(_serializer, #type_name, #len));
#(#serialize_stmts)* #(#serialize_stmts)*
_serde::ser::SerializeTupleStruct::end(__serde_state) _serde::ser::SerializeTupleStruct::end(__serde_state)
@@ -137,7 +138,7 @@ fn serialize_struct(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
let serialize_fields = let serialize_fields =
serialize_struct_visitor(ident, serialize_struct_visitor(ident,
fields, fields,
@@ -164,7 +165,7 @@ fn serialize_struct(ident: &syn::Ident,
}) })
.fold(quote!(0), |sum, expr| quote!(#sum + #expr)); .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
quote! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(_serializer, #type_name, #len)); let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(_serializer, #type_name, #len));
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeStruct::end(__serde_state) _serde::ser::SerializeStruct::end(__serde_state)
@@ -175,7 +176,7 @@ fn serialize_item_enum(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
variants: &[Variant], variants: &[Variant],
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
let arms: Vec<_> = variants.iter() let arms: Vec<_> = variants.iter()
.enumerate() .enumerate()
.map(|(variant_index, variant)| { .map(|(variant_index, variant)| {
@@ -187,7 +188,7 @@ fn serialize_item_enum(ident: &syn::Ident,
}) })
.collect(); .collect();
quote! { quote_expr! {
match *self { match *self {
#(#arms)* #(#arms)*
} }
@@ -246,7 +247,7 @@ fn serialize_variant(ident: &syn::Ident,
} }
}; };
let body = match *item_attrs.tag() { let body = Match(match *item_attrs.tag() {
attr::EnumTag::External => { attr::EnumTag::External => {
serialize_externally_tagged_variant(ident, serialize_externally_tagged_variant(ident,
generics, generics,
@@ -270,7 +271,7 @@ fn serialize_variant(ident: &syn::Ident,
content) content)
} }
attr::EnumTag::None => serialize_untagged_variant(ident, generics, variant, item_attrs), attr::EnumTag::None => serialize_untagged_variant(ident, generics, variant, item_attrs),
}; });
quote! { quote! {
#case => #body #case => #body
@@ -283,19 +284,19 @@ fn serialize_externally_tagged_variant(ident: &syn::Ident,
variant: &Variant, variant: &Variant,
variant_index: usize, variant_index: usize,
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
let type_name = item_attrs.name().serialize_name(); let type_name = item_attrs.name().serialize_name();
let variant_name = variant.attrs.name().serialize_name(); let variant_name = variant.attrs.name().serialize_name();
match variant.style { match variant.style {
Style::Unit => { Style::Unit => {
quote! { quote_expr! {
_serde::Serializer::serialize_unit_variant( _serde::Serializer::serialize_unit_variant(
_serializer, _serializer,
#type_name, #type_name,
#variant_index, #variant_index,
#variant_name, #variant_name,
), )
} }
} }
Style::Newtype => { Style::Newtype => {
@@ -305,43 +306,35 @@ fn serialize_externally_tagged_variant(ident: &syn::Ident,
field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr); field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr);
} }
quote! { quote_expr! {
_serde::Serializer::serialize_newtype_variant( _serde::Serializer::serialize_newtype_variant(
_serializer, _serializer,
#type_name, #type_name,
#variant_index, #variant_index,
#variant_name, #variant_name,
#field_expr, #field_expr,
), )
} }
} }
Style::Tuple => { Style::Tuple => {
let block = serialize_tuple_variant(TupleVariant::ExternallyTagged { serialize_tuple_variant(TupleVariant::ExternallyTagged {
type_name: type_name, type_name: type_name,
variant_index: variant_index, variant_index: variant_index,
variant_name: variant_name, variant_name: variant_name,
}, },
ident, ident,
generics, generics,
&variant.fields); &variant.fields)
quote! {
{ #block }
}
} }
Style::Struct => { Style::Struct => {
let block = serialize_struct_variant(StructVariant::ExternallyTagged { serialize_struct_variant(StructVariant::ExternallyTagged {
variant_index: variant_index, variant_index: variant_index,
variant_name: variant_name, variant_name: variant_name,
}, },
ident, ident,
generics, generics,
&variant.fields, &variant.fields,
&type_name); &type_name)
quote! {
{ #block }
}
} }
} }
} }
@@ -351,7 +344,7 @@ fn serialize_internally_tagged_variant(ident: &syn::Ident,
variant: &Variant, variant: &Variant,
item_attrs: &attr::Item, item_attrs: &attr::Item,
tag: &str) tag: &str)
-> Tokens { -> Fragment {
let type_name = item_attrs.name().serialize_name(); let type_name = item_attrs.name().serialize_name();
let variant_name = variant.attrs.name().serialize_name(); let variant_name = variant.attrs.name().serialize_name();
@@ -360,13 +353,13 @@ fn serialize_internally_tagged_variant(ident: &syn::Ident,
match variant.style { match variant.style {
Style::Unit => { Style::Unit => {
quote!({ quote_block! {
let mut __struct = try!(_serde::Serializer::serialize_struct( let mut __struct = try!(_serde::Serializer::serialize_struct(
_serializer, #type_name, 1)); _serializer, #type_name, 1));
try!(_serde::ser::SerializeStruct::serialize_field( try!(_serde::ser::SerializeStruct::serialize_field(
&mut __struct, #tag, #variant_name)); &mut __struct, #tag, #variant_name));
_serde::ser::SerializeStruct::end(__struct) _serde::ser::SerializeStruct::end(__struct)
}) }
} }
Style::Newtype => { Style::Newtype => {
let field = &variant.fields[0]; let field = &variant.fields[0];
@@ -375,7 +368,7 @@ fn serialize_internally_tagged_variant(ident: &syn::Ident,
field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr); field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr);
} }
quote! { quote_expr! {
_serde::ser::private::serialize_tagged_newtype( _serde::ser::private::serialize_tagged_newtype(
_serializer, _serializer,
#enum_ident_str, #enum_ident_str,
@@ -383,22 +376,18 @@ fn serialize_internally_tagged_variant(ident: &syn::Ident,
#tag, #tag,
#variant_name, #variant_name,
#field_expr, #field_expr,
), )
} }
} }
Style::Struct => { Style::Struct => {
let block = serialize_struct_variant(StructVariant::InternallyTagged { serialize_struct_variant(StructVariant::InternallyTagged {
tag: tag, tag: tag,
variant_name: variant_name, variant_name: variant_name,
}, },
ident, ident,
generics, generics,
&variant.fields, &variant.fields,
&type_name); &type_name)
quote! {
{ #block }
}
} }
Style::Tuple => unreachable!("checked in serde_codegen_internals"), Style::Tuple => unreachable!("checked in serde_codegen_internals"),
} }
@@ -410,19 +399,19 @@ fn serialize_adjacently_tagged_variant(ident: &syn::Ident,
item_attrs: &attr::Item, item_attrs: &attr::Item,
tag: &str, tag: &str,
content: &str) content: &str)
-> Tokens { -> Fragment {
let type_name = item_attrs.name().serialize_name(); let type_name = item_attrs.name().serialize_name();
let variant_name = variant.attrs.name().serialize_name(); let variant_name = variant.attrs.name().serialize_name();
let inner = match variant.style { let inner = Stmts(match variant.style {
Style::Unit => { Style::Unit => {
return quote!({ return quote_block! {
let mut __struct = try!(_serde::Serializer::serialize_struct( let mut __struct = try!(_serde::Serializer::serialize_struct(
_serializer, #type_name, 1)); _serializer, #type_name, 1));
try!(_serde::ser::SerializeStruct::serialize_field( try!(_serde::ser::SerializeStruct::serialize_field(
&mut __struct, #tag, #variant_name)); &mut __struct, #tag, #variant_name));
_serde::ser::SerializeStruct::end(__struct) _serde::ser::SerializeStruct::end(__struct)
}); };
} }
Style::Newtype => { Style::Newtype => {
let field = &variant.fields[0]; let field = &variant.fields[0];
@@ -431,7 +420,7 @@ fn serialize_adjacently_tagged_variant(ident: &syn::Ident,
field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr); field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr);
} }
quote! { quote_expr! {
_serde::Serialize::serialize(#field_expr, _serializer) _serde::Serialize::serialize(#field_expr, _serializer)
} }
} }
@@ -448,7 +437,7 @@ fn serialize_adjacently_tagged_variant(ident: &syn::Ident,
&variant.fields, &variant.fields,
&variant_name) &variant_name)
} }
}; });
let fields_ty = variant.fields.iter().map(|f| &f.ty); let fields_ty = variant.fields.iter().map(|f| &f.ty);
let ref fields_ident: Vec<_> = match variant.style { let ref fields_ident: Vec<_> = match variant.style {
@@ -472,7 +461,7 @@ fn serialize_adjacently_tagged_variant(ident: &syn::Ident,
let wrapper_generics = bound::with_lifetime_bound(generics, "'__a"); let wrapper_generics = bound::with_lifetime_bound(generics, "'__a");
let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl(); let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl();
quote!({ quote_block! {
struct __AdjacentlyTagged #wrapper_generics #where_clause { struct __AdjacentlyTagged #wrapper_generics #where_clause {
data: (#(&'__a #fields_ty,)*), data: (#(&'__a #fields_ty,)*),
phantom: _serde::export::PhantomData<#ident #ty_generics>, phantom: _serde::export::PhantomData<#ident #ty_generics>,
@@ -497,18 +486,18 @@ fn serialize_adjacently_tagged_variant(ident: &syn::Ident,
phantom: _serde::export::PhantomData::<#ident #ty_generics>, phantom: _serde::export::PhantomData::<#ident #ty_generics>,
})); }));
_serde::ser::SerializeStruct::end(__struct) _serde::ser::SerializeStruct::end(__struct)
}) }
} }
fn serialize_untagged_variant(ident: &syn::Ident, fn serialize_untagged_variant(ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
variant: &Variant, variant: &Variant,
item_attrs: &attr::Item) item_attrs: &attr::Item)
-> Tokens { -> Fragment {
match variant.style { match variant.style {
Style::Unit => { Style::Unit => {
quote! { quote_expr! {
_serde::Serializer::serialize_unit(_serializer), _serde::Serializer::serialize_unit(_serializer)
} }
} }
Style::Newtype => { Style::Newtype => {
@@ -518,29 +507,20 @@ fn serialize_untagged_variant(ident: &syn::Ident,
field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr); field_expr = wrap_serialize_with(ident, generics, field.ty, path, field_expr);
} }
quote! { quote_expr! {
_serde::Serialize::serialize(#field_expr, _serializer), _serde::Serialize::serialize(#field_expr, _serializer)
} }
} }
Style::Tuple => { Style::Tuple => {
let block = serialize_tuple_variant(TupleVariant::Untagged, ident, generics, &variant.fields)
serialize_tuple_variant(TupleVariant::Untagged, ident, generics, &variant.fields);
quote! {
{ #block }
}
} }
Style::Struct => { Style::Struct => {
let type_name = item_attrs.name().serialize_name(); let type_name = item_attrs.name().serialize_name();
let block = serialize_struct_variant(StructVariant::Untagged, serialize_struct_variant(StructVariant::Untagged,
ident, ident,
generics, generics,
&variant.fields, &variant.fields,
&type_name); &type_name)
quote! {
{ #block }
}
} }
} }
} }
@@ -558,7 +538,7 @@ fn serialize_tuple_variant(context: TupleVariant,
ident: &syn::Ident, ident: &syn::Ident,
generics: &syn::Generics, generics: &syn::Generics,
fields: &[Field]) fields: &[Field])
-> Tokens { -> Fragment {
let method = match context { let method = match context {
TupleVariant::ExternallyTagged { .. } => { TupleVariant::ExternallyTagged { .. } => {
quote!(_serde::ser::SerializeTupleVariant::serialize_field) quote!(_serde::ser::SerializeTupleVariant::serialize_field)
@@ -574,7 +554,7 @@ fn serialize_tuple_variant(context: TupleVariant,
match context { match context {
TupleVariant::ExternallyTagged { type_name, variant_index, variant_name } => { TupleVariant::ExternallyTagged { type_name, variant_index, variant_name } => {
quote! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant( let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant(
_serializer, _serializer,
#type_name, #type_name,
@@ -586,7 +566,7 @@ fn serialize_tuple_variant(context: TupleVariant,
} }
} }
TupleVariant::Untagged => { TupleVariant::Untagged => {
quote! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple( let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple(
_serializer, _serializer,
#len)); #len));
@@ -611,7 +591,7 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
generics: &syn::Generics, generics: &syn::Generics,
fields: &[Field], fields: &[Field],
name: &str) name: &str)
-> Tokens { -> Fragment {
let method = match context { let method = match context {
StructVariant::ExternallyTagged { .. } => { StructVariant::ExternallyTagged { .. } => {
quote!(_serde::ser::SerializeStructVariant::serialize_field) quote!(_serde::ser::SerializeStructVariant::serialize_field)
@@ -640,7 +620,7 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
match context { match context {
StructVariant::ExternallyTagged { variant_index, variant_name } => { StructVariant::ExternallyTagged { variant_index, variant_name } => {
quote! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant( let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant(
_serializer, _serializer,
#name, #name,
@@ -653,7 +633,7 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
} }
} }
StructVariant::InternallyTagged { tag, variant_name } => { StructVariant::InternallyTagged { tag, variant_name } => {
quote! { quote_block! {
let mut __serde_state = try!(_serde::Serializer::serialize_struct( let mut __serde_state = try!(_serde::Serializer::serialize_struct(
_serializer, _serializer,
#name, #name,
@@ -669,7 +649,7 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
} }
} }
StructVariant::Untagged => { StructVariant::Untagged => {
quote! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct( let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(
_serializer, _serializer,
#name, #name,