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

Rustfmt

Browse Source
This commit is contained in:
David Tolnay
2017-02-12 21:59:04 -08:00
parent 964a2dd4d1
commit e8651a52e7
24 changed files with 1220 additions and 1443 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_derive/src/bound.rs
+35 -35
View File
@@ -10,36 +10,33 @@ use internals::attr;
// allowed here".
pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
syn::Generics {
ty_params: generics.ty_params.iter().map(|ty_param| {
syn::TyParam {
default: None,
.. ty_param.clone()
}}).collect(),
.. generics.clone()
ty_params: generics.ty_params
.iter()
.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 {
aster::from_generics(generics.clone())
.with_predicates(predicates.to_vec())
.build()
}
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]>
{
aster::from_generics(generics.clone())
.with_predicates(
item.body.all_fields()
.flat_map(|field| from_field(&field.attrs))
.flat_map(|predicates| predicates.to_vec()))
.with_predicates(item.body
.all_fields()
.flat_map(|field| from_field(&field.attrs))
.flat_map(|predicates| predicates.to_vec()))
.build()
}
@@ -54,13 +51,12 @@ pub fn with_where_predicates_from_fields<F>(
// #[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
@@ -90,11 +86,13 @@ pub fn with_bound<F>(
}
}
let all_ty_params: HashSet<_> = generics.ty_params.iter()
let all_ty_params: HashSet<_> = generics.ty_params
.iter()
.map(|ty_param| ty_param.ident.clone())
.collect();
let relevant_tys = item.body.all_fields()
let relevant_tys = item.body
.all_fields()
.filter(|&field| filter(&field.attrs))
.map(|field| &field.ty);
@@ -107,15 +105,17 @@ pub fn with_bound<F>(
}
aster::from_generics(generics.clone())
.with_predicates(
generics.ty_params.iter()
.map(|ty_param| ty_param.ident.clone())
.filter(|id| visitor.relevant_ty_params.contains(id))
.map(|id| aster::where_predicate()
.with_predicates(generics.ty_params
.iter()
.map(|ty_param| ty_param.ident.clone())
.filter(|id| visitor.relevant_ty_params.contains(id))
.map(|id| {
aster::where_predicate()
// the type parameter that is being bounded e.g. T
.bound().build(aster::ty().id(id))
// the bound e.g. Serialize
.bound().trait_(bound.clone()).build()
.build()))
.build()
}))
.build()
}
serde_derive/src/de.rs
+242 -348
View File
@@ -18,13 +18,14 @@ pub fn expand_derive_deserialize(item: &syn::DeriveInput) -> Result<Tokens, Stri
let impl_generics = build_impl_generics(&item);
let ty = aster::ty().path()
.segment(item.ident.clone()).with_generics(impl_generics.clone()).build()
let ty = aster::ty()
.path()
.segment(item.ident.clone())
.with_generics(impl_generics.clone())
.build()
.build();
let body = deserialize_body(&item,
&impl_generics,
ty.clone());
let body = deserialize_body(&item, &impl_generics, ty.clone());
let where_clause = &impl_generics.where_clause;
@@ -50,21 +51,21 @@ pub fn expand_derive_deserialize(item: &syn::DeriveInput) -> Result<Tokens, Stri
fn build_impl_generics(item: &Item) -> syn::Generics {
let generics = bound::without_defaults(item.generics);
let generics = bound::with_where_predicates_from_fields(
item, &generics,
|attrs| attrs.de_bound());
let generics =
bound::with_where_predicates_from_fields(item, &generics, |attrs| attrs.de_bound());
match item.attrs.de_bound() {
Some(predicates) => {
bound::with_where_predicates(&generics, predicates)
}
Some(predicates) => bound::with_where_predicates(&generics, predicates),
None => {
let generics = bound::with_bound(item, &generics,
needs_deserialize_bound,
&aster::path().ids(&["_serde", "Deserialize"]).build());
bound::with_bound(item, &generics,
requires_default,
&aster::path().global().ids(&["std", "default", "Default"]).build())
let generics =
bound::with_bound(item,
&generics,
needs_deserialize_bound,
&aster::path().ids(&["_serde", "Deserialize"]).build());
bound::with_bound(item,
&generics,
requires_default,
&aster::path().global().ids(&["std", "default", "Default"]).build())
}
}
}
@@ -74,9 +75,7 @@ fn build_impl_generics(item: &Item) -> syn::Generics {
// attribute specify their own bound so we do not generate one. All other fields
// may need a `T: Deserialize` bound where T is the type of the field.
fn needs_deserialize_bound(attrs: &attr::Field) -> bool {
!attrs.skip_deserializing()
&& attrs.deserialize_with().is_none()
&& attrs.de_bound().is_none()
!attrs.skip_deserializing() && attrs.deserialize_with().is_none() && attrs.de_bound().is_none()
}
// Fields with a `default` attribute (not `default=...`), and fields with a
@@ -85,33 +84,23 @@ fn requires_default(attrs: &attr::Field) -> bool {
attrs.default() == &attr::FieldDefault::Default
}
fn deserialize_body(
item: &Item,
impl_generics: &syn::Generics,
ty: syn::Ty,
) -> Tokens {
fn deserialize_body(item: &Item, impl_generics: &syn::Generics, ty: syn::Ty) -> Tokens {
match item.body {
Body::Enum(ref variants) => {
deserialize_item_enum(
&item.ident,
impl_generics,
ty,
variants,
&item.attrs)
deserialize_item_enum(&item.ident, impl_generics, ty, 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(
&item.ident,
None,
impl_generics,
ty,
fields,
&item.attrs,
None)
deserialize_struct(&item.ident,
None,
impl_generics,
ty,
fields,
&item.attrs,
None)
}
Body::Struct(Style::Tuple, ref fields) |
Body::Struct(Style::Newtype, ref fields) => {
@@ -119,20 +108,15 @@ fn deserialize_body(
panic!("tuple struct has named fields");
}
deserialize_tuple(
&item.ident,
None,
impl_generics,
ty,
fields,
&item.attrs,
None)
}
Body::Struct(Style::Unit, _) => {
deserialize_unit_struct(
&item.ident,
&item.attrs)
deserialize_tuple(&item.ident,
None,
impl_generics,
ty,
fields,
&item.attrs,
None)
}
Body::Struct(Style::Unit, _) => deserialize_unit_struct(&item.ident, &item.attrs),
}
}
@@ -145,33 +129,37 @@ fn deserialize_body(
// 3. the expression for instantiating the visitor
fn deserialize_visitor(generics: &syn::Generics) -> (Tokens, Tokens, Tokens) {
if generics.lifetimes.is_empty() && generics.ty_params.is_empty() {
(
quote! {
(quote! {
struct __Visitor;
},
quote!(__Visitor),
quote!(__Visitor),
)
quote!(__Visitor),
quote!(__Visitor))
} else {
let where_clause = &generics.where_clause;
let num_phantoms = generics.lifetimes.len() + generics.ty_params.len();
let phantom_types = generics.lifetimes.iter()
let phantom_types = generics.lifetimes
.iter()
.map(|lifetime_def| {
let lifetime = &lifetime_def.lifetime;
quote!(_serde::export::PhantomData<& #lifetime ()>)
}).chain(generics.ty_params.iter()
})
.chain(generics.ty_params
.iter()
.map(|ty_param| {
let ident = &ty_param.ident;
quote!(_serde::export::PhantomData<#ident>)
}));
let all_params = generics.lifetimes.iter()
let all_params = generics.lifetimes
.iter()
.map(|lifetime_def| {
let lifetime = &lifetime_def.lifetime;
quote!(#lifetime)
}).chain(generics.ty_params.iter()
})
.chain(generics.ty_params
.iter()
.map(|ty_param| {
let ident = &ty_param.ident;
quote!(#ident)
@@ -186,20 +174,15 @@ fn deserialize_visitor(generics: &syn::Generics) -> (Tokens, Tokens, Tokens) {
let phantom_exprs = iter::repeat(quote!(_serde::export::PhantomData)).take(num_phantoms);
(
quote! {
(quote! {
struct __Visitor #generics ( #(#phantom_types),* ) #where_clause;
},
quote!(__Visitor <#(#all_params),*> ),
quote!(__Visitor #ty_param_idents ( #(#phantom_exprs),* )),
)
quote!(__Visitor <#(#all_params),*> ),
quote!(__Visitor #ty_param_idents ( #(#phantom_exprs),* )))
}
}
fn deserialize_unit_struct(
type_ident: &syn::Ident,
item_attrs: &attr::Item,
) -> Tokens {
fn deserialize_unit_struct(type_ident: &syn::Ident, item_attrs: &attr::Item) -> Tokens {
let type_name = item_attrs.name().deserialize_name();
let expecting = format!("unit struct {}", type_ident);
@@ -233,15 +216,14 @@ fn deserialize_unit_struct(
})
}
fn deserialize_tuple(
type_ident: &syn::Ident,
variant_ident: Option<&syn::Ident>,
impl_generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item,
deserializer: Option<Tokens>,
) -> Tokens {
fn deserialize_tuple(type_ident: &syn::Ident,
variant_ident: Option<&syn::Ident>,
impl_generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item,
deserializer: Option<Tokens>)
-> Tokens {
let where_clause = &impl_generics.where_clause;
let (visitor_item, visitor_ty, visitor_expr) = deserialize_visitor(impl_generics);
@@ -259,23 +241,12 @@ fn deserialize_tuple(
let nfields = fields.len();
let visit_newtype_struct = if !is_enum && nfields == 1 {
Some(deserialize_newtype_struct(
type_ident,
&type_path,
impl_generics,
&fields[0],
))
Some(deserialize_newtype_struct(type_ident, &type_path, impl_generics, &fields[0]))
} else {
None
};
let visit_seq = deserialize_seq(
type_ident,
&type_path,
impl_generics,
fields,
false,
);
let visit_seq = deserialize_seq(type_ident, &type_path, impl_generics, fields, false);
let dispatch = if let Some(deserializer) = deserializer {
quote!(_serde::Deserializer::deserialize(#deserializer, #visitor_expr))
@@ -320,13 +291,12 @@ fn deserialize_tuple(
})
}
fn deserialize_seq(
type_ident: &syn::Ident,
type_path: &Tokens,
impl_generics: &syn::Generics,
fields: &[Field],
is_struct: bool,
) -> Tokens {
fn deserialize_seq(type_ident: &syn::Ident,
type_path: &Tokens,
impl_generics: &syn::Generics,
fields: &[Field],
is_struct: bool)
-> Tokens {
let vars = (0..fields.len()).map(field_i as fn(_) -> _);
let deserialized_count = fields.iter()
@@ -389,12 +359,11 @@ fn deserialize_seq(
}
}
fn deserialize_newtype_struct(
type_ident: &syn::Ident,
type_path: &Tokens,
impl_generics: &syn::Generics,
field: &Field,
) -> Tokens {
fn deserialize_newtype_struct(type_ident: &syn::Ident,
type_path: &Tokens,
impl_generics: &syn::Generics,
field: &Field)
-> Tokens {
let value = match field.attrs.deserialize_with() {
None => {
let field_ty = &field.ty;
@@ -403,8 +372,8 @@ fn deserialize_newtype_struct(
}
}
Some(path) => {
let (wrapper, wrapper_impl, wrapper_ty) = wrap_deserialize_with(
type_ident, impl_generics, field.ty, path);
let (wrapper, wrapper_impl, wrapper_ty) =
wrap_deserialize_with(type_ident, impl_generics, field.ty, path);
quote!({
#wrapper
#wrapper_impl
@@ -422,15 +391,14 @@ fn deserialize_newtype_struct(
}
}
fn deserialize_struct(
type_ident: &syn::Ident,
variant_ident: Option<&syn::Ident>,
impl_generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item,
deserializer: Option<Tokens>,
) -> Tokens {
fn deserialize_struct(type_ident: &syn::Ident,
variant_ident: Option<&syn::Ident>,
impl_generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item,
deserializer: Option<Tokens>)
-> Tokens {
let is_enum = variant_ident.is_some();
let is_untagged = deserializer.is_some();
@@ -447,21 +415,10 @@ fn deserialize_struct(
None => format!("struct {}", type_ident),
};
let visit_seq = deserialize_seq(
type_ident,
&type_path,
impl_generics,
fields,
true,
);
let visit_seq = deserialize_seq(type_ident, &type_path, impl_generics, fields, true);
let (field_visitor, fields_stmt, visit_map) = deserialize_struct_visitor(
type_ident,
type_path,
impl_generics,
fields,
item_attrs,
);
let (field_visitor, fields_stmt, visit_map) =
deserialize_struct_visitor(type_ident, type_path, impl_generics, fields, item_attrs);
let dispatch = if let Some(deserializer) = deserializer {
quote! {
@@ -527,52 +484,36 @@ fn deserialize_struct(
})
}
fn deserialize_item_enum(
type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item
) -> Tokens {
fn deserialize_item_enum(type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item)
-> Tokens {
match *item_attrs.tag() {
attr::EnumTag::External => {
deserialize_externally_tagged_enum(
type_ident,
impl_generics,
ty,
variants,
item_attrs,
)
deserialize_externally_tagged_enum(type_ident, impl_generics, ty, variants, item_attrs)
}
attr::EnumTag::Internal(ref tag) => {
deserialize_internally_tagged_enum(
type_ident,
impl_generics,
ty,
variants,
item_attrs,
tag,
)
deserialize_internally_tagged_enum(type_ident,
impl_generics,
ty,
variants,
item_attrs,
tag)
}
attr::EnumTag::None => {
deserialize_untagged_enum(
type_ident,
impl_generics,
ty,
variants,
item_attrs,
)
deserialize_untagged_enum(type_ident, impl_generics, ty, variants, item_attrs)
}
}
}
fn deserialize_externally_tagged_enum(
type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item,
) -> Tokens {
fn deserialize_externally_tagged_enum(type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item)
-> Tokens {
let where_clause = &impl_generics.where_clause;
let type_name = item_attrs.name().deserialize_name();
@@ -592,11 +533,7 @@ fn deserialize_externally_tagged_enum(
}
};
let variant_visitor = deserialize_field_visitor(
variant_names_idents,
item_attrs,
true,
);
let variant_visitor = deserialize_field_visitor(variant_names_idents, item_attrs, true);
// Match arms to extract a variant from a string
let variant_arms = variants.iter()
@@ -605,13 +542,11 @@ fn deserialize_externally_tagged_enum(
.map(|(i, variant)| {
let variant_name = field_i(i);
let block = deserialize_externally_tagged_variant(
type_ident,
impl_generics,
ty.clone(),
variant,
item_attrs,
);
let block = deserialize_externally_tagged_variant(type_ident,
impl_generics,
ty.clone(),
variant,
item_attrs);
quote! {
(__Field::#variant_name, visitor) => #block
@@ -664,14 +599,13 @@ fn deserialize_externally_tagged_enum(
})
}
fn deserialize_internally_tagged_enum(
type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item,
tag: &str,
) -> Tokens {
fn deserialize_internally_tagged_enum(type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item,
tag: &str)
-> Tokens {
let variant_names_idents: Vec<_> = variants.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
@@ -685,11 +619,7 @@ fn deserialize_internally_tagged_enum(
}
};
let variant_visitor = deserialize_field_visitor(
variant_names_idents,
item_attrs,
true,
);
let variant_visitor = deserialize_field_visitor(variant_names_idents, item_attrs, true);
// Match arms to extract a variant from a string
let variant_arms = variants.iter()
@@ -727,13 +657,12 @@ fn deserialize_internally_tagged_enum(
})
}
fn deserialize_untagged_enum(
type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item,
) -> Tokens {
fn deserialize_untagged_enum(type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item)
-> Tokens {
let attempts = variants.iter()
.filter(|variant| !variant.attrs.skip_deserializing())
.map(|variant| {
@@ -768,13 +697,12 @@ fn deserialize_untagged_enum(
})
}
fn deserialize_externally_tagged_variant(
type_ident: &syn::Ident,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item,
) -> Tokens {
fn deserialize_externally_tagged_variant(type_ident: &syn::Ident,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item)
-> Tokens {
let variant_ident = &variant.ident;
match variant.style {
@@ -785,46 +713,39 @@ fn deserialize_externally_tagged_variant(
})
}
Style::Newtype => {
deserialize_externally_tagged_newtype_variant(
type_ident,
variant_ident,
generics,
&variant.fields[0],
)
deserialize_externally_tagged_newtype_variant(type_ident,
variant_ident,
generics,
&variant.fields[0])
}
Style::Tuple => {
deserialize_tuple(
type_ident,
Some(variant_ident),
generics,
ty,
&variant.fields,
item_attrs,
None,
)
deserialize_tuple(type_ident,
Some(variant_ident),
generics,
ty,
&variant.fields,
item_attrs,
None)
}
Style::Struct => {
deserialize_struct(
type_ident,
Some(variant_ident),
generics,
ty,
&variant.fields,
item_attrs,
None,
)
deserialize_struct(type_ident,
Some(variant_ident),
generics,
ty,
&variant.fields,
item_attrs,
None)
}
}
}
fn deserialize_internally_tagged_variant(
type_ident: &syn::Ident,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item,
deserializer: Tokens,
) -> Tokens {
fn deserialize_internally_tagged_variant(type_ident: &syn::Ident,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item,
deserializer: Tokens)
-> Tokens {
let variant_ident = &variant.ident;
match variant.style {
@@ -837,27 +758,24 @@ fn deserialize_internally_tagged_variant(
})
}
Style::Newtype | Style::Struct => {
deserialize_untagged_variant(
type_ident,
generics,
ty,
variant,
item_attrs,
deserializer,
)
deserialize_untagged_variant(type_ident,
generics,
ty,
variant,
item_attrs,
deserializer)
}
Style::Tuple => unreachable!("checked in serde_codegen_internals"),
}
}
fn deserialize_untagged_variant(
type_ident: &syn::Ident,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item,
deserializer: Tokens,
) -> Tokens {
fn deserialize_untagged_variant(type_ident: &syn::Ident,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item,
deserializer: Tokens)
-> Tokens {
let variant_ident = &variant.ident;
match variant.style {
@@ -874,45 +792,38 @@ fn deserialize_untagged_variant(
}
}
Style::Newtype => {
deserialize_untagged_newtype_variant(
type_ident,
variant_ident,
generics,
&variant.fields[0],
deserializer,
)
deserialize_untagged_newtype_variant(type_ident,
variant_ident,
generics,
&variant.fields[0],
deserializer)
}
Style::Tuple => {
deserialize_tuple(
type_ident,
Some(variant_ident),
generics,
ty,
&variant.fields,
item_attrs,
Some(deserializer),
)
deserialize_tuple(type_ident,
Some(variant_ident),
generics,
ty,
&variant.fields,
item_attrs,
Some(deserializer))
}
Style::Struct => {
deserialize_struct(
type_ident,
Some(variant_ident),
generics,
ty,
&variant.fields,
item_attrs,
Some(deserializer),
)
deserialize_struct(type_ident,
Some(variant_ident),
generics,
ty,
&variant.fields,
item_attrs,
Some(deserializer))
}
}
}
fn deserialize_externally_tagged_newtype_variant(
type_ident: &syn::Ident,
variant_ident: &syn::Ident,
impl_generics: &syn::Generics,
field: &Field,
) -> Tokens {
fn deserialize_externally_tagged_newtype_variant(type_ident: &syn::Ident,
variant_ident: &syn::Ident,
impl_generics: &syn::Generics,
field: &Field)
-> Tokens {
match field.attrs.deserialize_with() {
None => {
let field_ty = &field.ty;
@@ -923,8 +834,8 @@ fn deserialize_externally_tagged_newtype_variant(
}
}
Some(path) => {
let (wrapper, wrapper_impl, wrapper_ty) = wrap_deserialize_with(
type_ident, impl_generics, field.ty, path);
let (wrapper, wrapper_impl, wrapper_ty) =
wrap_deserialize_with(type_ident, impl_generics, field.ty, path);
quote!({
#wrapper
#wrapper_impl
@@ -936,13 +847,12 @@ fn deserialize_externally_tagged_newtype_variant(
}
}
fn deserialize_untagged_newtype_variant(
type_ident: &syn::Ident,
variant_ident: &syn::Ident,
impl_generics: &syn::Generics,
field: &Field,
deserializer: Tokens,
) -> Tokens {
fn deserialize_untagged_newtype_variant(type_ident: &syn::Ident,
variant_ident: &syn::Ident,
impl_generics: &syn::Generics,
field: &Field,
deserializer: Tokens)
-> Tokens {
match field.attrs.deserialize_with() {
None => {
let field_ty = &field.ty;
@@ -953,8 +863,8 @@ fn deserialize_untagged_newtype_variant(
})
}
Some(path) => {
let (wrapper, wrapper_impl, wrapper_ty) = wrap_deserialize_with(
type_ident, impl_generics, field.ty, path);
let (wrapper, wrapper_impl, wrapper_ty) =
wrap_deserialize_with(type_ident, impl_generics, field.ty, path);
quote!({
#wrapper
#wrapper_impl
@@ -966,11 +876,10 @@ fn deserialize_untagged_newtype_variant(
}
}
fn deserialize_field_visitor(
fields: Vec<(String, Ident)>,
item_attrs: &attr::Item,
is_variant: bool,
) -> Tokens {
fn deserialize_field_visitor(fields: Vec<(String, Ident)>,
item_attrs: &attr::Item,
is_variant: bool)
-> Tokens {
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();
@@ -1081,13 +990,12 @@ fn deserialize_field_visitor(
}
}
fn deserialize_struct_visitor(
type_ident: &syn::Ident,
struct_path: Tokens,
impl_generics: &syn::Generics,
fields: &[Field],
item_attrs: &attr::Item,
) -> (Tokens, Tokens, Tokens) {
fn deserialize_struct_visitor(type_ident: &syn::Ident,
struct_path: Tokens,
impl_generics: &syn::Generics,
fields: &[Field],
item_attrs: &attr::Item)
-> (Tokens, Tokens, Tokens) {
let field_names_idents: Vec<_> = fields.iter()
.enumerate()
.filter(|&(_, field)| !field.attrs.skip_deserializing())
@@ -1101,30 +1009,19 @@ fn deserialize_struct_visitor(
}
};
let field_visitor = deserialize_field_visitor(
field_names_idents,
item_attrs,
false,
);
let field_visitor = deserialize_field_visitor(field_names_idents, item_attrs, false);
let visit_map = deserialize_map(
type_ident,
struct_path,
impl_generics,
fields,
item_attrs,
);
let visit_map = deserialize_map(type_ident, struct_path, impl_generics, fields, item_attrs);
(field_visitor, fields_stmt, visit_map)
}
fn deserialize_map(
type_ident: &syn::Ident,
struct_path: Tokens,
impl_generics: &syn::Generics,
fields: &[Field],
item_attrs: &attr::Item,
) -> Tokens {
fn deserialize_map(type_ident: &syn::Ident,
struct_path: Tokens,
impl_generics: &syn::Generics,
fields: &[Field],
item_attrs: &attr::Item)
-> Tokens {
// Create the field names for the fields.
let fields_names: Vec<_> = fields.iter()
.enumerate()
@@ -1243,38 +1140,36 @@ 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(
type_ident: &syn::Ident,
impl_generics: &syn::Generics,
field_ty: &syn::Ty,
deserialize_with: &syn::Path,
) -> (Tokens, Tokens, syn::Path) {
fn wrap_deserialize_with(type_ident: &syn::Ident,
impl_generics: &syn::Generics,
field_ty: &syn::Ty,
deserialize_with: &syn::Path)
-> (Tokens, Tokens, syn::Path) {
// Quasi-quoting doesn't do a great job of expanding generics into paths,
// so manually build it.
let wrapper_ty = aster::path()
.segment("__SerdeDeserializeWithStruct")
.with_generics(impl_generics.clone())
.build()
.with_generics(impl_generics.clone())
.build()
.build();
let where_clause = &impl_generics.where_clause;
let phantom_ty = aster::path()
.segment(type_ident)
.with_generics(aster::from_generics(impl_generics.clone())
.strip_ty_params()
.build())
.build()
.with_generics(aster::from_generics(impl_generics.clone())
.strip_ty_params()
.build())
.build()
.build();
(
quote! {
(quote! {
struct __SerdeDeserializeWithStruct #impl_generics #where_clause {
value: #field_ty,
phantom: _serde::export::PhantomData<#phantom_ty>,
}
},
quote! {
quote! {
impl #impl_generics _serde::Deserialize for #wrapper_ty #where_clause {
fn deserialize<__D>(__d: __D) -> _serde::export::Result<Self, __D::Error>
where __D: _serde::Deserializer
@@ -1287,8 +1182,7 @@ fn wrap_deserialize_with(
}
}
},
wrapper_ty,
)
wrapper_ty)
}
fn expr_is_missing(attrs: &attr::Field) -> Tokens {
@@ -1319,14 +1213,14 @@ fn expr_is_missing(attrs: &attr::Field) -> Tokens {
fn check_no_str(cx: &internals::Ctxt, item: &Item) {
let fail = || {
cx.error(
"Serde does not support deserializing fields of type &str; \
consider using String instead");
cx.error("Serde does not support deserializing fields of type &str; consider using \
String instead");
};
for field in item.body.all_fields() {
if field.attrs.skip_deserializing()
|| field.attrs.deserialize_with().is_some() { continue }
if field.attrs.skip_deserializing() || field.attrs.deserialize_with().is_some() {
continue;
}
if let syn::Ty::Rptr(_, ref inner) = *field.ty {
if let syn::Ty::Path(_, ref path) = inner.ty {
serde_derive/src/ser.rs
+196 -287
View File
@@ -12,13 +12,14 @@ pub fn expand_derive_serialize(item: &syn::DeriveInput) -> Result<Tokens, String
let impl_generics = build_impl_generics(&item);
let ty = aster::ty().path()
.segment(item.ident.clone()).with_generics(impl_generics.clone()).build()
let ty = aster::ty()
.path()
.segment(item.ident.clone())
.with_generics(impl_generics.clone())
.build()
.build();
let body = serialize_body(&item,
&impl_generics,
ty.clone());
let body = serialize_body(&item, &impl_generics, ty.clone());
let where_clause = &impl_generics.where_clause;
@@ -45,18 +46,16 @@ pub fn expand_derive_serialize(item: &syn::DeriveInput) -> Result<Tokens, String
fn build_impl_generics(item: &Item) -> syn::Generics {
let generics = bound::without_defaults(item.generics);
let generics = bound::with_where_predicates_from_fields(
item, &generics,
|attrs| attrs.ser_bound());
let generics =
bound::with_where_predicates_from_fields(item, &generics, |attrs| attrs.ser_bound());
match item.attrs.ser_bound() {
Some(predicates) => {
bound::with_where_predicates(&generics, predicates)
}
Some(predicates) => bound::with_where_predicates(&generics, predicates),
None => {
bound::with_bound(item, &generics,
needs_serialize_bound,
&aster::path().ids(&["_serde", "Serialize"]).build())
bound::with_bound(item,
&generics,
needs_serialize_bound,
&aster::path().ids(&["_serde", "Serialize"]).build())
}
}
}
@@ -66,58 +65,32 @@ fn build_impl_generics(item: &Item) -> syn::Generics {
// attribute specify their own bound so we do not generate one. All other fields
// may need a `T: Serialize` bound where T is the type of the field.
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,
impl_generics: &syn::Generics,
ty: syn::Ty,
) -> Tokens {
fn serialize_body(item: &Item, impl_generics: &syn::Generics, ty: syn::Ty) -> Tokens {
match item.body {
Body::Enum(ref variants) => {
serialize_item_enum(
&item.ident,
impl_generics,
ty,
variants,
&item.attrs)
serialize_item_enum(&item.ident, impl_generics, ty, variants, &item.attrs)
}
Body::Struct(Style::Struct, ref fields) => {
if fields.iter().any(|field| field.ident.is_none()) {
panic!("struct has unnamed fields");
}
serialize_struct(
impl_generics,
ty,
fields,
&item.attrs)
serialize_struct(impl_generics, ty, fields, &item.attrs)
}
Body::Struct(Style::Tuple, ref fields) => {
if fields.iter().any(|field| field.ident.is_some()) {
panic!("tuple struct has named fields");
}
serialize_tuple_struct(
impl_generics,
ty,
fields,
&item.attrs)
serialize_tuple_struct(impl_generics, ty, fields, &item.attrs)
}
Body::Struct(Style::Newtype, ref fields) => {
serialize_newtype_struct(
impl_generics,
ty,
&fields[0],
&item.attrs)
}
Body::Struct(Style::Unit, _) => {
serialize_unit_struct(
&item.attrs)
serialize_newtype_struct(impl_generics, ty, &fields[0], &item.attrs)
}
Body::Struct(Style::Unit, _) => serialize_unit_struct(&item.attrs),
}
}
@@ -129,18 +102,16 @@ fn serialize_unit_struct(item_attrs: &attr::Item) -> Tokens {
}
}
fn serialize_newtype_struct(
impl_generics: &syn::Generics,
item_ty: syn::Ty,
field: &Field,
item_attrs: &attr::Item,
) -> Tokens {
fn serialize_newtype_struct(impl_generics: &syn::Generics,
item_ty: syn::Ty,
field: &Field,
item_attrs: &attr::Item)
-> Tokens {
let type_name = item_attrs.name().serialize_name();
let mut field_expr = quote!(&self.0);
if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_with(
&item_ty, impl_generics, field.ty, path, field_expr);
field_expr = wrap_serialize_with(&item_ty, impl_generics, field.ty, path, field_expr);
}
quote! {
@@ -148,19 +119,17 @@ fn serialize_newtype_struct(
}
}
fn serialize_tuple_struct(
impl_generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item,
) -> Tokens {
let serialize_stmts = serialize_tuple_struct_visitor(
ty.clone(),
fields,
impl_generics,
false,
quote!(_serde::ser::SerializeTupleStruct::serialize_field),
);
fn serialize_tuple_struct(impl_generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item)
-> Tokens {
let serialize_stmts =
serialize_tuple_struct_visitor(ty.clone(),
fields,
impl_generics,
false,
quote!(_serde::ser::SerializeTupleStruct::serialize_field));
let type_name = item_attrs.name().serialize_name();
let len = serialize_stmts.len();
@@ -173,19 +142,17 @@ fn serialize_tuple_struct(
}
}
fn serialize_struct(
impl_generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item,
) -> Tokens {
let serialize_fields = serialize_struct_visitor(
ty.clone(),
fields,
impl_generics,
false,
quote!(_serde::ser::SerializeStruct::serialize_field),
);
fn serialize_struct(impl_generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item)
-> Tokens {
let serialize_fields =
serialize_struct_visitor(ty.clone(),
fields,
impl_generics,
false,
quote!(_serde::ser::SerializeStruct::serialize_field));
let type_name = item_attrs.name().serialize_name();
@@ -195,8 +162,7 @@ fn serialize_struct(
let let_mut = mut_if(serialized_fields.peek().is_some());
let len = serialized_fields
.map(|field| {
let len = serialized_fields.map(|field| {
let ident = field.ident.clone().expect("struct has unnamed fields");
let field_expr = quote!(&self.#ident);
@@ -204,7 +170,7 @@ fn serialize_struct(
Some(path) => quote!(if #path(#field_expr) { 0 } else { 1 }),
None => quote!(1),
}
})
})
.fold(quote!(0), |sum, expr| quote!(#sum + #expr));
quote! {
@@ -214,27 +180,23 @@ fn serialize_struct(
}
}
fn serialize_item_enum(
type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item,
) -> Tokens {
let arms: Vec<_> =
variants.iter()
.enumerate()
.map(|(variant_index, variant)| {
serialize_variant(
type_ident,
impl_generics,
ty.clone(),
variant,
variant_index,
item_attrs,
)
})
.collect();
fn serialize_item_enum(type_ident: &syn::Ident,
impl_generics: &syn::Generics,
ty: syn::Ty,
variants: &[Variant],
item_attrs: &attr::Item)
-> Tokens {
let arms: Vec<_> = variants.iter()
.enumerate()
.map(|(variant_index, variant)| {
serialize_variant(type_ident,
impl_generics,
ty.clone(),
variant,
variant_index,
item_attrs)
})
.collect();
quote! {
match *self {
@@ -243,14 +205,13 @@ fn serialize_item_enum(
}
}
fn serialize_variant(
type_ident: &syn::Ident,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
variant_index: usize,
item_attrs: &attr::Item,
) -> Tokens {
fn serialize_variant(type_ident: &syn::Ident,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
variant_index: usize,
item_attrs: &attr::Item)
-> Tokens {
let variant_ident = variant.ident.clone();
if variant.attrs.skip_serializing() {
@@ -267,7 +228,8 @@ fn serialize_variant(
quote! {
#type_ident::#variant_ident #fields_pat => #skipped_err,
}
} else { // variant wasn't skipped
} else {
// variant wasn't skipped
let case = match variant.style {
Style::Unit => {
quote! {
@@ -280,14 +242,15 @@ fn serialize_variant(
}
}
Style::Tuple => {
let field_names = (0 .. variant.fields.len())
let field_names = (0..variant.fields.len())
.map(|i| Ident::new(format!("__field{}", i)));
quote! {
#type_ident::#variant_ident(#(ref #field_names),*)
}
}
Style::Struct => {
let fields = variant.fields.iter()
let fields = variant.fields
.iter()
.map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
quote! {
#type_ident::#variant_ident { #(ref #fields),* }
@@ -297,33 +260,22 @@ fn serialize_variant(
let body = match *item_attrs.tag() {
attr::EnumTag::External => {
serialize_externally_tagged_variant(
generics,
ty,
variant,
variant_index,
item_attrs,
)
serialize_externally_tagged_variant(generics,
ty,
variant,
variant_index,
item_attrs)
}
attr::EnumTag::Internal(ref tag) => {
serialize_internally_tagged_variant(
type_ident.as_ref(),
variant_ident.as_ref(),
generics,
ty,
variant,
item_attrs,
tag,
)
}
attr::EnumTag::None => {
serialize_untagged_variant(
generics,
ty,
variant,
item_attrs,
)
serialize_internally_tagged_variant(type_ident.as_ref(),
variant_ident.as_ref(),
generics,
ty,
variant,
item_attrs,
tag)
}
attr::EnumTag::None => serialize_untagged_variant(generics, ty, variant, item_attrs),
};
quote! {
@@ -332,13 +284,12 @@ fn serialize_variant(
}
}
fn serialize_externally_tagged_variant(
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
variant_index: usize,
item_attrs: &attr::Item,
) -> Tokens {
fn serialize_externally_tagged_variant(generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
variant_index: usize,
item_attrs: &attr::Item)
-> Tokens {
let type_name = item_attrs.name().serialize_name();
let variant_name = variant.attrs.name().serialize_name();
@@ -357,8 +308,7 @@ fn serialize_externally_tagged_variant(
let field = &variant.fields[0];
let mut field_expr = quote!(__simple_value);
if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_with(
&ty, generics, field.ty, path, field_expr);
field_expr = wrap_serialize_with(&ty, generics, field.ty, path, field_expr);
}
quote! {
@@ -372,32 +322,28 @@ fn serialize_externally_tagged_variant(
}
}
Style::Tuple => {
let block = serialize_tuple_variant(
TupleVariant::ExternallyTagged {
type_name: type_name,
variant_index: variant_index,
variant_name: variant_name,
},
generics,
ty,
&variant.fields,
);
let block = serialize_tuple_variant(TupleVariant::ExternallyTagged {
type_name: type_name,
variant_index: variant_index,
variant_name: variant_name,
},
generics,
ty,
&variant.fields);
quote! {
{ #block }
}
}
Style::Struct => {
let block = serialize_struct_variant(
StructVariant::ExternallyTagged {
variant_index: variant_index,
variant_name: variant_name,
},
generics,
ty,
&variant.fields,
item_attrs,
);
let block = serialize_struct_variant(StructVariant::ExternallyTagged {
variant_index: variant_index,
variant_name: variant_name,
},
generics,
ty,
&variant.fields,
item_attrs);
quote! {
{ #block }
@@ -406,15 +352,14 @@ fn serialize_externally_tagged_variant(
}
}
fn serialize_internally_tagged_variant(
type_ident: &str,
variant_ident: &str,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item,
tag: &str,
) -> Tokens {
fn serialize_internally_tagged_variant(type_ident: &str,
variant_ident: &str,
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item,
tag: &str)
-> Tokens {
let type_name = item_attrs.name().serialize_name();
let variant_name = variant.attrs.name().serialize_name();
@@ -432,8 +377,7 @@ fn serialize_internally_tagged_variant(
let field = &variant.fields[0];
let mut field_expr = quote!(__simple_value);
if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_with(
&ty, generics, field.ty, path, field_expr);
field_expr = wrap_serialize_with(&ty, generics, field.ty, path, field_expr);
}
quote! {
@@ -448,16 +392,14 @@ fn serialize_internally_tagged_variant(
}
}
Style::Struct => {
let block = serialize_struct_variant(
StructVariant::InternallyTagged {
tag: tag,
variant_name: variant_name,
},
generics,
ty,
&variant.fields,
item_attrs,
);
let block = serialize_struct_variant(StructVariant::InternallyTagged {
tag: tag,
variant_name: variant_name,
},
generics,
ty,
&variant.fields,
item_attrs);
quote! {
{ #block }
@@ -467,12 +409,11 @@ fn serialize_internally_tagged_variant(
}
}
fn serialize_untagged_variant(
generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item,
) -> Tokens {
fn serialize_untagged_variant(generics: &syn::Generics,
ty: syn::Ty,
variant: &Variant,
item_attrs: &attr::Item)
-> Tokens {
match variant.style {
Style::Unit => {
quote! {
@@ -483,8 +424,7 @@ fn serialize_untagged_variant(
let field = &variant.fields[0];
let mut field_expr = quote!(__simple_value);
if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_with(
&ty, generics, field.ty, path, field_expr);
field_expr = wrap_serialize_with(&ty, generics, field.ty, path, field_expr);
}
quote! {
@@ -492,25 +432,19 @@ fn serialize_untagged_variant(
}
}
Style::Tuple => {
let block = serialize_tuple_variant(
TupleVariant::Untagged,
generics,
ty,
&variant.fields,
);
let block =
serialize_tuple_variant(TupleVariant::Untagged, generics, ty, &variant.fields);
quote! {
{ #block }
}
}
Style::Struct => {
let block = serialize_struct_variant(
StructVariant::Untagged,
generics,
ty,
&variant.fields,
item_attrs,
);
let block = serialize_struct_variant(StructVariant::Untagged,
generics,
ty,
&variant.fields,
item_attrs);
quote! {
{ #block }
@@ -528,28 +462,20 @@ enum TupleVariant {
Untagged,
}
fn serialize_tuple_variant(
context: TupleVariant,
generics: &syn::Generics,
structure_ty: syn::Ty,
fields: &[Field],
) -> Tokens {
fn serialize_tuple_variant(context: TupleVariant,
generics: &syn::Generics,
structure_ty: syn::Ty,
fields: &[Field])
-> Tokens {
let method = match context {
TupleVariant::ExternallyTagged{..} => {
TupleVariant::ExternallyTagged { .. } => {
quote!(_serde::ser::SerializeTupleVariant::serialize_field)
}
TupleVariant::Untagged => {
quote!(_serde::ser::SerializeTuple::serialize_element)
}
TupleVariant::Untagged => quote!(_serde::ser::SerializeTuple::serialize_element),
};
let serialize_stmts = serialize_tuple_struct_visitor(
structure_ty,
fields,
generics,
true,
method,
);
let serialize_stmts =
serialize_tuple_struct_visitor(structure_ty, fields, generics, true, method);
let len = serialize_stmts.len();
let let_mut = mut_if(len > 0);
@@ -584,36 +510,25 @@ enum StructVariant<'a> {
variant_index: usize,
variant_name: String,
},
InternallyTagged {
tag: &'a str,
variant_name: String,
},
InternallyTagged { tag: &'a str, variant_name: String },
Untagged,
}
fn serialize_struct_variant<'a>(
context: StructVariant<'a>,
generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item,
) -> Tokens {
fn serialize_struct_variant<'a>(context: StructVariant<'a>,
generics: &syn::Generics,
ty: syn::Ty,
fields: &[Field],
item_attrs: &attr::Item)
-> Tokens {
let method = match context {
StructVariant::ExternallyTagged{..} => {
StructVariant::ExternallyTagged { .. } => {
quote!(_serde::ser::SerializeStructVariant::serialize_field)
}
StructVariant::InternallyTagged{..} | StructVariant::Untagged => {
quote!(_serde::ser::SerializeStruct::serialize_field)
}
StructVariant::InternallyTagged { .. } |
StructVariant::Untagged => quote!(_serde::ser::SerializeStruct::serialize_field),
};
let serialize_fields = serialize_struct_visitor(
ty.clone(),
fields,
generics,
true,
method,
);
let serialize_fields = serialize_struct_visitor(ty.clone(), fields, generics, true, method);
let item_name = item_attrs.name().serialize_name();
@@ -623,15 +538,14 @@ fn serialize_struct_variant<'a>(
let let_mut = mut_if(serialized_fields.peek().is_some());
let len = serialized_fields
.map(|field| {
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),
}
})
})
.fold(quote!(0), |sum, expr| quote!(#sum + #expr));
match context {
@@ -678,13 +592,12 @@ fn serialize_struct_variant<'a>(
}
}
fn serialize_tuple_struct_visitor(
structure_ty: syn::Ty,
fields: &[Field],
generics: &syn::Generics,
is_enum: bool,
func: Tokens,
) -> Vec<Tokens> {
fn serialize_tuple_struct_visitor(structure_ty: syn::Ty,
fields: &[Field],
generics: &syn::Generics,
is_enum: bool,
func: Tokens)
-> Vec<Tokens> {
fields.iter()
.enumerate()
.map(|(i, field)| {
@@ -696,12 +609,13 @@ fn serialize_tuple_struct_visitor(
quote!(&self.#i)
};
let skip = field.attrs.skip_serializing_if()
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(
&structure_ty, generics, field.ty, path, field_expr);
field_expr =
wrap_serialize_with(&structure_ty, generics, field.ty, path, field_expr);
}
let ser = quote! {
@@ -716,13 +630,12 @@ fn serialize_tuple_struct_visitor(
.collect()
}
fn serialize_struct_visitor(
structure_ty: syn::Ty,
fields: &[Field],
generics: &syn::Generics,
is_enum: bool,
func: Tokens,
) -> Vec<Tokens> {
fn serialize_struct_visitor(structure_ty: syn::Ty,
fields: &[Field],
generics: &syn::Generics,
is_enum: bool,
func: Tokens)
-> Vec<Tokens> {
fields.iter()
.filter(|&field| !field.attrs.skip_serializing())
.map(|field| {
@@ -735,12 +648,13 @@ fn serialize_struct_visitor(
let key_expr = field.attrs.name().serialize_name();
let skip = field.attrs.skip_serializing_if()
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(
&structure_ty, generics, field.ty, path, field_expr)
field_expr =
wrap_serialize_with(&structure_ty, generics, field.ty, path, field_expr)
}
let ser = quote! {
@@ -755,13 +669,12 @@ fn serialize_struct_visitor(
.collect()
}
fn wrap_serialize_with(
item_ty: &syn::Ty,
generics: &syn::Generics,
field_ty: &syn::Ty,
path: &syn::Path,
value: Tokens,
) -> Tokens {
fn wrap_serialize_with(item_ty: &syn::Ty,
generics: &syn::Generics,
field_ty: &syn::Ty,
path: &syn::Path,
value: Tokens)
-> Tokens {
let where_clause = &generics.where_clause;
let wrapper_generics = aster::from_generics(generics.clone())
@@ -771,8 +684,8 @@ fn wrap_serialize_with(
let wrapper_ty = aster::path()
.segment("__SerializeWith")
.with_generics(wrapper_generics.clone())
.build()
.with_generics(wrapper_generics.clone())
.build()
.build();
quote!({
@@ -803,9 +716,5 @@ fn wrap_serialize_with(
//
// where we want to omit the `mut` to avoid a warning.
fn mut_if(is_mut: bool) -> Option<Tokens> {
if is_mut {
Some(quote!(mut))
} else {
None
}
if is_mut { Some(quote!(mut)) } else { None }
}