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

Address clippy lints in serde_derive

Browse Source
This commit is contained in:
David Tolnay
2018-01-09 19:34:35 -08:00
parent 34eaab00f7
commit 16bc9fb99e
3 changed files with 88 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_derive/src/bound.rs
+2 -2
View File
@@ -125,7 +125,7 @@ where
} }
} }
if path.leading_colon.is_none() && path.segments.len() == 1 { if path.leading_colon.is_none() && path.segments.len() == 1 {
let id = path.segments[0].ident.clone(); let id = path.segments[0].ident;
if self.all_ty_params.contains(&id) { if self.all_ty_params.contains(&id) {
self.relevant_ty_params.insert(id); self.relevant_ty_params.insert(id);
} }
@@ -289,7 +289,7 @@ fn type_of_item(cont: &Container) -> syn::Type {
leading_colon: None, leading_colon: None,
segments: vec![ segments: vec![
syn::PathSegment { syn::PathSegment {
ident: cont.ident.clone(), ident: cont.ident,
arguments: syn::PathArguments::AngleBracketed( arguments: syn::PathArguments::AngleBracketed(
syn::AngleBracketedGenericArguments { syn::AngleBracketedGenericArguments {
colon2_token: None, colon2_token: None,
serde_derive/src/de.rs
+49 -54
View File
@@ -91,10 +91,10 @@ struct Parameters {
impl Parameters { impl Parameters {
fn new(cont: &Container) -> Self { fn new(cont: &Container) -> Self {
let local = cont.ident.clone(); let local = cont.ident;
let this = match cont.attrs.remote() { let this = match cont.attrs.remote() {
Some(remote) => remote.clone(), Some(remote) => remote.clone(),
None => cont.ident.clone().into(), None => cont.ident.into(),
}; };
let borrowed = borrowed_lifetimes(cont); let borrowed = borrowed_lifetimes(cont);
let generics = build_generics(cont, &borrowed); let generics = build_generics(cont, &borrowed);
@@ -230,7 +230,7 @@ fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
if fields.iter().any(|field| field.ident.is_none()) { if fields.iter().any(|field| field.ident.is_none()) {
panic!("struct has unnamed fields"); panic!("struct has unnamed fields");
} }
deserialize_struct(None, params, fields, &cont.attrs, None, Untagged::No) deserialize_struct(None, params, fields, &cont.attrs, None, &Untagged::No)
} }
Data::Struct(Style::Tuple, ref fields) | Data::Struct(Style::Newtype, ref fields) => { Data::Struct(Style::Tuple, ref fields) | Data::Struct(Style::Newtype, ref fields) => {
if fields.iter().any(|field| field.ident.is_some()) { if fields.iter().any(|field| field.ident.is_some()) {
@@ -266,7 +266,7 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
let code = match cont.data { let code = match cont.data {
Data::Struct(Style::Struct, ref fields) => { Data::Struct(Style::Struct, ref fields) => {
deserialize_struct_in_place(None, params, fields, &cont.attrs, None, Untagged::No) deserialize_struct_in_place(None, params, fields, &cont.attrs, None)
} }
Data::Struct(Style::Tuple, ref fields) | Data::Struct(Style::Newtype, ref fields) => { Data::Struct(Style::Tuple, ref fields) | Data::Struct(Style::Newtype, ref fields) => {
deserialize_tuple_in_place(None, params, fields, &cont.attrs, None) deserialize_tuple_in_place(None, params, fields, &cont.attrs, None)
@@ -529,7 +529,7 @@ fn deserialize_seq(
let mut index_in_seq = 0usize; let mut index_in_seq = 0usize;
let let_values = vars.clone().zip(fields).map(|(var, field)| { let let_values = vars.clone().zip(fields).map(|(var, field)| {
if field.attrs.skip_deserializing() { if field.attrs.skip_deserializing() {
let default = Expr(expr_is_missing(&field, cattrs)); let default = Expr(expr_is_missing(field, cattrs));
quote! { quote! {
let #var = #default; let #var = #default;
} }
@@ -627,7 +627,7 @@ fn deserialize_seq_in_place(
.unwrap_or_else(|| Member::Unnamed(field_index.into())); .unwrap_or_else(|| Member::Unnamed(field_index.into()));
if field.attrs.skip_deserializing() { if field.attrs.skip_deserializing() {
let default = Expr(expr_is_missing(&field, cattrs)); let default = Expr(expr_is_missing(field, cattrs));
quote! { quote! {
self.place.#field_name = #default; self.place.#field_name = #default;
} }
@@ -754,7 +754,7 @@ fn deserialize_struct(
fields: &[Field], fields: &[Field],
cattrs: &attr::Container, cattrs: &attr::Container,
deserializer: Option<Tokens>, deserializer: Option<Tokens>,
untagged: Untagged, untagged: &Untagged,
) -> Fragment { ) -> Fragment {
let is_enum = variant_ident.is_some(); let is_enum = variant_ident.is_some();
@@ -785,7 +785,7 @@ fn deserialize_struct(
let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, true, cattrs)); let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, true, cattrs));
let (field_visitor, fields_stmt, visit_map) = let (field_visitor, fields_stmt, visit_map) =
deserialize_struct_visitor(type_path, params, fields, cattrs); deserialize_struct_visitor(&type_path, params, fields, cattrs);
let field_visitor = Stmts(field_visitor); let field_visitor = Stmts(field_visitor);
let fields_stmt = Stmts(fields_stmt); let fields_stmt = Stmts(fields_stmt);
let visit_map = Stmts(visit_map); let visit_map = Stmts(visit_map);
@@ -819,7 +819,7 @@ fn deserialize_struct(
}; };
// untagged struct variants do not get a visit_seq method // untagged struct variants do not get a visit_seq method
let visit_seq = match untagged { let visit_seq = match *untagged {
Untagged::Yes => None, Untagged::Yes => None,
Untagged::No => Some(quote! { Untagged::No => Some(quote! {
#[inline] #[inline]
@@ -869,7 +869,6 @@ fn deserialize_struct_in_place(
fields: &[Field], fields: &[Field],
cattrs: &attr::Container, cattrs: &attr::Container,
deserializer: Option<Tokens>, deserializer: Option<Tokens>,
untagged: Untagged,
) -> Fragment { ) -> Fragment {
let is_enum = variant_ident.is_some(); let is_enum = variant_ident.is_some();
@@ -919,17 +918,13 @@ fn deserialize_struct_in_place(
quote!(mut __seq) quote!(mut __seq)
}; };
// untagged struct variants do not get a visit_seq method let visit_seq = quote! {
let visit_seq = match untagged { #[inline]
Untagged::Yes => None, fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
Untagged::No => Some(quote! { where __A: _serde::de::SeqAccess<#delife>
#[inline] {
fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error> #visit_seq
where __A: _serde::de::SeqAccess<#delife> }
{
#visit_seq
}
}),
}; };
let in_place_impl_generics = de_impl_generics.in_place(); let in_place_impl_generics = de_impl_generics.in_place();
@@ -1014,7 +1009,7 @@ fn deserialize_externally_tagged_enum(
}; };
let variant_visitor = Stmts(deserialize_generated_identifier( let variant_visitor = Stmts(deserialize_generated_identifier(
variant_names_idents, &variant_names_idents,
cattrs, cattrs,
true, true,
)); ));
@@ -1113,7 +1108,7 @@ fn deserialize_internally_tagged_enum(
}; };
let variant_visitor = Stmts(deserialize_generated_identifier( let variant_visitor = Stmts(deserialize_generated_identifier(
variant_names_idents, &variant_names_idents,
cattrs, cattrs,
true, true,
)); ));
@@ -1182,12 +1177,12 @@ fn deserialize_adjacently_tagged_enum(
}; };
let variant_visitor = Stmts(deserialize_generated_identifier( let variant_visitor = Stmts(deserialize_generated_identifier(
variant_names_idents, &variant_names_idents,
cattrs, cattrs,
true, true,
)); ));
let ref variant_arms: Vec<_> = variants let variant_arms: &Vec<_> = &variants
.iter() .iter()
.enumerate() .enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing()) .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
@@ -1495,7 +1490,7 @@ fn deserialize_externally_tagged_variant(
) -> Fragment { ) -> Fragment {
if let Some(path) = variant.attrs.deserialize_with() { if let Some(path) = variant.attrs.deserialize_with() {
let (wrapper, wrapper_ty, unwrap_fn) = let (wrapper, wrapper_ty, unwrap_fn) =
wrap_deserialize_variant_with(params, &variant, path); wrap_deserialize_variant_with(params, variant, path);
return quote_block! { return quote_block! {
#wrapper #wrapper
_serde::export::Result::map( _serde::export::Result::map(
@@ -1525,7 +1520,7 @@ fn deserialize_externally_tagged_variant(
&variant.fields, &variant.fields,
cattrs, cattrs,
None, None,
Untagged::No, &Untagged::No,
), ),
} }
} }
@@ -1556,7 +1551,7 @@ fn deserialize_internally_tagged_variant(
variant_ident, variant_ident,
params, params,
&variant.fields[0], &variant.fields[0],
deserializer, &deserializer,
), ),
Style::Struct => deserialize_struct( Style::Struct => deserialize_struct(
Some(variant_ident), Some(variant_ident),
@@ -1564,7 +1559,7 @@ fn deserialize_internally_tagged_variant(
&variant.fields, &variant.fields,
cattrs, cattrs,
Some(deserializer), Some(deserializer),
Untagged::No, &Untagged::No,
), ),
Style::Tuple => unreachable!("checked in serde_derive_internals"), Style::Tuple => unreachable!("checked in serde_derive_internals"),
} }
@@ -1578,7 +1573,7 @@ fn deserialize_untagged_variant(
) -> Fragment { ) -> Fragment {
if let Some(path) = variant.attrs.deserialize_with() { if let Some(path) = variant.attrs.deserialize_with() {
let (wrapper, wrapper_ty, unwrap_fn) = let (wrapper, wrapper_ty, unwrap_fn) =
wrap_deserialize_variant_with(params, &variant, path); wrap_deserialize_variant_with(params, variant, path);
return quote_block! { return quote_block! {
#wrapper #wrapper
_serde::export::Result::map( _serde::export::Result::map(
@@ -1606,7 +1601,7 @@ fn deserialize_untagged_variant(
variant_ident, variant_ident,
params, params,
&variant.fields[0], &variant.fields[0],
deserializer, &deserializer,
), ),
Style::Tuple => deserialize_tuple( Style::Tuple => deserialize_tuple(
Some(variant_ident), Some(variant_ident),
@@ -1621,7 +1616,7 @@ fn deserialize_untagged_variant(
&variant.fields, &variant.fields,
cattrs, cattrs,
Some(deserializer), Some(deserializer),
Untagged::Yes, &Untagged::Yes,
), ),
} }
} }
@@ -1657,7 +1652,7 @@ fn deserialize_untagged_newtype_variant(
variant_ident: &syn::Ident, variant_ident: &syn::Ident,
params: &Parameters, params: &Parameters,
field: &Field, field: &Field,
deserializer: Tokens, deserializer: &Tokens,
) -> Fragment { ) -> Fragment {
let this = &params.this; let this = &params.this;
match field.attrs.deserialize_with() { match field.attrs.deserialize_with() {
@@ -1682,7 +1677,7 @@ fn deserialize_untagged_newtype_variant(
} }
fn deserialize_generated_identifier( fn deserialize_generated_identifier(
fields: Vec<(String, Ident)>, fields: &[(String, Ident)],
cattrs: &attr::Container, cattrs: &attr::Container,
is_variant: bool, is_variant: bool,
) -> Fragment { ) -> Fragment {
@@ -1698,8 +1693,8 @@ fn deserialize_generated_identifier(
}; };
let visitor_impl = Stmts(deserialize_identifier( let visitor_impl = Stmts(deserialize_identifier(
this, &this,
&fields, fields,
is_variant, is_variant,
fallthrough, fallthrough,
)); ));
@@ -1771,7 +1766,7 @@ fn deserialize_custom_identifier(
.map(|variant| { .map(|variant| {
( (
variant.attrs.name().deserialize_name(), variant.attrs.name().deserialize_name(),
variant.ident.clone(), variant.ident,
) )
}) })
.collect(); .collect();
@@ -1796,7 +1791,7 @@ fn deserialize_custom_identifier(
split_with_de_lifetime(params); split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime(); let delife = params.borrowed.de_lifetime();
let visitor_impl = Stmts(deserialize_identifier( let visitor_impl = Stmts(deserialize_identifier(
this.clone(), &this,
&names_idents, &names_idents,
is_variant, is_variant,
fallthrough, fallthrough,
@@ -1825,7 +1820,7 @@ fn deserialize_custom_identifier(
} }
fn deserialize_identifier( fn deserialize_identifier(
this: Tokens, this: &Tokens,
fields: &[(String, Ident)], fields: &[(String, Ident)],
is_variant: bool, is_variant: bool,
fallthrough: Option<Tokens>, fallthrough: Option<Tokens>,
@@ -1919,7 +1914,7 @@ fn deserialize_identifier(
} }
fn deserialize_struct_visitor( fn deserialize_struct_visitor(
struct_path: Tokens, struct_path: &Tokens,
params: &Parameters, params: &Parameters,
fields: &[Field], fields: &[Field],
cattrs: &attr::Container, cattrs: &attr::Container,
@@ -1938,7 +1933,7 @@ fn deserialize_struct_visitor(
} }
}; };
let field_visitor = deserialize_generated_identifier(field_names_idents, cattrs, false); let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false);
let visit_map = deserialize_map(struct_path, params, fields, cattrs); let visit_map = deserialize_map(struct_path, params, fields, cattrs);
@@ -1946,7 +1941,7 @@ fn deserialize_struct_visitor(
} }
fn deserialize_map( fn deserialize_map(
struct_path: Tokens, struct_path: &Tokens,
params: &Parameters, params: &Parameters,
fields: &[Field], fields: &[Field],
cattrs: &attr::Container, cattrs: &attr::Container,
@@ -2034,7 +2029,7 @@ fn deserialize_map(
.iter() .iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing()) .filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| { .map(|&(field, ref name)| {
let missing_expr = Match(expr_is_missing(&field, cattrs)); let missing_expr = Match(expr_is_missing(field, cattrs));
quote! { quote! {
let #name = match #name { let #name = match #name {
@@ -2045,9 +2040,9 @@ fn deserialize_map(
}); });
let result = fields_names.iter().map(|&(field, ref name)| { let result = fields_names.iter().map(|&(field, ref name)| {
let ident = field.ident.clone().expect("struct contains unnamed fields"); let ident = field.ident.expect("struct contains unnamed fields");
if field.attrs.skip_deserializing() { if field.attrs.skip_deserializing() {
let value = Expr(expr_is_missing(&field, cattrs)); let value = Expr(expr_is_missing(field, cattrs));
quote!(#ident: #value) quote!(#ident: #value)
} else { } else {
quote!(#ident: #name) quote!(#ident: #name)
@@ -2109,7 +2104,7 @@ fn deserialize_struct_in_place_visitor(
} }
}; };
let field_visitor = deserialize_generated_identifier(field_names_idents, cattrs, false); let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false);
let visit_map = deserialize_map_in_place(params, fields, cattrs); let visit_map = deserialize_map_in_place(params, fields, cattrs);
@@ -2206,7 +2201,7 @@ fn deserialize_map_in_place(
.iter() .iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing()) .filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| { .map(|&(field, ref name)| {
let missing_expr = expr_is_missing(&field, cattrs); let missing_expr = expr_is_missing(field, cattrs);
// If missing_expr unconditionally returns an error, don't try // If missing_expr unconditionally returns an error, don't try
// to assign its value to self.place. Maybe this could be handled // to assign its value to self.place. Maybe this could be handled
// more elegantly. // more elegantly.
@@ -2266,7 +2261,7 @@ fn field_i(i: usize) -> Ident {
/// in a trait to prevent it from accessing the internal `Deserialize` state. /// in a trait to prevent it from accessing the internal `Deserialize` state.
fn wrap_deserialize_with( fn wrap_deserialize_with(
params: &Parameters, params: &Parameters,
value_ty: Tokens, value_ty: &Tokens,
deserialize_with: &syn::Path, deserialize_with: &syn::Path,
) -> (Tokens, Tokens) { ) -> (Tokens, Tokens) {
let this = &params.this; let this = &params.this;
@@ -2304,7 +2299,7 @@ fn wrap_deserialize_field_with(
field_ty: &syn::Type, field_ty: &syn::Type,
deserialize_with: &syn::Path, deserialize_with: &syn::Path,
) -> (Tokens, Tokens) { ) -> (Tokens, Tokens) {
wrap_deserialize_with(params, quote!(#field_ty), deserialize_with) wrap_deserialize_with(params, &quote!(#field_ty), deserialize_with)
} }
fn wrap_deserialize_variant_with( fn wrap_deserialize_variant_with(
@@ -2317,7 +2312,7 @@ fn wrap_deserialize_variant_with(
let field_tys = variant.fields.iter().map(|field| field.ty); let field_tys = variant.fields.iter().map(|field| field.ty);
let (wrapper, wrapper_ty) = let (wrapper, wrapper_ty) =
wrap_deserialize_with(params, quote!((#(#field_tys),*)), deserialize_with); wrap_deserialize_with(params, &quote!((#(#field_tys),*)), deserialize_with);
let field_access = (0..variant.fields.len()).map(|n| Member::Unnamed(n.into())); let field_access = (0..variant.fields.len()).map(|n| Member::Unnamed(n.into()));
let unwrap_fn = match variant.style { let unwrap_fn = match variant.style {
@@ -2412,11 +2407,11 @@ impl<'a> ToTokens for InPlaceImplGenerics<'a> {
for param in &mut generics.params { for param in &mut generics.params {
match *param { match *param {
syn::GenericParam::Lifetime(ref mut param) => { syn::GenericParam::Lifetime(ref mut param) => {
param.bounds.push(place_lifetime.lifetime.clone()); param.bounds.push(place_lifetime.lifetime);
} }
syn::GenericParam::Type(ref mut param) => { syn::GenericParam::Type(ref mut param) => {
param.bounds param.bounds
.push(syn::TypeParamBound::Lifetime(place_lifetime.lifetime.clone())); .push(syn::TypeParamBound::Lifetime(place_lifetime.lifetime));
} }
syn::GenericParam::Const(_) => {} syn::GenericParam::Const(_) => {}
} }
@@ -2518,8 +2513,8 @@ fn split_with_de_lifetime(
syn::TypeGenerics, syn::TypeGenerics,
Option<&syn::WhereClause>, Option<&syn::WhereClause>,
) { ) {
let de_impl_generics = DeImplGenerics(&params); let de_impl_generics = DeImplGenerics(params);
let de_ty_generics = DeTypeGenerics(&params); let de_ty_generics = DeTypeGenerics(params);
let (_, ty_generics, where_clause) = params.generics.split_for_impl(); let (_, ty_generics, where_clause) = params.generics.split_for_impl();
(de_impl_generics, de_ty_generics, ty_generics, where_clause) (de_impl_generics, de_ty_generics, ty_generics, where_clause)
} }
serde_derive/src/ser.rs
+37 -38
View File
@@ -103,7 +103,7 @@ impl Parameters {
let this = match cont.attrs.remote() { let this = match cont.attrs.remote() {
Some(remote) => remote.clone(), Some(remote) => remote.clone(),
None => cont.ident.clone().into(), None => cont.ident.into(),
}; };
let generics = build_generics(cont); let generics = build_generics(cont);
@@ -202,9 +202,9 @@ fn serialize_newtype_struct(
) -> Fragment { ) -> Fragment {
let type_name = cattrs.name().serialize_name(); let type_name = cattrs.name().serialize_name();
let mut field_expr = get_member(params, field, Member::Unnamed(0.into())); let mut field_expr = get_member(params, field, &Member::Unnamed(0.into()));
if let Some(path) = field.attrs.serialize_with() { if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
} }
quote_expr! { quote_expr! {
@@ -221,7 +221,7 @@ fn serialize_tuple_struct(
fields, fields,
params, params,
false, false,
quote!(_serde::ser::SerializeTupleStruct::serialize_field), &quote!(_serde::ser::SerializeTupleStruct::serialize_field),
); );
let type_name = cattrs.name().serialize_name(); let type_name = cattrs.name().serialize_name();
@@ -236,14 +236,14 @@ fn serialize_tuple_struct(
} }
fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment { fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment {
assert!(fields.len() as u64 <= u32::MAX as u64); assert!(fields.len() as u64 <= u64::from(u32::MAX));
let serialize_fields = serialize_struct_visitor( let serialize_fields = serialize_struct_visitor(
fields, fields,
params, params,
false, false,
quote!(_serde::ser::SerializeStruct::serialize_field), &quote!(_serde::ser::SerializeStruct::serialize_field),
quote!(_serde::ser::SerializeStruct::skip_field), &quote!(_serde::ser::SerializeStruct::skip_field),
); );
let type_name = cattrs.name().serialize_name(); let type_name = cattrs.name().serialize_name();
@@ -259,8 +259,8 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
.map(|field| match field.attrs.skip_serializing_if() { .map(|field| match field.attrs.skip_serializing_if() {
None => quote!(1), None => quote!(1),
Some(path) => { Some(path) => {
let ident = field.ident.clone().expect("struct has unnamed fields"); let ident = field.ident.expect("struct has unnamed fields");
let field_expr = get_member(params, field, Member::Named(ident)); let field_expr = get_member(params, field, &Member::Named(ident));
quote!(if #path(#field_expr) { 0 } else { 1 }) quote!(if #path(#field_expr) { 0 } else { 1 })
} }
}) })
@@ -274,7 +274,7 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
} }
fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Container) -> Fragment { fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Container) -> Fragment {
assert!(variants.len() as u64 <= u32::MAX as u64); assert!(variants.len() as u64 <= u64::from(u32::MAX));
let self_var = &params.self_var; let self_var = &params.self_var;
@@ -300,7 +300,7 @@ fn serialize_variant(
cattrs: &attr::Container, cattrs: &attr::Container,
) -> Tokens { ) -> Tokens {
let this = &params.this; let this = &params.this;
let variant_ident = variant.ident.clone(); let variant_ident = variant.ident;
if variant.attrs.skip_serializing() { if variant.attrs.skip_serializing() {
let skipped_msg = format!( let skipped_msg = format!(
@@ -343,7 +343,7 @@ fn serialize_variant(
let fields = variant let fields = variant
.fields .fields
.iter() .iter()
.map(|f| f.ident.clone().expect("struct variant has unnamed fields")); .map(|f| f.ident.expect("struct variant has unnamed fields"));
quote! { quote! {
#this::#variant_ident { #(ref #fields),* } #this::#variant_ident { #(ref #fields),* }
} }
@@ -380,7 +380,7 @@ fn serialize_externally_tagged_variant(
let variant_name = variant.attrs.name().serialize_name(); let variant_name = variant.attrs.name().serialize_name();
if let Some(path) = variant.attrs.serialize_with() { if let Some(path) = variant.attrs.serialize_with() {
let ser = wrap_serialize_variant_with(params, path, &variant); let ser = wrap_serialize_variant_with(params, path, variant);
return quote_expr! { return quote_expr! {
_serde::Serializer::serialize_newtype_variant( _serde::Serializer::serialize_newtype_variant(
__serializer, __serializer,
@@ -407,7 +407,7 @@ fn serialize_externally_tagged_variant(
let field = &variant.fields[0]; let field = &variant.fields[0];
let mut field_expr = quote!(__field0); let mut field_expr = quote!(__field0);
if let Some(path) = field.attrs.serialize_with() { if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
} }
quote_expr! { quote_expr! {
@@ -454,7 +454,7 @@ fn serialize_internally_tagged_variant(
let variant_ident_str = variant.ident.as_ref(); let variant_ident_str = variant.ident.as_ref();
if let Some(path) = variant.attrs.serialize_with() { if let Some(path) = variant.attrs.serialize_with() {
let ser = wrap_serialize_variant_with(params, path, &variant); let ser = wrap_serialize_variant_with(params, path, variant);
return quote_expr! { return quote_expr! {
_serde::private::ser::serialize_tagged_newtype( _serde::private::ser::serialize_tagged_newtype(
__serializer, __serializer,
@@ -481,7 +481,7 @@ fn serialize_internally_tagged_variant(
let field = &variant.fields[0]; let field = &variant.fields[0];
let mut field_expr = quote!(__field0); let mut field_expr = quote!(__field0);
if let Some(path) = field.attrs.serialize_with() { if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
} }
quote_expr! { quote_expr! {
@@ -520,7 +520,7 @@ fn serialize_adjacently_tagged_variant(
let variant_name = variant.attrs.name().serialize_name(); let variant_name = variant.attrs.name().serialize_name();
let inner = Stmts(if let Some(path) = variant.attrs.serialize_with() { let inner = Stmts(if let Some(path) = variant.attrs.serialize_with() {
let ser = wrap_serialize_variant_with(params, path, &variant); let ser = wrap_serialize_variant_with(params, path, variant);
quote_expr! { quote_expr! {
_serde::Serialize::serialize(#ser, __serializer) _serde::Serialize::serialize(#ser, __serializer)
} }
@@ -539,7 +539,7 @@ fn serialize_adjacently_tagged_variant(
let field = &variant.fields[0]; let field = &variant.fields[0];
let mut field_expr = quote!(__field0); let mut field_expr = quote!(__field0);
if let Some(path) = field.attrs.serialize_with() { if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
} }
quote_expr! { quote_expr! {
@@ -559,7 +559,7 @@ fn serialize_adjacently_tagged_variant(
}); });
let fields_ty = variant.fields.iter().map(|f| &f.ty); let fields_ty = variant.fields.iter().map(|f| &f.ty);
let ref fields_ident: Vec<_> = match variant.style { let fields_ident: &Vec<_> = &match variant.style {
Style::Unit => { Style::Unit => {
if variant.attrs.serialize_with().is_some() { if variant.attrs.serialize_with().is_some() {
vec![] vec![]
@@ -574,7 +574,7 @@ fn serialize_adjacently_tagged_variant(
Style::Struct => variant Style::Struct => variant
.fields .fields
.iter() .iter()
.map(|f| f.ident.clone().expect("struct variant has unnamed fields")) .map(|f| f.ident.expect("struct variant has unnamed fields"))
.collect(), .collect(),
}; };
@@ -621,7 +621,7 @@ fn serialize_untagged_variant(
cattrs: &attr::Container, cattrs: &attr::Container,
) -> Fragment { ) -> Fragment {
if let Some(path) = variant.attrs.serialize_with() { if let Some(path) = variant.attrs.serialize_with() {
let ser = wrap_serialize_variant_with(params, path, &variant); let ser = wrap_serialize_variant_with(params, path, variant);
return quote_expr! { return quote_expr! {
_serde::Serialize::serialize(#ser, __serializer) _serde::Serialize::serialize(#ser, __serializer)
}; };
@@ -637,7 +637,7 @@ fn serialize_untagged_variant(
let field = &variant.fields[0]; let field = &variant.fields[0];
let mut field_expr = quote!(__field0); let mut field_expr = quote!(__field0);
if let Some(path) = field.attrs.serialize_with() { if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
} }
quote_expr! { quote_expr! {
@@ -673,7 +673,7 @@ fn serialize_tuple_variant(
TupleVariant::Untagged => quote!(_serde::ser::SerializeTuple::serialize_element), 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 len = serialize_stmts.len();
let let_mut = mut_if(len > 0); let let_mut = mut_if(len > 0);
@@ -736,7 +736,7 @@ fn serialize_struct_variant<'a>(
), ),
}; };
let serialize_fields = serialize_struct_visitor(fields, params, true, method, skip_method); let serialize_fields = serialize_struct_visitor(fields, params, true, &method, &skip_method);
let mut serialized_fields = fields let mut serialized_fields = fields
.iter() .iter()
@@ -747,7 +747,7 @@ fn serialize_struct_variant<'a>(
let len = serialized_fields let len = serialized_fields
.map(|field| { .map(|field| {
let ident = field.ident.clone().expect("struct has unnamed fields"); let ident = field.ident.expect("struct has unnamed fields");
match field.attrs.skip_serializing_if() { match field.attrs.skip_serializing_if() {
Some(path) => quote!(if #path(#ident) { 0 } else { 1 }), Some(path) => quote!(if #path(#ident) { 0 } else { 1 }),
@@ -807,7 +807,7 @@ fn serialize_tuple_struct_visitor(
fields: &[Field], fields: &[Field],
params: &Parameters, params: &Parameters,
is_enum: bool, is_enum: bool,
func: Tokens, func: &Tokens,
) -> Vec<Tokens> { ) -> Vec<Tokens> {
fields fields
.iter() .iter()
@@ -817,7 +817,7 @@ fn serialize_tuple_struct_visitor(
let id = Ident::new(&format!("__field{}", i), Span::def_site()); let id = Ident::new(&format!("__field{}", i), Span::def_site());
quote!(#id) quote!(#id)
} else { } else {
get_member(params, field, Member::Unnamed(i.into())) get_member(params, field, &Member::Unnamed(i.into()))
}; };
let skip = field let skip = field
@@ -826,7 +826,7 @@ fn serialize_tuple_struct_visitor(
.map(|path| quote!(#path(#field_expr))); .map(|path| quote!(#path(#field_expr)));
if let Some(path) = field.attrs.serialize_with() { if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
} }
let ser = quote! { let ser = quote! {
@@ -845,18 +845,18 @@ fn serialize_struct_visitor(
fields: &[Field], fields: &[Field],
params: &Parameters, params: &Parameters,
is_enum: bool, is_enum: bool,
func: Tokens, func: &Tokens,
skip_func: Tokens, skip_func: &Tokens,
) -> Vec<Tokens> { ) -> Vec<Tokens> {
fields fields
.iter() .iter()
.filter(|&field| !field.attrs.skip_serializing()) .filter(|&field| !field.attrs.skip_serializing())
.map(|field| { .map(|field| {
let field_ident = field.ident.clone().expect("struct has unnamed field"); let field_ident = field.ident.expect("struct has unnamed field");
let mut field_expr = if is_enum { let mut field_expr = if is_enum {
quote!(#field_ident) quote!(#field_ident)
} else { } else {
get_member(params, field, Member::Named(field_ident)) get_member(params, field, &Member::Named(field_ident))
}; };
let key_expr = field.attrs.name().serialize_name(); let key_expr = field.attrs.name().serialize_name();
@@ -867,7 +867,7 @@ fn serialize_struct_visitor(
.map(|path| quote!(#path(#field_expr))); .map(|path| quote!(#path(#field_expr)));
if let Some(path) = field.attrs.serialize_with() { if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
} }
let ser = quote! { let ser = quote! {
@@ -894,7 +894,7 @@ fn wrap_serialize_field_with(
params: &Parameters, params: &Parameters,
field_ty: &syn::Type, field_ty: &syn::Type,
serialize_with: &syn::Path, serialize_with: &syn::Path,
field_expr: Tokens, field_expr: &Tokens,
) -> Tokens { ) -> Tokens {
wrap_serialize_with(params, serialize_with, &[field_ty], &[quote!(#field_expr)]) wrap_serialize_with(params, serialize_with, &[field_ty], &[quote!(#field_expr)])
} }
@@ -912,8 +912,7 @@ fn wrap_serialize_variant_with(
.map(|(i, field)| { .map(|(i, field)| {
let id = field let id = field
.ident .ident
.as_ref() .unwrap_or_else(|| Ident::new(&format!("__field{}", i), Span::def_site()));
.map_or_else(|| Ident::new(&format!("__field{}", i), Span::def_site()), |id| id.clone());
quote!(#id) quote!(#id)
}) })
.collect(); .collect();
@@ -934,7 +933,7 @@ fn wrap_serialize_with(
let this = &params.this; let this = &params.this;
let (_, ty_generics, where_clause) = params.generics.split_for_impl(); let (_, ty_generics, where_clause) = params.generics.split_for_impl();
let wrapper_generics = if field_exprs.len() == 0 { let wrapper_generics = if field_exprs.is_empty() {
params.generics.clone() params.generics.clone()
} else { } else {
bound::with_lifetime_bound(&params.generics, "'__a") bound::with_lifetime_bound(&params.generics, "'__a")
@@ -978,7 +977,7 @@ fn mut_if(is_mut: bool) -> Option<Tokens> {
} }
} }
fn get_member(params: &Parameters, field: &Field, member: Member) -> Tokens { fn get_member(params: &Parameters, field: &Field, member: &Member) -> Tokens {
let self_var = &params.self_var; let self_var = &params.self_var;
match (params.is_remote, field.attrs.getter()) { match (params.is_remote, field.attrs.getter()) {
(false, None) => { (false, None) => {