pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-25 01:07:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format in rfc style

Browse Source
This commit is contained in:
David Tolnay
2017-04-13 12:28:23 -07:00
parent c5bd760133
commit ea8fb97beb
25 changed files with 2822 additions and 2131 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_derive/src/bound.rs
+112 -76
View File
@@ -16,27 +16,41 @@ macro_rules! path {
// allowed here".
pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
syn::Generics {
ty_params: generics.ty_params
ty_params: generics
.ty_params
.iter()
.map(|ty_param| syn::TyParam { default: None, ..ty_param.clone() })
.map(
|ty_param| {
syn::TyParam {
default: None,
..ty_param.clone()
}
},
)
.collect(),
..generics.clone()
}
}
pub fn with_where_predicates(generics: &syn::Generics,
predicates: &[syn::WherePredicate])
-> syn::Generics {
pub fn with_where_predicates(
generics: &syn::Generics,
predicates: &[syn::WherePredicate],
) -> syn::Generics {
let mut generics = generics.clone();
generics.where_clause.predicates.extend_from_slice(predicates);
generics
.where_clause
.predicates
.extend_from_slice(predicates);
generics
}
pub fn with_where_predicates_from_fields<F>(item: &Item,
generics: &syn::Generics,
from_field: F)
-> syn::Generics
where F: Fn(&attr::Field) -> Option<&[syn::WherePredicate]>
pub fn with_where_predicates_from_fields<F>(
item: &Item,
generics: &syn::Generics,
from_field: F,
) -> syn::Generics
where
F: Fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
{
let predicates = item.body
.all_fields()
@@ -59,12 +73,14 @@ pub fn with_where_predicates_from_fields<F>(item: &Item,
// #[serde(skip_serializing)]
// c: C,
// }
pub fn with_bound<F>(item: &Item,
generics: &syn::Generics,
filter: F,
bound: &syn::Path)
-> syn::Generics
where F: Fn(&attr::Field) -> bool
pub fn with_bound<F>(
item: &Item,
generics: &syn::Generics,
filter: F,
bound: &syn::Path,
) -> syn::Generics
where
F: Fn(&attr::Field) -> bool,
{
struct FindTyParams {
// Set of all generic type parameters on the current struct (A, B, C in
@@ -94,7 +110,8 @@ pub fn with_bound<F>(item: &Item,
}
}
let all_ty_params: HashSet<_> = generics.ty_params
let all_ty_params: HashSet<_> = generics
.ty_params
.iter()
.map(|ty_param| ty_param.ident.clone())
.collect();
@@ -112,58 +129,66 @@ pub fn with_bound<F>(item: &Item,
visit::walk_ty(&mut visitor, ty);
}
let new_predicates = generics.ty_params
let new_predicates = generics
.ty_params
.iter()
.map(|ty_param| ty_param.ident.clone())
.filter(|id| visitor.relevant_ty_params.contains(id))
.map(|id| {
syn::WherePredicate::BoundPredicate(syn::WhereBoundPredicate {
bound_lifetimes: Vec::new(),
// the type parameter that is being bounded e.g. T
bounded_ty: syn::Ty::Path(None, id.into()),
// the bound e.g. Serialize
bounds: vec![syn::TyParamBound::Trait(
syn::PolyTraitRef {
.map(
|id| {
syn::WherePredicate::BoundPredicate(
syn::WhereBoundPredicate {
bound_lifetimes: Vec::new(),
trait_ref: bound.clone(),
// the type parameter that is being bounded e.g. T
bounded_ty: syn::Ty::Path(None, id.into()),
// the bound e.g. Serialize
bounds: vec![
syn::TyParamBound::Trait(
syn::PolyTraitRef {
bound_lifetimes: Vec::new(),
trait_ref: bound.clone(),
},
syn::TraitBoundModifier::None,
),
],
},
syn::TraitBoundModifier::None
)],
})
});
)
},
);
let mut generics = generics.clone();
generics.where_clause.predicates.extend(new_predicates);
generics
}
pub fn with_self_bound(item: &Item,
generics: &syn::Generics,
bound: &syn::Path)
-> syn::Generics
{
pub fn with_self_bound(item: &Item, generics: &syn::Generics, bound: &syn::Path) -> syn::Generics {
let mut generics = generics.clone();
generics.where_clause.predicates.push(
syn::WherePredicate::BoundPredicate(syn::WhereBoundPredicate {
bound_lifetimes: Vec::new(),
// the type that is being bounded e.g. MyStruct<'a, T>
bounded_ty: type_of_item(item),
// the bound e.g. Default
bounds: vec![syn::TyParamBound::Trait(
syn::PolyTraitRef {
generics
.where_clause
.predicates
.push(
syn::WherePredicate::BoundPredicate(
syn::WhereBoundPredicate {
bound_lifetimes: Vec::new(),
trait_ref: bound.clone(),
// the type that is being bounded e.g. MyStruct<'a, T>
bounded_ty: type_of_item(item),
// the bound e.g. Default
bounds: vec![
syn::TyParamBound::Trait(
syn::PolyTraitRef {
bound_lifetimes: Vec::new(),
trait_ref: bound.clone(),
},
syn::TraitBoundModifier::None,
),
],
},
syn::TraitBoundModifier::None
)],
})
);
),
);
generics
}
pub fn with_lifetime_bound(generics: &syn::Generics,
lifetime: &str)
-> syn::Generics {
pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics {
let mut generics = generics.clone();
for lifetime_def in &mut generics.lifetimes {
@@ -171,38 +196,49 @@ pub fn with_lifetime_bound(generics: &syn::Generics,
}
for ty_param in &mut generics.ty_params {
ty_param.bounds.push(syn::TyParamBound::Region(syn::Lifetime::new(lifetime)));
ty_param
.bounds
.push(syn::TyParamBound::Region(syn::Lifetime::new(lifetime)));
}
generics.lifetimes.push(syn::LifetimeDef {
attrs: Vec::new(),
lifetime: syn::Lifetime::new(lifetime),
bounds: Vec::new(),
});
generics
.lifetimes
.push(
syn::LifetimeDef {
attrs: Vec::new(),
lifetime: syn::Lifetime::new(lifetime),
bounds: Vec::new(),
},
);
generics
}
fn type_of_item(item: &Item) -> syn::Ty {
syn::Ty::Path(None, syn::Path {
global: false,
segments: vec![
syn::PathSegment {
ident: item.ident.clone(),
parameters: syn::PathParameters::AngleBracketed(syn::AngleBracketedParameterData {
lifetimes: item.generics
.lifetimes
.iter()
.map(|def| def.lifetime.clone())
.collect(),
types: item.generics
syn::Ty::Path(
None,
syn::Path {
global: false,
segments: vec![
syn::PathSegment {
ident: item.ident.clone(),
parameters: syn::PathParameters::AngleBracketed(
syn::AngleBracketedParameterData {
lifetimes: item.generics
.lifetimes
.iter()
.map(|def| def.lifetime.clone())
.collect(),
types: item.generics
.ty_params
.iter()
.map(|param| syn::Ty::Path(None, param.ident.clone().into()))
.collect(),
bindings: Vec::new(),
}),
}
]
})
bindings: Vec::new(),
},
),
},
],
},
)
}
serde_derive/src/de.rs
+315 -259
View File
@@ -44,13 +44,15 @@ pub fn expand_derive_deserialize(item: &syn::DeriveInput) -> Result<Tokens, Stri
}
};
Ok(quote! {
Ok(
quote! {
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const #dummy_const: () = {
extern crate serde as _serde;
#impl_item
};
})
},
)
}
struct Parameters {
@@ -115,8 +117,7 @@ impl Parameters {
fn build_generics(item: &Item) -> syn::Generics {
let generics = bound::without_defaults(item.generics);
let generics =
bound::with_where_predicates_from_fields(item, &generics, attr::Field::de_bound);
let generics = bound::with_where_predicates_from_fields(item, &generics, attr::Field::de_bound);
match item.attrs.de_bound() {
Some(predicates) => bound::with_where_predicates(&generics, predicates),
@@ -125,19 +126,23 @@ fn build_generics(item: &Item) -> syn::Generics {
attr::Default::Default => {
bound::with_self_bound(item, &generics, &path!(_serde::export::Default))
}
attr::Default::None | attr::Default::Path(_) => generics,
attr::Default::None |
attr::Default::Path(_) => generics,
};
let generics =
bound::with_bound(item,
&generics,
needs_deserialize_bound,
&path!(_serde::Deserialize<'de>));
let generics = bound::with_bound(
item,
&generics,
needs_deserialize_bound,
&path!(_serde::Deserialize<'de>),
);
bound::with_bound(item,
&generics,
requires_default,
&path!(_serde::export::Default))
bound::with_bound(
item,
&generics,
requires_default,
&path!(_serde::export::Default),
)
}
}
}
@@ -175,29 +180,19 @@ fn deserialize_body(item: &Item, params: &Parameters) -> Fragment {
deserialize_from(from_type)
} else {
match item.body {
Body::Enum(ref variants) => {
deserialize_item_enum(params, variants, &item.attrs)
}
Body::Enum(ref variants) => deserialize_item_enum(params, variants, &item.attrs),
Body::Struct(Style::Struct, ref fields) => {
if fields.iter().any(|field| field.ident.is_none()) {
panic!("struct has unnamed fields");
}
deserialize_struct(None,
params,
fields,
&item.attrs,
None)
deserialize_struct(None, params, fields, &item.attrs, None)
}
Body::Struct(Style::Tuple, ref fields) |
Body::Struct(Style::Newtype, ref fields) => {
if fields.iter().any(|field| field.ident.is_some()) {
panic!("tuple struct has named fields");
}
deserialize_tuple(None,
params,
fields,
&item.attrs,
None)
deserialize_tuple(None, params, fields, &item.attrs, None)
}
Body::Struct(Style::Unit, _) => deserialize_unit_struct(params, &item.attrs),
}
@@ -240,14 +235,15 @@ fn deserialize_unit_struct(params: &Parameters, item_attrs: &attr::Item) -> Frag
}
}
fn deserialize_tuple(variant_ident: Option<&syn::Ident>,
params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item,
deserializer: Option<Tokens>)
-> Fragment {
fn deserialize_tuple(
variant_ident: Option<&syn::Ident>,
params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item,
deserializer: Option<Tokens>,
) -> Fragment {
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
// If there are getters (implying private fields), construct the local type
// and use an `Into` conversion to get the remote type. If there are no
@@ -277,7 +273,7 @@ fn deserialize_tuple(variant_ident: Option<&syn::Ident>,
None
};
let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, false, item_attrs));
let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, false, item_attrs),);
let visitor_expr = quote! {
__Visitor {
@@ -297,7 +293,9 @@ fn deserialize_tuple(variant_ident: Option<&syn::Ident>,
quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
};
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
let all_skipped = fields
.iter()
.all(|field| field.attrs.skip_deserializing());
let visitor_var = if all_skipped {
quote!(_)
} else {
@@ -331,15 +329,17 @@ fn deserialize_tuple(variant_ident: Option<&syn::Ident>,
}
}
fn deserialize_seq(type_path: &Tokens,
params: &Parameters,
fields: &[Field],
is_struct: bool,
item_attrs: &attr::Item)
-> Fragment {
fn deserialize_seq(
type_path: &Tokens,
params: &Parameters,
fields: &[Field],
is_struct: bool,
item_attrs: &attr::Item,
) -> Fragment {
let vars = (0..fields.len()).map(field_i as fn(_) -> _);
let deserialized_count = fields.iter()
let deserialized_count = fields
.iter()
.filter(|field| !field.attrs.skip_deserializing())
.count();
let expecting = format!("tuple of {} elements", deserialized_count);
@@ -406,10 +406,7 @@ fn deserialize_seq(type_path: &Tokens,
}
}
fn deserialize_newtype_struct(type_path: &Tokens,
params: &Parameters,
field: &Field)
-> Tokens {
fn deserialize_newtype_struct(type_path: &Tokens, params: &Parameters, field: &Field) -> Tokens {
let value = match field.attrs.deserialize_with() {
None => {
let field_ty = &field.ty;
@@ -418,8 +415,7 @@ fn deserialize_newtype_struct(type_path: &Tokens,
}
}
Some(path) => {
let (wrapper, wrapper_ty) =
wrap_deserialize_with(params, field.ty, path);
let (wrapper, wrapper_ty) = wrap_deserialize_with(params, field.ty, path);
quote!({
#wrapper
try!(<#wrapper_ty as _serde::Deserialize>::deserialize(__e)).value
@@ -445,17 +441,18 @@ fn deserialize_newtype_struct(type_path: &Tokens,
}
}
fn deserialize_struct(variant_ident: Option<&syn::Ident>,
params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item,
deserializer: Option<Tokens>)
-> Fragment {
fn deserialize_struct(
variant_ident: Option<&syn::Ident>,
params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item,
deserializer: Option<Tokens>,
) -> Fragment {
let is_enum = variant_ident.is_some();
let is_untagged = deserializer.is_some();
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
// If there are getters (implying private fields), construct the local type
// and use an `Into` conversion to get the remote type. If there are no
@@ -476,7 +473,7 @@ fn deserialize_struct(variant_ident: Option<&syn::Ident>,
None => format!("struct {}", params.type_name()),
};
let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, true, item_attrs));
let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, true, item_attrs),);
let (field_visitor, fields_stmt, visit_map) =
deserialize_struct_visitor(type_path, params, fields, item_attrs);
@@ -505,7 +502,9 @@ fn deserialize_struct(variant_ident: Option<&syn::Ident>,
}
};
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
let all_skipped = fields
.iter()
.all(|field| field.attrs.skip_deserializing());
let visitor_var = if all_skipped {
quote!(_)
} else {
@@ -557,48 +556,41 @@ fn deserialize_struct(variant_ident: Option<&syn::Ident>,
}
}
fn deserialize_item_enum(params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item)
-> Fragment {
fn deserialize_item_enum(
params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item,
) -> Fragment {
match *item_attrs.tag() {
attr::EnumTag::External => {
deserialize_externally_tagged_enum(params, variants, item_attrs)
}
attr::EnumTag::External => deserialize_externally_tagged_enum(params, variants, item_attrs),
attr::EnumTag::Internal { ref tag } => {
deserialize_internally_tagged_enum(params,
variants,
item_attrs,
tag)
}
attr::EnumTag::Adjacent { ref tag, ref content } => {
deserialize_adjacently_tagged_enum(params,
variants,
item_attrs,
tag,
content)
}
attr::EnumTag::None => {
deserialize_untagged_enum(params, variants, item_attrs)
deserialize_internally_tagged_enum(params, variants, item_attrs, tag)
}
attr::EnumTag::Adjacent {
ref tag,
ref content,
} => deserialize_adjacently_tagged_enum(params, variants, item_attrs, tag, content),
attr::EnumTag::None => deserialize_untagged_enum(params, variants, item_attrs),
}
}
fn deserialize_externally_tagged_enum(params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item)
-> Fragment {
fn deserialize_externally_tagged_enum(
params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item,
) -> Fragment {
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let type_name = item_attrs.name().deserialize_name();
let expecting = format!("enum {}", params.type_name());
let variant_names_idents: Vec<_> = variants.iter()
let variant_names_idents: Vec<_> = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)),)
.collect();
let variants_stmt = {
@@ -608,25 +600,30 @@ fn deserialize_externally_tagged_enum(params: &Parameters,
}
};
let variant_visitor = Stmts(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
let variant_arms = variants.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(|(i, variant)| {
let variant_name = field_i(i);
let variant_arms =
variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(
|(i, variant)| {
let variant_name = field_i(i);
let block = Match(deserialize_externally_tagged_variant(params,
variant,
item_attrs));
let block =
Match(deserialize_externally_tagged_variant(params, variant, item_attrs),);
quote! {
quote! {
(__Field::#variant_name, __visitor) => #block
}
});
},
);
let all_skipped = variants.iter().all(|variant| variant.attrs.skip_deserializing());
let all_skipped = variants
.iter()
.all(|variant| variant.attrs.skip_deserializing());
let match_variant = if all_skipped {
// This is an empty enum like `enum Impossible {}` or an enum in which
// all variants have `#[serde(skip_deserializing)]`.
@@ -678,15 +675,17 @@ fn deserialize_externally_tagged_enum(params: &Parameters,
}
}
fn deserialize_internally_tagged_enum(params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item,
tag: &str)
-> Fragment {
let variant_names_idents: Vec<_> = variants.iter()
fn deserialize_internally_tagged_enum(
params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item,
tag: &str,
) -> Fragment {
let variant_names_idents: Vec<_> = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)),)
.collect();
let variants_stmt = {
@@ -696,7 +695,7 @@ fn deserialize_internally_tagged_enum(params: &Parameters,
}
};
let variant_visitor = Stmts(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
let variant_arms = variants.iter()
@@ -732,19 +731,21 @@ fn deserialize_internally_tagged_enum(params: &Parameters,
}
}
fn deserialize_adjacently_tagged_enum(params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item,
tag: &str,
content: &str)
-> Fragment {
fn deserialize_adjacently_tagged_enum(
params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item,
tag: &str,
content: &str,
) -> Fragment {
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let variant_names_idents: Vec<_> = variants.iter()
let variant_names_idents: Vec<_> = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)),)
.collect();
let variants_stmt = {
@@ -754,25 +755,30 @@ fn deserialize_adjacently_tagged_enum(params: &Parameters,
}
};
let variant_visitor = Stmts(deserialize_field_visitor(variant_names_idents, item_attrs, true));
let variant_visitor = Stmts(deserialize_field_visitor(variant_names_idents, item_attrs, true),);
let ref variant_arms: Vec<_> = variants.iter()
let ref variant_arms: Vec<_> = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(|(i, variant)| {
let variant_index = field_i(i);
.map(
|(i, variant)| {
let variant_index = field_i(i);
let block = Match(deserialize_untagged_variant(
params,
variant,
item_attrs,
quote!(__deserializer),
));
let block = Match(
deserialize_untagged_variant(
params,
variant,
item_attrs,
quote!(__deserializer),
),
);
quote! {
quote! {
__Field::#variant_index => #block
}
})
},
)
.collect();
let expecting = format!("adjacently tagged enum {}", params.type_name());
@@ -799,20 +805,25 @@ fn deserialize_adjacently_tagged_enum(params: &Parameters,
let fallthrough = if variants.iter().all(is_unit) {
None
} else {
Some(quote! {
_ => #missing_content
})
};
let arms = variants.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing() && is_unit(variant))
.map(|(i, variant)| {
let variant_index = field_i(i);
let variant_ident = &variant.ident;
Some(
quote! {
_ => #missing_content
},
)
};
let arms = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing() && is_unit(variant),)
.map(
|(i, variant)| {
let variant_index = field_i(i);
let variant_ident = &variant.ident;
quote! {
__Field::#variant_index => _serde::export::Ok(#this::#variant_ident),
}
});
},
);
missing_content = quote! {
match __field {
#(#arms)*
@@ -970,20 +981,24 @@ fn deserialize_adjacently_tagged_enum(params: &Parameters,
}
}
fn deserialize_untagged_enum(params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item)
-> Fragment {
let attempts = variants.iter()
fn deserialize_untagged_enum(
params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item,
) -> Fragment {
let attempts = variants
.iter()
.filter(|variant| !variant.attrs.skip_deserializing())
.map(|variant| {
Expr(deserialize_untagged_variant(
.map(
|variant| {
Expr(deserialize_untagged_variant(
params,
variant,
item_attrs,
quote!(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)),
))
});
},
);
// TODO this message could be better by saving the errors from the failed
// attempts. The heuristic used by TOML was to count the number of fields
@@ -991,7 +1006,8 @@ fn deserialize_untagged_enum(params: &Parameters,
// largest number of fields. I'm not sure I like that. Maybe it would be
// better to save all the errors and combine them into one message that
// explains why none of the variants matched.
let fallthrough_msg = format!("data did not match any variant of untagged enum {}", params.type_name());
let fallthrough_msg =
format!("data did not match any variant of untagged enum {}", params.type_name());
quote_block! {
let __content = try!(<_serde::private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
@@ -1006,10 +1022,11 @@ fn deserialize_untagged_enum(params: &Parameters,
}
}
fn deserialize_externally_tagged_variant(params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item)
-> Fragment {
fn deserialize_externally_tagged_variant(
params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
) -> Fragment {
let variant_ident = &variant.ident;
match variant.style {
@@ -1021,32 +1038,35 @@ fn deserialize_externally_tagged_variant(params: &Parameters,
}
}
Style::Newtype => {
deserialize_externally_tagged_newtype_variant(variant_ident,
params,
&variant.fields[0])
deserialize_externally_tagged_newtype_variant(variant_ident, params, &variant.fields[0])
}
Style::Tuple => {
deserialize_tuple(Some(variant_ident),
params,
&variant.fields,
item_attrs,
None)
deserialize_tuple(
Some(variant_ident),
params,
&variant.fields,
item_attrs,
None,
)
}
Style::Struct => {
deserialize_struct(Some(variant_ident),
params,
&variant.fields,
item_attrs,
None)
deserialize_struct(
Some(variant_ident),
params,
&variant.fields,
item_attrs,
None,
)
}
}
}
fn deserialize_internally_tagged_variant(params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
deserializer: Tokens)
-> Fragment {
fn deserialize_internally_tagged_variant(
params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
deserializer: Tokens,
) -> Fragment {
let variant_ident = &variant.ident;
match variant.style {
@@ -1060,20 +1080,18 @@ fn deserialize_internally_tagged_variant(params: &Parameters,
}
}
Style::Newtype | Style::Struct => {
deserialize_untagged_variant(params,
variant,
item_attrs,
deserializer)
deserialize_untagged_variant(params, variant, item_attrs, deserializer)
}
Style::Tuple => unreachable!("checked in serde_codegen_internals"),
}
}
fn deserialize_untagged_variant(params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
deserializer: Tokens)
-> Fragment {
fn deserialize_untagged_variant(
params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
deserializer: Tokens,
) -> Fragment {
let variant_ident = &variant.ident;
match variant.style {
@@ -1091,32 +1109,39 @@ fn deserialize_untagged_variant(params: &Parameters,
}
}
Style::Newtype => {
deserialize_untagged_newtype_variant(variant_ident,
params,
&variant.fields[0],
deserializer)
deserialize_untagged_newtype_variant(
variant_ident,
params,
&variant.fields[0],
deserializer,
)
}
Style::Tuple => {
deserialize_tuple(Some(variant_ident),
params,
&variant.fields,
item_attrs,
Some(deserializer))
deserialize_tuple(
Some(variant_ident),
params,
&variant.fields,
item_attrs,
Some(deserializer),
)
}
Style::Struct => {
deserialize_struct(Some(variant_ident),
params,
&variant.fields,
item_attrs,
Some(deserializer))
deserialize_struct(
Some(variant_ident),
params,
&variant.fields,
item_attrs,
Some(deserializer),
)
}
}
}
fn deserialize_externally_tagged_newtype_variant(variant_ident: &syn::Ident,
params: &Parameters,
field: &Field)
-> Fragment {
fn deserialize_externally_tagged_newtype_variant(
variant_ident: &syn::Ident,
params: &Parameters,
field: &Field,
) -> Fragment {
let this = &params.this;
match field.attrs.deserialize_with() {
None => {
@@ -1128,8 +1153,7 @@ fn deserialize_externally_tagged_newtype_variant(variant_ident: &syn::Ident,
}
}
Some(path) => {
let (wrapper, wrapper_ty) =
wrap_deserialize_with(params, field.ty, path);
let (wrapper, wrapper_ty) = wrap_deserialize_with(params, field.ty, path);
quote_block! {
#wrapper
_serde::export::Result::map(
@@ -1140,11 +1164,12 @@ fn deserialize_externally_tagged_newtype_variant(variant_ident: &syn::Ident,
}
}
fn deserialize_untagged_newtype_variant(variant_ident: &syn::Ident,
params: &Parameters,
field: &Field,
deserializer: Tokens)
-> Fragment {
fn deserialize_untagged_newtype_variant(
variant_ident: &syn::Ident,
params: &Parameters,
field: &Field,
deserializer: Tokens,
) -> Fragment {
let this = &params.this;
match field.attrs.deserialize_with() {
None => {
@@ -1156,8 +1181,7 @@ fn deserialize_untagged_newtype_variant(variant_ident: &syn::Ident,
}
}
Some(path) => {
let (wrapper, wrapper_ty) =
wrap_deserialize_with(params, field.ty, path);
let (wrapper, wrapper_ty) = wrap_deserialize_with(params, field.ty, path);
quote_block! {
#wrapper
_serde::export::Result::map(
@@ -1168,10 +1192,11 @@ fn deserialize_untagged_newtype_variant(variant_ident: &syn::Ident,
}
}
fn deserialize_field_visitor(fields: Vec<(String, Ident)>,
item_attrs: &attr::Item,
is_variant: bool)
-> Fragment {
fn deserialize_field_visitor(
fields: Vec<(String, Ident)>,
item_attrs: &attr::Item,
is_variant: bool,
) -> Fragment {
let field_strs = fields.iter().map(|&(ref name, _)| name);
let field_bytes = fields.iter().map(|&(ref name, _)| quote::ByteStr(name));
let field_idents: &Vec<_> = &fields.iter().map(|&(_, ref ident)| ident).collect();
@@ -1185,7 +1210,8 @@ fn deserialize_field_visitor(fields: Vec<(String, Ident)>,
let visit_index = if is_variant {
let variant_indices = 0u32..;
let fallthrough_msg = format!("variant index 0 <= i < {}", fields.len());
Some(quote! {
Some(
quote! {
fn visit_u32<__E>(self, __value: u32) -> _serde::export::Result<__Field, __E>
where __E: _serde::de::Error
{
@@ -1198,7 +1224,8 @@ fn deserialize_field_visitor(fields: Vec<(String, Ident)>,
&#fallthrough_msg))
}
}
})
},
)
} else {
None
};
@@ -1218,9 +1245,11 @@ fn deserialize_field_visitor(fields: Vec<(String, Ident)>,
};
let bytes_to_str = if is_variant || item_attrs.deny_unknown_fields() {
Some(quote! {
Some(
quote! {
let __value = &_serde::export::from_utf8_lossy(__value);
})
},
)
} else {
None
};
@@ -1280,15 +1309,17 @@ fn deserialize_field_visitor(fields: Vec<(String, Ident)>,
}
}
fn deserialize_struct_visitor(struct_path: Tokens,
params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item)
-> (Fragment, Fragment, Fragment) {
let field_names_idents: Vec<_> = fields.iter()
fn deserialize_struct_visitor(
struct_path: Tokens,
params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item,
) -> (Fragment, Fragment, Fragment) {
let field_names_idents: Vec<_> = fields
.iter()
.enumerate()
.filter(|&(_, field)| !field.attrs.skip_deserializing())
.map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)))
.map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)),)
.collect();
let fields_stmt = {
@@ -1305,26 +1336,31 @@ fn deserialize_struct_visitor(struct_path: Tokens,
(field_visitor, fields_stmt, visit_map)
}
fn deserialize_map(struct_path: Tokens,
params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item)
-> Fragment {
fn deserialize_map(
struct_path: Tokens,
params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item,
) -> Fragment {
// Create the field names for the fields.
let fields_names: Vec<_> = fields.iter()
let fields_names: Vec<_> = fields
.iter()
.enumerate()
.map(|(i, field)| (field, field_i(i)))
.collect();
// Declare each field that will be deserialized.
let let_values = fields_names.iter()
let let_values = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| {
let field_ty = &field.ty;
quote! {
.map(
|&(field, ref name)| {
let field_ty = &field.ty;
quote! {
let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
}
});
},
);
// Match arms to extract a value for a field.
let value_arms = fields_names.iter()
@@ -1367,7 +1403,9 @@ fn deserialize_map(struct_path: Tokens,
})
};
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
let all_skipped = fields
.iter()
.all(|field| field.attrs.skip_deserializing());
let match_keys = if item_attrs.deny_unknown_fields() && all_skipped {
quote! {
// FIXME: Once we drop support for Rust 1.15:
@@ -1387,40 +1425,53 @@ fn deserialize_map(struct_path: Tokens,
}
};
let extract_values = fields_names.iter()
let extract_values = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| {
let missing_expr = Match(expr_is_missing(&field, item_attrs));
.map(
|&(field, ref name)| {
let missing_expr = Match(expr_is_missing(&field, item_attrs));
quote! {
quote! {
let #name = match #name {
_serde::export::Some(#name) => #name,
_serde::export::None => #missing_expr
};
}
});
},
);
let result = fields_names.iter()
.map(|&(field, ref name)| {
let ident = field.ident.clone().expect("struct contains unnamed fields");
if field.attrs.skip_deserializing() {
let value = Expr(expr_is_missing(&field, item_attrs));
quote!(#ident: #value)
} else {
quote!(#ident: #name)
}
});
let result = fields_names
.iter()
.map(
|&(field, ref name)| {
let ident = field
.ident
.clone()
.expect("struct contains unnamed fields");
if field.attrs.skip_deserializing() {
let value = Expr(expr_is_missing(&field, item_attrs));
quote!(#ident: #value)
} else {
quote!(#ident: #name)
}
},
);
let let_default = match *item_attrs.default() {
attr::Default::Default => {
Some(quote!(
Some(
quote!(
let __default: Self::Value = _serde::export::Default::default();
))
),
)
}
attr::Default::Path(ref path) => {
Some(quote!(
Some(
quote!(
let __default: Self::Value = #path();
))
),
)
}
attr::Default::None => {
// We don't need the default value, to prevent an unused variable warning
@@ -1456,12 +1507,13 @@ fn field_i(i: usize) -> Ident {
/// This function wraps the expression in `#[serde(deserialize_with = "...")]`
/// in a trait to prevent it from accessing the internal `Deserialize` state.
fn wrap_deserialize_with(params: &Parameters,
field_ty: &syn::Ty,
deserialize_with: &syn::Path)
-> (Tokens, Tokens) {
fn wrap_deserialize_with(
params: &Parameters,
field_ty: &syn::Ty,
deserialize_with: &syn::Path,
) -> (Tokens, Tokens) {
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let wrapper = quote! {
struct __DeserializeWith #de_impl_generics #where_clause {
@@ -1500,7 +1552,8 @@ fn expr_is_missing(field: &Field, item_attrs: &attr::Item) -> Fragment {
}
match *item_attrs.default() {
attr::Default::Default | attr::Default::Path(_) => {
attr::Default::Default |
attr::Default::Path(_) => {
let ident = &field.ident;
return quote_expr!(__default.#ident);
}
@@ -1538,13 +1591,16 @@ struct DeTyGenerics<'a>(&'a syn::Generics);
impl<'a> ToTokens for DeTyGenerics<'a> {
fn to_tokens(&self, tokens: &mut Tokens) {
let mut generics = self.0.clone();
generics.lifetimes.insert(0, syn::LifetimeDef::new("'de"));
generics
.lifetimes
.insert(0, syn::LifetimeDef::new("'de"));
let (_, ty_generics, _) = generics.split_for_impl();
ty_generics.to_tokens(tokens);
}
}
fn split_with_de_lifetime(params: &Parameters) -> (DeImplGenerics, DeTyGenerics, syn::TyGenerics, &syn::WhereClause) {
fn split_with_de_lifetime(params: &Parameters,)
-> (DeImplGenerics, DeTyGenerics, syn::TyGenerics, &syn::WhereClause) {
let de_impl_generics = DeImplGenerics(&params);
let de_ty_generics = DeTyGenerics(&params.generics);
let (_, ty_generics, where_clause) = params.generics.split_for_impl();
serde_derive/src/ser.rs
+287 -235
View File
@@ -42,13 +42,15 @@ pub fn expand_derive_serialize(item: &syn::DeriveInput) -> Result<Tokens, String
}
};
Ok(quote! {
Ok(
quote! {
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const #dummy_const: () = {
extern crate serde as _serde;
#impl_item
};
})
},
)
}
struct Parameters {
@@ -110,10 +112,12 @@ fn build_generics(item: &Item) -> syn::Generics {
match item.attrs.ser_bound() {
Some(predicates) => bound::with_where_predicates(&generics, predicates),
None => {
bound::with_bound(item,
&generics,
needs_serialize_bound,
&path!(_serde::Serialize))
bound::with_bound(
item,
&generics,
needs_serialize_bound,
&path!(_serde::Serialize),
)
}
}
}
@@ -131,9 +135,7 @@ fn serialize_body(item: &Item, params: &Parameters) -> Fragment {
serialize_into(params, into_type)
} else {
match item.body {
Body::Enum(ref variants) => {
serialize_item_enum(params, variants, &item.attrs)
}
Body::Enum(ref variants) => serialize_item_enum(params, variants, &item.attrs),
Body::Struct(Style::Struct, ref fields) => {
if fields.iter().any(|field| field.ident.is_none()) {
panic!("struct has unnamed fields");
@@ -171,10 +173,11 @@ fn serialize_unit_struct(item_attrs: &attr::Item) -> Fragment {
}
}
fn serialize_newtype_struct(params: &Parameters,
field: &Field,
item_attrs: &attr::Item)
-> Fragment {
fn serialize_newtype_struct(
params: &Parameters,
field: &Field,
item_attrs: &attr::Item,
) -> Fragment {
let type_name = item_attrs.name().serialize_name();
let mut field_expr = get_field(params, field, 0);
@@ -187,15 +190,17 @@ fn serialize_newtype_struct(params: &Parameters,
}
}
fn serialize_tuple_struct(params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item)
-> Fragment {
let serialize_stmts =
serialize_tuple_struct_visitor(fields,
params,
false,
quote!(_serde::ser::SerializeTupleStruct::serialize_field));
fn serialize_tuple_struct(
params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item,
) -> Fragment {
let serialize_stmts = serialize_tuple_struct_visitor(
fields,
params,
false,
quote!(_serde::ser::SerializeTupleStruct::serialize_field),
);
let type_name = item_attrs.name().serialize_name();
let len = serialize_stmts.len();
@@ -208,36 +213,36 @@ fn serialize_tuple_struct(params: &Parameters,
}
}
fn serialize_struct(params: &Parameters,
fields: &[Field],
item_attrs: &attr::Item)
-> Fragment {
fn serialize_struct(params: &Parameters, fields: &[Field], item_attrs: &attr::Item) -> Fragment {
assert!(fields.len() as u64 <= u32::MAX as u64);
let serialize_fields =
serialize_struct_visitor(fields,
params,
false,
quote!(_serde::ser::SerializeStruct::serialize_field));
let serialize_fields = serialize_struct_visitor(
fields,
params,
false,
quote!(_serde::ser::SerializeStruct::serialize_field),
);
let type_name = item_attrs.name().serialize_name();
let mut serialized_fields = fields.iter()
let mut serialized_fields = fields
.iter()
.filter(|&field| !field.attrs.skip_serializing())
.peekable();
let let_mut = mut_if(serialized_fields.peek().is_some());
let len = serialized_fields.map(|field| {
match field.attrs.skip_serializing_if() {
let len = serialized_fields
.map(
|field| match field.attrs.skip_serializing_if() {
None => quote!(1),
Some(path) => {
let ident = field.ident.clone().expect("struct has unnamed fields");
let field_expr = get_field(params, field, ident);
quote!(if #path(#field_expr) { 0 } else { 1 })
}
}
})
},
)
.fold(quote!(0), |sum, expr| quote!(#sum + #expr));
quote_block! {
@@ -247,22 +252,23 @@ fn serialize_struct(params: &Parameters,
}
}
fn serialize_item_enum(params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item)
-> Fragment {
fn serialize_item_enum(
params: &Parameters,
variants: &[Variant],
item_attrs: &attr::Item,
) -> Fragment {
assert!(variants.len() as u64 <= u32::MAX as u64);
let self_var = &params.self_var;
let arms: Vec<_> = variants.iter()
let arms: Vec<_> = variants
.iter()
.enumerate()
.map(|(variant_index, variant)| {
serialize_variant(params,
variant,
variant_index as u32,
item_attrs)
})
.map(
|(variant_index, variant)| {
serialize_variant(params, variant, variant_index as u32, item_attrs)
},
)
.collect();
quote_expr! {
@@ -272,24 +278,34 @@ fn serialize_item_enum(params: &Parameters,
}
}
fn serialize_variant(params: &Parameters,
variant: &Variant,
variant_index: u32,
item_attrs: &attr::Item)
-> Tokens {
fn serialize_variant(
params: &Parameters,
variant: &Variant,
variant_index: u32,
item_attrs: &attr::Item,
) -> Tokens {
let this = &params.this;
let variant_ident = variant.ident.clone();
if variant.attrs.skip_serializing() {
let skipped_msg = format!("the enum variant {}::{} cannot be serialized",
params.type_name(), variant_ident);
let skipped_msg = format!(
"the enum variant {}::{} cannot be serialized",
params.type_name(),
variant_ident
);
let skipped_err = quote! {
_serde::export::Err(_serde::ser::Error::custom(#skipped_msg))
};
let fields_pat = match variant.style {
Style::Unit => quote!(),
Style::Newtype | Style::Tuple => quote!( (..) ),
Style::Struct => quote!( {..} ),
Style::Newtype | Style::Tuple => quote!((..)),
Style::Struct => {
quote!(
{
..
}
)
}
};
quote! {
#this::#variant_ident #fields_pat => #skipped_err,
@@ -308,44 +324,44 @@ fn serialize_variant(params: &Parameters,
}
}
Style::Tuple => {
let field_names = (0..variant.fields.len())
.map(|i| Ident::new(format!("__field{}", i)));
let field_names =
(0..variant.fields.len()).map(|i| Ident::new(format!("__field{}", i)));
quote! {
#this::#variant_ident(#(ref #field_names),*)
}
}
Style::Struct => {
let fields = variant.fields
let fields = variant
.fields
.iter()
.map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
.map(
|f| {
f.ident
.clone()
.expect("struct variant has unnamed fields")
},
);
quote! {
#this::#variant_ident { #(ref #fields),* }
}
}
};
let body = Match(match *item_attrs.tag() {
attr::EnumTag::External => {
serialize_externally_tagged_variant(params,
variant,
variant_index,
item_attrs)
}
attr::EnumTag::Internal { ref tag } => {
serialize_internally_tagged_variant(params,
variant,
item_attrs,
tag)
}
attr::EnumTag::Adjacent { ref tag, ref content } => {
serialize_adjacently_tagged_variant(params,
variant,
item_attrs,
tag,
content)
}
attr::EnumTag::None => serialize_untagged_variant(params, variant, item_attrs),
});
let body = Match(
match *item_attrs.tag() {
attr::EnumTag::External => {
serialize_externally_tagged_variant(params, variant, variant_index, item_attrs)
}
attr::EnumTag::Internal { ref tag } => {
serialize_internally_tagged_variant(params, variant, item_attrs, tag)
}
attr::EnumTag::Adjacent {
ref tag,
ref content,
} => serialize_adjacently_tagged_variant(params, variant, item_attrs, tag, content),
attr::EnumTag::None => serialize_untagged_variant(params, variant, item_attrs),
},
);
quote! {
#case => #body
@@ -353,11 +369,12 @@ fn serialize_variant(params: &Parameters,
}
}
fn serialize_externally_tagged_variant(params: &Parameters,
variant: &Variant,
variant_index: u32,
item_attrs: &attr::Item)
-> Fragment {
fn serialize_externally_tagged_variant(
params: &Parameters,
variant: &Variant,
variant_index: u32,
item_attrs: &attr::Item,
) -> Fragment {
let type_name = item_attrs.name().serialize_name();
let variant_name = variant.attrs.name().serialize_name();
@@ -390,31 +407,36 @@ fn serialize_externally_tagged_variant(params: &Parameters,
}
}
Style::Tuple => {
serialize_tuple_variant(TupleVariant::ExternallyTagged {
type_name: type_name,
variant_index: variant_index,
variant_name: variant_name,
},
params,
&variant.fields)
serialize_tuple_variant(
TupleVariant::ExternallyTagged {
type_name: type_name,
variant_index: variant_index,
variant_name: variant_name,
},
params,
&variant.fields,
)
}
Style::Struct => {
serialize_struct_variant(StructVariant::ExternallyTagged {
variant_index: variant_index,
variant_name: variant_name,
},
params,
&variant.fields,
&type_name)
serialize_struct_variant(
StructVariant::ExternallyTagged {
variant_index: variant_index,
variant_name: variant_name,
},
params,
&variant.fields,
&type_name,
)
}
}
}
fn serialize_internally_tagged_variant(params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
tag: &str)
-> Fragment {
fn serialize_internally_tagged_variant(
params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
tag: &str,
) -> Fragment {
let type_name = item_attrs.name().serialize_name();
let variant_name = variant.attrs.name().serialize_name();
@@ -450,61 +472,66 @@ fn serialize_internally_tagged_variant(params: &Parameters,
}
}
Style::Struct => {
serialize_struct_variant(StructVariant::InternallyTagged {
tag: tag,
variant_name: variant_name,
},
params,
&variant.fields,
&type_name)
serialize_struct_variant(
StructVariant::InternallyTagged {
tag: tag,
variant_name: variant_name,
},
params,
&variant.fields,
&type_name,
)
}
Style::Tuple => unreachable!("checked in serde_codegen_internals"),
}
}
fn serialize_adjacently_tagged_variant(params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
tag: &str,
content: &str)
-> Fragment {
fn serialize_adjacently_tagged_variant(
params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
tag: &str,
content: &str,
) -> Fragment {
let this = &params.this;
let type_name = item_attrs.name().serialize_name();
let variant_name = variant.attrs.name().serialize_name();
let inner = Stmts(match variant.style {
Style::Unit => {
return quote_block! {
let inner = Stmts(
match variant.style {
Style::Unit => {
return quote_block! {
let mut __struct = try!(_serde::Serializer::serialize_struct(
__serializer, #type_name, 1));
try!(_serde::ser::SerializeStruct::serialize_field(
&mut __struct, #tag, #variant_name));
_serde::ser::SerializeStruct::end(__struct)
};
}
Style::Newtype => {
let field = &variant.fields[0];
let mut field_expr = quote!(__field0);
if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_with(params, field.ty, path, field_expr);
}
Style::Newtype => {
let field = &variant.fields[0];
let mut field_expr = quote!(__field0);
if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_with(params, field.ty, path, field_expr);
}
quote_expr! {
quote_expr! {
_serde::Serialize::serialize(#field_expr, __serializer)
}
}
Style::Tuple => {
serialize_tuple_variant(TupleVariant::Untagged,
params,
&variant.fields)
}
Style::Struct => {
serialize_struct_variant(StructVariant::Untagged,
params,
&variant.fields,
&variant_name)
}
});
}
Style::Tuple => {
serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields)
}
Style::Struct => {
serialize_struct_variant(
StructVariant::Untagged,
params,
&variant.fields,
&variant_name,
)
}
},
);
let fields_ty = variant.fields.iter().map(|f| &f.ty);
let ref fields_ident: Vec<_> = match variant.style {
@@ -516,9 +543,16 @@ fn serialize_adjacently_tagged_variant(params: &Parameters,
.collect()
}
Style::Struct => {
variant.fields
variant
.fields
.iter()
.map(|f| f.ident.clone().expect("struct variant has unnamed fields"))
.map(
|f| {
f.ident
.clone()
.expect("struct variant has unnamed fields")
},
)
.collect()
}
};
@@ -556,10 +590,11 @@ fn serialize_adjacently_tagged_variant(params: &Parameters,
}
}
fn serialize_untagged_variant(params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item)
-> Fragment {
fn serialize_untagged_variant(
params: &Parameters,
variant: &Variant,
item_attrs: &attr::Item,
) -> Fragment {
match variant.style {
Style::Unit => {
quote_expr! {
@@ -577,15 +612,10 @@ fn serialize_untagged_variant(params: &Parameters,
_serde::Serialize::serialize(#field_expr, __serializer)
}
}
Style::Tuple => {
serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields)
}
Style::Tuple => serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields),
Style::Struct => {
let type_name = item_attrs.name().serialize_name();
serialize_struct_variant(StructVariant::Untagged,
params,
&variant.fields,
&type_name)
serialize_struct_variant(StructVariant::Untagged, params, &variant.fields, &type_name)
}
}
}
@@ -599,10 +629,11 @@ enum TupleVariant {
Untagged,
}
fn serialize_tuple_variant(context: TupleVariant,
params: &Parameters,
fields: &[Field])
-> Fragment {
fn serialize_tuple_variant(
context: TupleVariant,
params: &Parameters,
fields: &[Field],
) -> Fragment {
let method = match context {
TupleVariant::ExternallyTagged { .. } => {
quote!(_serde::ser::SerializeTupleVariant::serialize_field)
@@ -610,14 +641,17 @@ fn serialize_tuple_variant(context: TupleVariant,
TupleVariant::Untagged => quote!(_serde::ser::SerializeTuple::serialize_element),
};
let serialize_stmts =
serialize_tuple_struct_visitor(fields, params, true, method);
let serialize_stmts = serialize_tuple_struct_visitor(fields, params, true, method);
let len = serialize_stmts.len();
let let_mut = mut_if(len > 0);
match context {
TupleVariant::ExternallyTagged { type_name, variant_index, variant_name } => {
TupleVariant::ExternallyTagged {
type_name,
variant_index,
variant_name,
} => {
quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant(
__serializer,
@@ -650,11 +684,12 @@ enum StructVariant<'a> {
Untagged,
}
fn serialize_struct_variant<'a>(context: StructVariant<'a>,
params: &Parameters,
fields: &[Field],
name: &str)
-> Fragment {
fn serialize_struct_variant<'a>(
context: StructVariant<'a>,
params: &Parameters,
fields: &[Field],
name: &str,
) -> Fragment {
let method = match context {
StructVariant::ExternallyTagged { .. } => {
quote!(_serde::ser::SerializeStructVariant::serialize_field)
@@ -665,24 +700,31 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
let serialize_fields = serialize_struct_visitor(fields, params, true, method);
let mut serialized_fields = fields.iter()
let mut serialized_fields = fields
.iter()
.filter(|&field| !field.attrs.skip_serializing())
.peekable();
let let_mut = mut_if(serialized_fields.peek().is_some());
let len = serialized_fields.map(|field| {
let ident = field.ident.clone().expect("struct has unnamed fields");
let len = serialized_fields
.map(
|field| {
let ident = field.ident.clone().expect("struct has unnamed fields");
match field.attrs.skip_serializing_if() {
Some(path) => quote!(if #path(#ident) { 0 } else { 1 }),
None => quote!(1),
}
})
match field.attrs.skip_serializing_if() {
Some(path) => quote!(if #path(#ident) { 0 } else { 1 }),
None => quote!(1),
}
},
)
.fold(quote!(0), |sum, expr| quote!(#sum + #expr));
match context {
StructVariant::ExternallyTagged { variant_index, variant_name } => {
StructVariant::ExternallyTagged {
variant_index,
variant_name,
} => {
quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant(
__serializer,
@@ -725,85 +767,94 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
}
}
fn serialize_tuple_struct_visitor(fields: &[Field],
params: &Parameters,
is_enum: bool,
func: Tokens)
-> Vec<Tokens> {
fields.iter()
fn serialize_tuple_struct_visitor(
fields: &[Field],
params: &Parameters,
is_enum: bool,
func: Tokens,
) -> Vec<Tokens> {
fields
.iter()
.enumerate()
.map(|(i, field)| {
let mut field_expr = if is_enum {
let id = Ident::new(format!("__field{}", i));
quote!(#id)
} else {
get_field(params, field, i)
};
.map(
|(i, field)| {
let mut field_expr = if is_enum {
let id = Ident::new(format!("__field{}", i));
quote!(#id)
} else {
get_field(params, field, i)
};
let skip = field.attrs
.skip_serializing_if()
.map(|path| quote!(#path(#field_expr)));
let skip = field
.attrs
.skip_serializing_if()
.map(|path| quote!(#path(#field_expr)));
if let Some(path) = field.attrs.serialize_with() {
field_expr =
wrap_serialize_with(params, field.ty, path, field_expr);
}
if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_with(params, field.ty, path, field_expr);
}
let ser = quote! {
let ser = quote! {
try!(#func(&mut __serde_state, #field_expr));
};
match skip {
None => ser,
Some(skip) => quote!(if !#skip { #ser }),
}
})
match skip {
None => ser,
Some(skip) => quote!(if !#skip { #ser }),
}
},
)
.collect()
}
fn serialize_struct_visitor(fields: &[Field],
params: &Parameters,
is_enum: bool,
func: Tokens)
-> Vec<Tokens> {
fields.iter()
fn serialize_struct_visitor(
fields: &[Field],
params: &Parameters,
is_enum: bool,
func: Tokens,
) -> Vec<Tokens> {
fields
.iter()
.filter(|&field| !field.attrs.skip_serializing())
.map(|field| {
let field_ident = field.ident.clone().expect("struct has unnamed field");
let mut field_expr = if is_enum {
quote!(#field_ident)
} else {
get_field(params, field, field_ident)
};
.map(
|field| {
let field_ident = field.ident.clone().expect("struct has unnamed field");
let mut field_expr = if is_enum {
quote!(#field_ident)
} else {
get_field(params, field, field_ident)
};
let key_expr = field.attrs.name().serialize_name();
let key_expr = field.attrs.name().serialize_name();
let skip = field.attrs
.skip_serializing_if()
.map(|path| quote!(#path(#field_expr)));
let skip = field
.attrs
.skip_serializing_if()
.map(|path| quote!(#path(#field_expr)));
if let Some(path) = field.attrs.serialize_with() {
field_expr =
wrap_serialize_with(params, field.ty, path, field_expr)
}
if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_with(params, field.ty, path, field_expr)
}
let ser = quote! {
let ser = quote! {
try!(#func(&mut __serde_state, #key_expr, #field_expr));
};
match skip {
None => ser,
Some(skip) => quote!(if !#skip { #ser }),
}
})
match skip {
None => ser,
Some(skip) => quote!(if !#skip { #ser }),
}
},
)
.collect()
}
fn wrap_serialize_with(params: &Parameters,
field_ty: &syn::Ty,
serialize_with: &syn::Path,
value: Tokens)
-> Tokens {
fn wrap_serialize_with(
params: &Parameters,
field_ty: &syn::Ty,
serialize_with: &syn::Path,
value: Tokens,
) -> Tokens {
let this = &params.this;
let (_, ty_generics, where_clause) = params.generics.split_for_impl();
@@ -842,7 +893,8 @@ fn mut_if(is_mut: bool) -> Option<Tokens> {
}
fn get_field<I>(params: &Parameters, field: &Field, ident: I) -> Tokens
where I: Into<Ident>
where
I: Into<Ident>,
{
let self_var = &params.self_var;
match (params.is_remote, field.attrs.getter()) {