mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions 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
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
3 changed files with 88 additions and 94 deletions
serde_derive/src
bound.rsde.rsser.rs

4
serde_derive/src/bound.rs

@ -125,7 +125,7 @@ where
}
}
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) {
self.relevant_ty_params.insert(id);
}
@ -289,7 +289,7 @@ fn type_of_item(cont: &Container) -> syn::Type {
leading_colon: None,
segments: vec![
syn::PathSegment {
ident: cont.ident.clone(),
ident: cont.ident,
arguments: syn::PathArguments::AngleBracketed(
syn::AngleBracketedGenericArguments {
colon2_token: None,

103
serde_derive/src/de.rs

@ -91,10 +91,10 @@ struct Parameters {
impl Parameters {
fn new(cont: &Container) -> Self {
let local = cont.ident.clone();
let local = cont.ident;
let this = match cont.attrs.remote() {
Some(remote) => remote.clone(),
None => cont.ident.clone().into(),
None => cont.ident.into(),
};
let borrowed = borrowed_lifetimes(cont);
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()) {
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) => {
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 {
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) => {
deserialize_tuple_in_place(None, params, fields, &cont.attrs, None)
@ -529,7 +529,7 @@ fn deserialize_seq(
let mut index_in_seq = 0usize;
let let_values = vars.clone().zip(fields).map(|(var, field)| {
if field.attrs.skip_deserializing() {
let default = Expr(expr_is_missing(&field, cattrs));
let default = Expr(expr_is_missing(field, cattrs));
quote! {
let #var = #default;
}
@ -627,7 +627,7 @@ fn deserialize_seq_in_place(
.unwrap_or_else(|| Member::Unnamed(field_index.into()));
if field.attrs.skip_deserializing() {
let default = Expr(expr_is_missing(&field, cattrs));
let default = Expr(expr_is_missing(field, cattrs));
quote! {
self.place.#field_name = #default;
}
@ -754,7 +754,7 @@ fn deserialize_struct(
fields: &[Field],
cattrs: &attr::Container,
deserializer: Option<Tokens>,
untagged: Untagged,
untagged: &Untagged,
) -> Fragment {
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 (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 fields_stmt = Stmts(fields_stmt);
let visit_map = Stmts(visit_map);
@ -819,7 +819,7 @@ fn deserialize_struct(
};
// untagged struct variants do not get a visit_seq method
let visit_seq = match untagged {
let visit_seq = match *untagged {
Untagged::Yes => None,
Untagged::No => Some(quote! {
#[inline]
@ -869,7 +869,6 @@ fn deserialize_struct_in_place(
fields: &[Field],
cattrs: &attr::Container,
deserializer: Option<Tokens>,
untagged: Untagged,
) -> Fragment {
let is_enum = variant_ident.is_some();
@ -919,17 +918,13 @@ fn deserialize_struct_in_place(
quote!(mut __seq)
};
// untagged struct variants do not get a visit_seq method
let visit_seq = match untagged {
Untagged::Yes => None,
Untagged::No => Some(quote! {
#[inline]
fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
where __A: _serde::de::SeqAccess<#delife>
{
#visit_seq
}
}),
let visit_seq = quote! {
#[inline]
fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
where __A: _serde::de::SeqAccess<#delife>
{
#visit_seq
}
};
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(
variant_names_idents,
&variant_names_idents,
cattrs,
true,
));
@ -1113,7 +1108,7 @@ fn deserialize_internally_tagged_enum(
};
let variant_visitor = Stmts(deserialize_generated_identifier(
variant_names_idents,
&variant_names_idents,
cattrs,
true,
));
@ -1182,12 +1177,12 @@ fn deserialize_adjacently_tagged_enum(
};
let variant_visitor = Stmts(deserialize_generated_identifier(
variant_names_idents,
&variant_names_idents,
cattrs,
true,
));
let ref variant_arms: Vec<_> = variants
let variant_arms: &Vec<_> = &variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
@ -1495,7 +1490,7 @@ fn deserialize_externally_tagged_variant(
) -> Fragment {
if let Some(path) = variant.attrs.deserialize_with() {
let (wrapper, wrapper_ty, unwrap_fn) =
wrap_deserialize_variant_with(params, &variant, path);
wrap_deserialize_variant_with(params, variant, path);
return quote_block! {
#wrapper
_serde::export::Result::map(
@ -1525,7 +1520,7 @@ fn deserialize_externally_tagged_variant(
&variant.fields,
cattrs,
None,
Untagged::No,
&Untagged::No,
),
}
}
@ -1556,7 +1551,7 @@ fn deserialize_internally_tagged_variant(
variant_ident,
params,
&variant.fields[0],
deserializer,
&deserializer,
),
Style::Struct => deserialize_struct(
Some(variant_ident),
@ -1564,7 +1559,7 @@ fn deserialize_internally_tagged_variant(
&variant.fields,
cattrs,
Some(deserializer),
Untagged::No,
&Untagged::No,
),
Style::Tuple => unreachable!("checked in serde_derive_internals"),
}
@ -1578,7 +1573,7 @@ fn deserialize_untagged_variant(
) -> Fragment {
if let Some(path) = variant.attrs.deserialize_with() {
let (wrapper, wrapper_ty, unwrap_fn) =
wrap_deserialize_variant_with(params, &variant, path);
wrap_deserialize_variant_with(params, variant, path);
return quote_block! {
#wrapper
_serde::export::Result::map(
@ -1606,7 +1601,7 @@ fn deserialize_untagged_variant(
variant_ident,
params,
&variant.fields[0],
deserializer,
&deserializer,
),
Style::Tuple => deserialize_tuple(
Some(variant_ident),
@ -1621,7 +1616,7 @@ fn deserialize_untagged_variant(
&variant.fields,
cattrs,
Some(deserializer),
Untagged::Yes,
&Untagged::Yes,
),
}
}
@ -1657,7 +1652,7 @@ fn deserialize_untagged_newtype_variant(
variant_ident: &syn::Ident,
params: &Parameters,
field: &Field,
deserializer: Tokens,
deserializer: &Tokens,
) -> Fragment {
let this = &params.this;
match field.attrs.deserialize_with() {
@ -1682,7 +1677,7 @@ fn deserialize_untagged_newtype_variant(
}
fn deserialize_generated_identifier(
fields: Vec<(String, Ident)>,
fields: &[(String, Ident)],
cattrs: &attr::Container,
is_variant: bool,
) -> Fragment {
@ -1698,8 +1693,8 @@ fn deserialize_generated_identifier(
};
let visitor_impl = Stmts(deserialize_identifier(
this,
&fields,
&this,
fields,
is_variant,
fallthrough,
));
@ -1771,7 +1766,7 @@ fn deserialize_custom_identifier(
.map(|variant| {
(
variant.attrs.name().deserialize_name(),
variant.ident.clone(),
variant.ident,
)
})
.collect();
@ -1796,7 +1791,7 @@ fn deserialize_custom_identifier(
split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime();
let visitor_impl = Stmts(deserialize_identifier(
this.clone(),
&this,
&names_idents,
is_variant,
fallthrough,
@ -1825,7 +1820,7 @@ fn deserialize_custom_identifier(
}
fn deserialize_identifier(
this: Tokens,
this: &Tokens,
fields: &[(String, Ident)],
is_variant: bool,
fallthrough: Option<Tokens>,
@ -1919,7 +1914,7 @@ fn deserialize_identifier(
}
fn deserialize_struct_visitor(
struct_path: Tokens,
struct_path: &Tokens,
params: &Parameters,
fields: &[Field],
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);
@ -1946,7 +1941,7 @@ fn deserialize_struct_visitor(
}
fn deserialize_map(
struct_path: Tokens,
struct_path: &Tokens,
params: &Parameters,
fields: &[Field],
cattrs: &attr::Container,
@ -2034,7 +2029,7 @@ fn deserialize_map(
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| {
let missing_expr = Match(expr_is_missing(&field, cattrs));
let missing_expr = Match(expr_is_missing(field, cattrs));
quote! {
let #name = match #name {
@ -2045,9 +2040,9 @@ fn deserialize_map(
});
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() {
let value = Expr(expr_is_missing(&field, cattrs));
let value = Expr(expr_is_missing(field, cattrs));
quote!(#ident: #value)
} else {
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);
@ -2206,7 +2201,7 @@ fn deserialize_map_in_place(
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.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
// to assign its value to self.place. Maybe this could be handled
// more elegantly.
@ -2266,7 +2261,7 @@ fn field_i(i: usize) -> Ident {
/// in a trait to prevent it from accessing the internal `Deserialize` state.
fn wrap_deserialize_with(
params: &Parameters,
value_ty: Tokens,
value_ty: &Tokens,
deserialize_with: &syn::Path,
) -> (Tokens, Tokens) {
let this = &params.this;
@ -2304,7 +2299,7 @@ fn wrap_deserialize_field_with(
field_ty: &syn::Type,
deserialize_with: &syn::Path,
) -> (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(
@ -2317,7 +2312,7 @@ fn wrap_deserialize_variant_with(
let field_tys = variant.fields.iter().map(|field| field.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 unwrap_fn = match variant.style {
@ -2412,11 +2407,11 @@ impl<'a> ToTokens for InPlaceImplGenerics<'a> {
for param in &mut generics.params {
match *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) => {
param.bounds
.push(syn::TypeParamBound::Lifetime(place_lifetime.lifetime.clone()));
.push(syn::TypeParamBound::Lifetime(place_lifetime.lifetime));
}
syn::GenericParam::Const(_) => {}
}
@ -2518,8 +2513,8 @@ fn split_with_de_lifetime(
syn::TypeGenerics,
Option<&syn::WhereClause>,
) {
let de_impl_generics = DeImplGenerics(&params);
let de_ty_generics = DeTypeGenerics(&params);
let de_impl_generics = DeImplGenerics(params);
let de_ty_generics = DeTypeGenerics(params);
let (_, ty_generics, where_clause) = params.generics.split_for_impl();
(de_impl_generics, de_ty_generics, ty_generics, where_clause)
}

75
serde_derive/src/ser.rs

@ -103,7 +103,7 @@ impl Parameters {
let this = match cont.attrs.remote() {
Some(remote) => remote.clone(),
None => cont.ident.clone().into(),
None => cont.ident.into(),
};
let generics = build_generics(cont);
@ -202,9 +202,9 @@ fn serialize_newtype_struct(
) -> Fragment {
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() {
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! {
@ -221,7 +221,7 @@ fn serialize_tuple_struct(
fields,
params,
false,
quote!(_serde::ser::SerializeTupleStruct::serialize_field),
&quote!(_serde::ser::SerializeTupleStruct::serialize_field),
);
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 {
assert!(fields.len() as u64 <= u32::MAX as u64);
assert!(fields.len() as u64 <= u64::from(u32::MAX));
let serialize_fields = serialize_struct_visitor(
fields,
params,
false,
quote!(_serde::ser::SerializeStruct::serialize_field),
quote!(_serde::ser::SerializeStruct::skip_field),
&quote!(_serde::ser::SerializeStruct::serialize_field),
&quote!(_serde::ser::SerializeStruct::skip_field),
);
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() {
None => quote!(1),
Some(path) => {
let ident = field.ident.clone().expect("struct has unnamed fields");
let field_expr = get_member(params, field, Member::Named(ident));
let ident = field.ident.expect("struct has unnamed fields");
let field_expr = get_member(params, field, &Member::Named(ident));
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 {
assert!(variants.len() as u64 <= u32::MAX as u64);
assert!(variants.len() as u64 <= u64::from(u32::MAX));
let self_var = &params.self_var;
@ -300,7 +300,7 @@ fn serialize_variant(
cattrs: &attr::Container,
) -> Tokens {
let this = &params.this;
let variant_ident = variant.ident.clone();
let variant_ident = variant.ident;
if variant.attrs.skip_serializing() {
let skipped_msg = format!(
@ -343,7 +343,7 @@ fn serialize_variant(
let fields = variant
.fields
.iter()
.map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
.map(|f| f.ident.expect("struct variant has unnamed fields"));
quote! {
#this::#variant_ident { #(ref #fields),* }
}
@ -380,7 +380,7 @@ fn serialize_externally_tagged_variant(
let variant_name = variant.attrs.name().serialize_name();
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! {
_serde::Serializer::serialize_newtype_variant(
__serializer,
@ -407,7 +407,7 @@ fn serialize_externally_tagged_variant(
let field = &variant.fields[0];
let mut field_expr = quote!(__field0);
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! {
@ -454,7 +454,7 @@ fn serialize_internally_tagged_variant(
let variant_ident_str = variant.ident.as_ref();
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! {
_serde::private::ser::serialize_tagged_newtype(
__serializer,
@ -481,7 +481,7 @@ fn serialize_internally_tagged_variant(
let field = &variant.fields[0];
let mut field_expr = quote!(__field0);
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! {
@ -520,7 +520,7 @@ fn serialize_adjacently_tagged_variant(
let variant_name = variant.attrs.name().serialize_name();
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! {
_serde::Serialize::serialize(#ser, __serializer)
}
@ -539,7 +539,7 @@ fn serialize_adjacently_tagged_variant(
let field = &variant.fields[0];
let mut field_expr = quote!(__field0);
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! {
@ -559,7 +559,7 @@ fn serialize_adjacently_tagged_variant(
});
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 => {
if variant.attrs.serialize_with().is_some() {
vec![]
@ -574,7 +574,7 @@ fn serialize_adjacently_tagged_variant(
Style::Struct => variant
.fields
.iter()
.map(|f| f.ident.clone().expect("struct variant has unnamed fields"))
.map(|f| f.ident.expect("struct variant has unnamed fields"))
.collect(),
};
@ -621,7 +621,7 @@ fn serialize_untagged_variant(
cattrs: &attr::Container,
) -> Fragment {
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! {
_serde::Serialize::serialize(#ser, __serializer)
};
@ -637,7 +637,7 @@ fn serialize_untagged_variant(
let field = &variant.fields[0];
let mut field_expr = quote!(__field0);
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! {
@ -673,7 +673,7 @@ fn serialize_tuple_variant(
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);
@ -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
.iter()
@ -747,7 +747,7 @@ fn serialize_struct_variant<'a>(
let len = serialized_fields
.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() {
Some(path) => quote!(if #path(#ident) { 0 } else { 1 }),
@ -807,7 +807,7 @@ fn serialize_tuple_struct_visitor(
fields: &[Field],
params: &Parameters,
is_enum: bool,
func: Tokens,
func: &Tokens,
) -> Vec<Tokens> {
fields
.iter()
@ -817,7 +817,7 @@ fn serialize_tuple_struct_visitor(
let id = Ident::new(&format!("__field{}", i), Span::def_site());
quote!(#id)
} else {
get_member(params, field, Member::Unnamed(i.into()))
get_member(params, field, &Member::Unnamed(i.into()))
};
let skip = field
@ -826,7 +826,7 @@ fn serialize_tuple_struct_visitor(
.map(|path| quote!(#path(#field_expr)));
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! {
@ -845,18 +845,18 @@ fn serialize_struct_visitor(
fields: &[Field],
params: &Parameters,
is_enum: bool,
func: Tokens,
skip_func: Tokens,
func: &Tokens,
skip_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 field_ident = field.ident.expect("struct has unnamed field");
let mut field_expr = if is_enum {
quote!(#field_ident)
} 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();
@ -867,7 +867,7 @@ fn serialize_struct_visitor(
.map(|path| quote!(#path(#field_expr)));
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! {
@ -894,7 +894,7 @@ fn wrap_serialize_field_with(
params: &Parameters,
field_ty: &syn::Type,
serialize_with: &syn::Path,
field_expr: Tokens,
field_expr: &Tokens,
) -> Tokens {
wrap_serialize_with(params, serialize_with, &[field_ty], &[quote!(#field_expr)])
}
@ -912,8 +912,7 @@ fn wrap_serialize_variant_with(
.map(|(i, field)| {
let id = field
.ident
.as_ref()
.map_or_else(|| Ident::new(&format!("__field{}", i), Span::def_site()), |id| id.clone());
.unwrap_or_else(|| Ident::new(&format!("__field{}", i), Span::def_site()));
quote!(#id)
})
.collect();
@ -934,7 +933,7 @@ fn wrap_serialize_with(
let this = &params.this;
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()
} else {
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;
match (params.is_remote, field.attrs.getter()) {
(false, None) => {