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

Remove use of ref keyword from serde_derive

Browse Source
This commit is contained in:
David Tolnay
2019-09-07 23:01:16 -07:00
parent e46463e69f
commit b24d50160a
8 changed files with 283 additions and 334 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_derive/src/bound.rs
+15 -15
View File
@@ -17,8 +17,8 @@ pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
params: generics
.params
.iter()
.map(|param| match *param {
syn::GenericParam::Type(ref param) => syn::GenericParam::Type(syn::TypeParam {
.map(|param| match param {
syn::GenericParam::Type(param) => syn::GenericParam::Type(syn::TypeParam {
eq_token: None,
default: None,
..param.clone()
@@ -63,8 +63,8 @@ pub fn with_where_predicates_from_variants(
generics: &syn::Generics,
from_variant: fn(&attr::Variant) -> Option<&[syn::WherePredicate]>,
) -> syn::Generics {
let variants = match cont.data {
Data::Enum(ref variants) => variants,
let variants = match &cont.data {
Data::Enum(variants) => variants,
Data::Struct(_, _) => {
return generics.clone();
}
@@ -114,8 +114,8 @@ pub fn with_bound(
}
impl<'ast> Visit<'ast> for FindTyParams<'ast> {
fn visit_field(&mut self, field: &'ast syn::Field) {
if let syn::Type::Path(ref ty) = field.ty {
if let Some(Pair::Punctuated(ref t, _)) = ty.path.segments.pairs().next() {
if let syn::Type::Path(ty) = &field.ty {
if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
if self.all_type_params.contains(&t.ident) {
self.associated_type_usage.push(ty);
}
@@ -160,8 +160,8 @@ pub fn with_bound(
relevant_type_params: HashSet::new(),
associated_type_usage: Vec::new(),
};
match cont.data {
Data::Enum(ref variants) => {
match &cont.data {
Data::Enum(variants) => {
for variant in variants.iter() {
let relevant_fields = variant
.fields
@@ -172,7 +172,7 @@ pub fn with_bound(
}
}
}
Data::Struct(_, ref fields) => {
Data::Struct(_, fields) => {
for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
visitor.visit_field(field.original);
}
@@ -255,11 +255,11 @@ pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Gen
let params = Some(syn::GenericParam::Lifetime(def))
.into_iter()
.chain(generics.params.iter().cloned().map(|mut param| {
match param {
syn::GenericParam::Lifetime(ref mut param) => {
match &mut param {
syn::GenericParam::Lifetime(param) => {
param.bounds.push(bound.clone());
}
syn::GenericParam::Type(ref mut param) => {
syn::GenericParam::Type(param) => {
param
.bounds
.push(syn::TypeParamBound::Lifetime(bound.clone()));
@@ -291,14 +291,14 @@ fn type_of_item(cont: &Container) -> syn::Type {
.generics
.params
.iter()
.map(|param| match *param {
syn::GenericParam::Type(ref param) => {
.map(|param| match param {
syn::GenericParam::Type(param) => {
syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
qself: None,
path: param.ident.clone().into(),
}))
}
syn::GenericParam::Lifetime(ref param) => {
syn::GenericParam::Lifetime(param) => {
syn::GenericArgument::Lifetime(param.lifetime.clone())
}
syn::GenericParam::Const(_) => {
serde_derive/src/de.rs
+61 -66
View File
@@ -75,7 +75,7 @@ fn precondition(cx: &Ctxt, cont: &Container) {
}
fn precondition_sized(cx: &Ctxt, cont: &Container) {
if let Data::Struct(_, ref fields) = cont.data {
if let Data::Struct(_, fields) = &cont.data {
if let Some(last) = fields.last() {
if let syn::Type::Slice(_) = *last.ty {
cx.error_spanned_by(
@@ -229,8 +229,8 @@ impl BorrowedLifetimes {
}
fn de_lifetime_def(&self) -> Option<syn::LifetimeDef> {
match *self {
BorrowedLifetimes::Borrowed(ref bounds) => Some(syn::LifetimeDef {
match self {
BorrowedLifetimes::Borrowed(bounds) => Some(syn::LifetimeDef {
attrs: Vec::new(),
lifetime: syn::Lifetime::new("'de", Span::call_site()),
colon_token: None,
@@ -272,21 +272,19 @@ fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
} else if let Some(type_try_from) = cont.attrs.type_try_from() {
deserialize_try_from(type_try_from)
} else if let attr::Identifier::No = cont.attrs.identifier() {
match cont.data {
Data::Enum(ref variants) => deserialize_enum(params, variants, &cont.attrs),
Data::Struct(Style::Struct, ref fields) => {
match &cont.data {
Data::Enum(variants) => deserialize_enum(params, variants, &cont.attrs),
Data::Struct(Style::Struct, fields) => {
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, fields) | Data::Struct(Style::Newtype, fields) => {
deserialize_tuple(None, params, fields, &cont.attrs, None)
}
Data::Struct(Style::Unit, _) => deserialize_unit_struct(params, &cont.attrs),
}
} else {
match cont.data {
Data::Enum(ref variants) => {
deserialize_custom_identifier(params, variants, &cont.attrs)
}
match &cont.data {
Data::Enum(variants) => deserialize_custom_identifier(params, variants, &cont.attrs),
Data::Struct(_, _) => unreachable!("checked in serde_derive_internals"),
}
}
@@ -310,8 +308,8 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
return None;
}
let code = match cont.data {
Data::Struct(Style::Struct, ref fields) => {
let code = match &cont.data {
Data::Struct(Style::Struct, fields) => {
if let Some(code) = deserialize_struct_in_place(None, params, fields, &cont.attrs, None)
{
code
@@ -319,7 +317,7 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
return None;
}
}
Data::Struct(Style::Tuple, ref fields) | Data::Struct(Style::Newtype, ref fields) => {
Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
deserialize_tuple_in_place(None, params, fields, &cont.attrs, None)
}
Data::Enum(_) | Data::Struct(Style::Unit, _) => {
@@ -348,8 +346,8 @@ fn deserialize_in_place_body(_cont: &Container, _params: &Parameters) -> Option<
}
fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
let fields = match cont.data {
Data::Struct(_, ref fields) => fields,
let fields = match &cont.data {
Data::Struct(_, fields) => fields,
Data::Enum(_) => unreachable!(),
};
@@ -369,9 +367,9 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
if field as *const Field == transparent_field as *const Field {
quote!(#member: __transparent)
} else {
let value = match *field.attrs.default() {
let value = match field.attrs.default() {
attr::Default::Default => quote!(_serde::export::Default::default()),
attr::Default::Path(ref path) => quote!(#path()),
attr::Default::Path(path) => quote!(#path()),
attr::Default::None => quote!(_serde::export::PhantomData),
};
quote!(#member: #value)
@@ -456,7 +454,7 @@ fn deserialize_tuple(
let is_enum = variant_ident.is_some();
let type_path = match variant_ident {
Some(ref variant_ident) => quote!(#construct::#variant_ident),
Some(variant_ident) => quote!(#construct::#variant_ident),
None => construct,
};
let expecting = match variant_ident {
@@ -664,9 +662,9 @@ fn deserialize_seq(
})
}
};
let value_if_none = match *field.attrs.default() {
let value_if_none = match field.attrs.default() {
attr::Default::Default => quote!(_serde::export::Default::default()),
attr::Default::Path(ref path) => quote!(#path()),
attr::Default::Path(path) => quote!(#path()),
attr::Default::None => quote!(
return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
),
@@ -702,11 +700,11 @@ fn deserialize_seq(
};
}
let let_default = match *cattrs.default() {
let let_default = match cattrs.default() {
attr::Default::Default => Some(quote!(
let __default: Self::Value = _serde::export::Default::default();
)),
attr::Default::Path(ref path) => Some(quote!(
attr::Default::Path(path) => Some(quote!(
let __default: Self::Value = #path();
)),
attr::Default::None => {
@@ -750,11 +748,11 @@ fn deserialize_seq_in_place(
self.place.#member = #default;
}
} else {
let value_if_none = match *field.attrs.default() {
let value_if_none = match field.attrs.default() {
attr::Default::Default => quote!(
self.place.#member = _serde::export::Default::default();
),
attr::Default::Path(ref path) => quote!(
attr::Default::Path(path) => quote!(
self.place.#member = #path();
),
attr::Default::None => quote!(
@@ -793,11 +791,11 @@ fn deserialize_seq_in_place(
let this = &params.this;
let (_, ty_generics, _) = params.generics.split_for_impl();
let let_default = match *cattrs.default() {
let let_default = match cattrs.default() {
attr::Default::Default => Some(quote!(
let __default: #this #ty_generics = _serde::export::Default::default();
)),
attr::Default::Path(ref path) => Some(quote!(
attr::Default::Path(path) => Some(quote!(
let __default: #this #ty_generics = #path();
)),
attr::Default::None => {
@@ -907,7 +905,7 @@ fn deserialize_struct(
};
let type_path = match variant_ident {
Some(ref variant_ident) => quote!(#construct::#variant_ident),
Some(variant_ident) => quote!(#construct::#variant_ident),
None => construct,
};
let expecting = match variant_ident {
@@ -1144,15 +1142,14 @@ fn deserialize_enum(
variants: &[Variant],
cattrs: &attr::Container,
) -> Fragment {
match *cattrs.tag() {
match cattrs.tag() {
attr::TagType::External => deserialize_externally_tagged_enum(params, variants, cattrs),
attr::TagType::Internal { ref tag } => {
attr::TagType::Internal { tag } => {
deserialize_internally_tagged_enum(params, variants, cattrs, tag)
}
attr::TagType::Adjacent {
ref tag,
ref content,
} => deserialize_adjacently_tagged_enum(params, variants, cattrs, tag, content),
attr::TagType::Adjacent { tag, content } => {
deserialize_adjacently_tagged_enum(params, variants, cattrs, tag, content)
}
attr::TagType::None => deserialize_untagged_enum(params, variants, cattrs),
}
}
@@ -1174,12 +1171,10 @@ fn prepare_enum_variant_enum(
})
.collect();
let other_idx = variants
.iter()
.position(|ref variant| variant.attrs.other());
let other_idx = variants.iter().position(|variant| variant.attrs.other());
let variants_stmt = {
let variant_names = variant_names_idents.iter().map(|&(ref name, _, _)| name);
let variant_names = variant_names_idents.iter().map(|(name, _, _)| name);
quote! {
const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
}
@@ -1883,7 +1878,7 @@ fn deserialize_generated_identifier(
other_idx: Option<usize>,
) -> Fragment {
let this = quote!(__Field);
let field_idents: &Vec<_> = &fields.iter().map(|&(_, ref ident, _)| ident).collect();
let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();
let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
let ignore_variant = quote!(__other(_serde::private::de::Content<'de>),);
@@ -1989,7 +1984,7 @@ fn deserialize_custom_identifier(
})
.collect();
let names = names_idents.iter().map(|&(ref name, _, _)| name);
let names = names_idents.iter().map(|(name, _, _)| name);
let names_const = if fallthrough.is_some() {
None
@@ -2046,26 +2041,26 @@ fn deserialize_identifier(
collect_other_fields: bool,
) -> Fragment {
let mut flat_fields = Vec::new();
for &(_, ref ident, ref aliases) in fields {
for (_, ident, aliases) in fields {
flat_fields.extend(aliases.iter().map(|alias| (alias, ident)))
}
let field_strs = flat_fields.iter().map(|&(ref name, _)| name);
let field_borrowed_strs = flat_fields.iter().map(|&(ref name, _)| name);
let field_strs = flat_fields.iter().map(|(name, _)| name);
let field_borrowed_strs = flat_fields.iter().map(|(name, _)| name);
let field_bytes = flat_fields
.iter()
.map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
.map(|(name, _)| Literal::byte_string(name.as_bytes()));
let field_borrowed_bytes = flat_fields
.iter()
.map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
.map(|(name, _)| Literal::byte_string(name.as_bytes()));
let constructors: &Vec<_> = &flat_fields
.iter()
.map(|&(_, ref ident)| quote!(#this::#ident))
.map(|(_, ident)| quote!(#this::#ident))
.collect();
let main_constructors: &Vec<_> = &fields
.iter()
.map(|&(_, ref ident, _)| quote!(#this::#ident))
.map(|(_, ident, _)| quote!(#this::#ident))
.collect();
let expecting = if is_variant {
@@ -2327,7 +2322,7 @@ fn deserialize_struct_as_struct_visitor(
.collect();
let fields_stmt = {
let field_names = field_names_idents.iter().map(|&(ref name, _, _)| name);
let field_names = field_names_idents.iter().map(|(name, _, _)| name);
quote_block! {
const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
}
@@ -2383,7 +2378,7 @@ fn deserialize_map(
let let_values = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
.map(|&(field, ref name)| {
.map(|(field, name)| {
let field_ty = field.ty;
quote! {
let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
@@ -2406,7 +2401,7 @@ fn deserialize_map(
let value_arms = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
.map(|&(field, ref name)| {
.map(|(field, name)| {
let deser_name = field.attrs.name().deserialize_name();
let visit = match field.attrs.deserialize_with() {
@@ -2482,7 +2477,7 @@ fn deserialize_map(
let extract_values = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
.map(|&(field, ref name)| {
.map(|(field, name)| {
let missing_expr = Match(expr_is_missing(field, cattrs));
quote! {
@@ -2496,7 +2491,7 @@ fn deserialize_map(
let extract_collected = fields_names
.iter()
.filter(|&&(field, _)| field.attrs.flatten() && !field.attrs.skip_deserializing())
.map(|&(field, ref name)| {
.map(|(field, name)| {
let field_ty = field.ty;
let func = match field.attrs.deserialize_with() {
None => {
@@ -2531,7 +2526,7 @@ fn deserialize_map(
None
};
let result = fields_names.iter().map(|&(field, ref name)| {
let result = fields_names.iter().map(|(field, name)| {
let member = &field.member;
if field.attrs.skip_deserializing() {
let value = Expr(expr_is_missing(field, cattrs));
@@ -2541,11 +2536,11 @@ fn deserialize_map(
}
});
let let_default = match *cattrs.default() {
let let_default = match cattrs.default() {
attr::Default::Default => Some(quote!(
let __default: Self::Value = _serde::export::Default::default();
)),
attr::Default::Path(ref path) => Some(quote!(
attr::Default::Path(path) => Some(quote!(
let __default: Self::Value = #path();
)),
attr::Default::None => {
@@ -2604,7 +2599,7 @@ fn deserialize_struct_as_struct_in_place_visitor(
.collect();
let fields_stmt = {
let field_names = field_names_idents.iter().map(|&(ref name, _, _)| name);
let field_names = field_names_idents.iter().map(|(name, _, _)| name);
quote_block! {
const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
}
@@ -2637,7 +2632,7 @@ fn deserialize_map_in_place(
let let_flags = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(_, ref name)| {
.map(|(_, name)| {
quote! {
let mut #name: bool = false;
}
@@ -2647,7 +2642,7 @@ fn deserialize_map_in_place(
let value_arms_from = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| {
.map(|(field, name)| {
let deser_name = field.attrs.name().deserialize_name();
let member = &field.member;
@@ -2714,7 +2709,7 @@ fn deserialize_map_in_place(
let check_flags = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| {
.map(|(field, name)| {
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.
@@ -2742,11 +2737,11 @@ fn deserialize_map_in_place(
let this = &params.this;
let (_, _, ty_generics, _) = split_with_de_lifetime(params);
let let_default = match *cattrs.default() {
let let_default = match cattrs.default() {
attr::Default::Default => Some(quote!(
let __default: #this #ty_generics = _serde::export::Default::default();
)),
attr::Default::Path(ref path) => Some(quote!(
attr::Default::Path(path) => Some(quote!(
let __default: #this #ty_generics = #path();
)),
attr::Default::None => {
@@ -2865,13 +2860,13 @@ fn wrap_deserialize_variant_with(
}
fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
match *field.attrs.default() {
match field.attrs.default() {
attr::Default::Default => {
let span = field.original.span();
let func = quote_spanned!(span=> _serde::export::Default::default);
return quote_expr!(#func());
}
attr::Default::Path(ref path) => {
attr::Default::Path(path) => {
return quote_expr!(#path());
}
attr::Default::None => { /* below */ }
@@ -2935,11 +2930,11 @@ impl<'a> ToTokens for InPlaceImplGenerics<'a> {
// Add lifetime for `&'place mut Self, and `'a: 'place`
for param in &mut generics.params {
match *param {
syn::GenericParam::Lifetime(ref mut param) => {
match param {
syn::GenericParam::Lifetime(param) => {
param.bounds.push(place_lifetime.lifetime.clone());
}
syn::GenericParam::Type(ref mut param) => {
syn::GenericParam::Type(param) => {
param.bounds.push(syn::TypeParamBound::Lifetime(
place_lifetime.lifetime.clone(),
));
serde_derive/src/fragment.rs
+12 -12
View File
@@ -27,9 +27,9 @@ macro_rules! quote_block {
pub struct Expr(pub Fragment);
impl ToTokens for Expr {
fn to_tokens(&self, out: &mut TokenStream) {
match self.0 {
Fragment::Expr(ref expr) => expr.to_tokens(out),
Fragment::Block(ref block) => {
match &self.0 {
Fragment::Expr(expr) => expr.to_tokens(out),
Fragment::Block(block) => {
token::Brace::default().surround(out, |out| block.to_tokens(out));
}
}
@@ -40,9 +40,9 @@ impl ToTokens for Expr {
pub struct Stmts(pub Fragment);
impl ToTokens for Stmts {
fn to_tokens(&self, out: &mut TokenStream) {
match self.0 {
Fragment::Expr(ref expr) => expr.to_tokens(out),
Fragment::Block(ref block) => block.to_tokens(out),
match &self.0 {
Fragment::Expr(expr) => expr.to_tokens(out),
Fragment::Block(block) => block.to_tokens(out),
}
}
}
@@ -52,12 +52,12 @@ impl ToTokens for Stmts {
pub struct Match(pub Fragment);
impl ToTokens for Match {
fn to_tokens(&self, out: &mut TokenStream) {
match self.0 {
Fragment::Expr(ref expr) => {
match &self.0 {
Fragment::Expr(expr) => {
expr.to_tokens(out);
<Token![,]>::default().to_tokens(out);
}
Fragment::Block(ref block) => {
Fragment::Block(block) => {
token::Brace::default().surround(out, |out| block.to_tokens(out));
}
}
@@ -66,9 +66,9 @@ impl ToTokens for Match {
impl AsRef<TokenStream> for Fragment {
fn as_ref(&self) -> &TokenStream {
match *self {
Fragment::Expr(ref expr) => expr,
Fragment::Block(ref block) => block,
match self {
Fragment::Expr(expr) => expr,
Fragment::Block(block) => block,
}
}
}
serde_derive/src/internals/ast.rs
+15 -17
View File
@@ -67,11 +67,9 @@ impl<'a> Container<'a> {
) -> Option<Container<'a>> {
let mut attrs = attr::Container::from_ast(cx, item);
let mut data = match item.data {
syn::Data::Enum(ref data) => {
Data::Enum(enum_from_ast(cx, &data.variants, attrs.default()))
}
syn::Data::Struct(ref data) => {
let mut data = match &item.data {
syn::Data::Enum(data) => Data::Enum(enum_from_ast(cx, &data.variants, attrs.default())),
syn::Data::Struct(data) => {
let (style, fields) = struct_from_ast(cx, &data.fields, None, attrs.default());
Data::Struct(style, fields)
}
@@ -82,8 +80,8 @@ impl<'a> Container<'a> {
};
let mut has_flatten = false;
match data {
Data::Enum(ref mut variants) => {
match &mut data {
Data::Enum(variants) => {
for variant in variants {
variant.attrs.rename_by_rules(attrs.rename_all_rules());
for field in &mut variant.fields {
@@ -96,7 +94,7 @@ impl<'a> Container<'a> {
}
}
}
Data::Struct(_, ref mut fields) => {
Data::Struct(_, fields) => {
for field in fields {
if field.attrs.flatten() {
has_flatten = true;
@@ -124,11 +122,11 @@ impl<'a> Container<'a> {
impl<'a> Data<'a> {
pub fn all_fields(&'a self) -> Box<Iterator<Item = &'a Field<'a>> + 'a> {
match *self {
Data::Enum(ref variants) => {
match self {
Data::Enum(variants) => {
Box::new(variants.iter().flat_map(|variant| variant.fields.iter()))
}
Data::Struct(_, ref fields) => Box::new(fields.iter()),
Data::Struct(_, fields) => Box::new(fields.iter()),
}
}
@@ -165,16 +163,16 @@ fn struct_from_ast<'a>(
attrs: Option<&attr::Variant>,
container_default: &attr::Default,
) -> (Style, Vec<Field<'a>>) {
match *fields {
syn::Fields::Named(ref fields) => (
match fields {
syn::Fields::Named(fields) => (
Style::Struct,
fields_from_ast(cx, &fields.named, attrs, container_default),
),
syn::Fields::Unnamed(ref fields) if fields.unnamed.len() == 1 => (
syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => (
Style::Newtype,
fields_from_ast(cx, &fields.unnamed, attrs, container_default),
),
syn::Fields::Unnamed(ref fields) => (
syn::Fields::Unnamed(fields) => (
Style::Tuple,
fields_from_ast(cx, &fields.unnamed, attrs, container_default),
),
@@ -192,8 +190,8 @@ fn fields_from_ast<'a>(
.iter()
.enumerate()
.map(|(i, field)| Field {
member: match field.ident {
Some(ref ident) => syn::Member::Named(ident.clone()),
member: match &field.ident {
Some(ident) => syn::Member::Named(ident.clone()),
None => syn::Member::Unnamed(i.into()),
},
attrs: attr::Field::from_ast(cx, i, field, attrs, container_default),
serde_derive/src/internals/attr.rs
+135 -173
View File
@@ -311,9 +311,9 @@ impl Container {
.flat_map(|attr| get_serde_meta_items(cx, attr))
.flatten()
{
match meta_item {
match &meta_item {
// Parse `#[serde(rename = "foo")]`
Meta(NameValue(ref m)) if m.path == RENAME => {
Meta(NameValue(m)) if m.path == RENAME => {
if let Ok(s) = get_lit_str(cx, RENAME, &m.lit) {
ser_name.set(&m.path, s.value());
de_name.set(&m.path, s.value());
@@ -321,7 +321,7 @@ impl Container {
}
// Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
Meta(List(ref m)) if m.path == RENAME => {
Meta(List(m)) if m.path == RENAME => {
if let Ok((ser, de)) = get_renames(cx, &m.nested) {
ser_name.set_opt(&m.path, ser.map(syn::LitStr::value));
de_name.set_opt(&m.path, de.map(syn::LitStr::value));
@@ -329,7 +329,7 @@ impl Container {
}
// Parse `#[serde(rename_all = "foo")]`
Meta(NameValue(ref m)) if m.path == RENAME_ALL => {
Meta(NameValue(m)) if m.path == RENAME_ALL => {
if let Ok(s) = get_lit_str(cx, RENAME_ALL, &m.lit) {
match RenameRule::from_str(&s.value()) {
Ok(rename_rule) => {
@@ -348,7 +348,7 @@ impl Container {
}
// Parse `#[serde(rename_all(serialize = "foo", deserialize = "bar"))]`
Meta(List(ref m)) if m.path == RENAME_ALL => {
Meta(List(m)) if m.path == RENAME_ALL => {
if let Ok((ser, de)) = get_renames(cx, &m.nested) {
if let Some(ser) = ser {
match RenameRule::from_str(&ser.value()) {
@@ -378,18 +378,18 @@ impl Container {
}
// Parse `#[serde(transparent)]`
Meta(Path(ref word)) if word == TRANSPARENT => {
Meta(Path(word)) if word == TRANSPARENT => {
transparent.set_true(word);
}
// Parse `#[serde(deny_unknown_fields)]`
Meta(Path(ref word)) if word == DENY_UNKNOWN_FIELDS => {
Meta(Path(word)) if word == DENY_UNKNOWN_FIELDS => {
deny_unknown_fields.set_true(word);
}
// Parse `#[serde(default)]`
Meta(Path(ref word)) if word == DEFAULT => match item.data {
syn::Data::Struct(syn::DataStruct { ref fields, .. }) => match *fields {
Meta(Path(word)) if word == DEFAULT => match &item.data {
syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
syn::Fields::Named(_) => {
default.set(word, Default::Default);
}
@@ -398,24 +398,22 @@ impl Container {
"#[serde(default)] can only be used on structs with named fields",
),
},
syn::Data::Enum(syn::DataEnum { ref enum_token, .. }) => cx.error_spanned_by(
syn::Data::Enum(syn::DataEnum { enum_token, .. }) => cx.error_spanned_by(
enum_token,
"#[serde(default)] can only be used on structs with named fields",
),
syn::Data::Union(syn::DataUnion {
ref union_token, ..
}) => cx.error_spanned_by(
syn::Data::Union(syn::DataUnion { union_token, .. }) => cx.error_spanned_by(
union_token,
"#[serde(default)] can only be used on structs with named fields",
),
},
// Parse `#[serde(default = "...")]`
Meta(NameValue(ref m)) if m.path == DEFAULT => {
Meta(NameValue(m)) if m.path == DEFAULT => {
if let Ok(path) = parse_lit_into_expr_path(cx, DEFAULT, &m.lit) {
match item.data {
syn::Data::Struct(syn::DataStruct { ref fields, .. }) => {
match *fields {
match &item.data {
syn::Data::Struct(syn::DataStruct { fields, .. }) => {
match fields {
syn::Fields::Named(_) => {
default.set(&m.path, Default::Path(path));
}
@@ -426,13 +424,13 @@ impl Container {
),
}
}
syn::Data::Enum(syn::DataEnum { ref enum_token, .. }) => cx
syn::Data::Enum(syn::DataEnum { enum_token, .. }) => cx
.error_spanned_by(
enum_token,
"#[serde(default = \"...\")] can only be used on structs with named fields",
),
syn::Data::Union(syn::DataUnion {
ref union_token, ..
union_token, ..
}) => cx.error_spanned_by(
union_token,
"#[serde(default = \"...\")] can only be used on structs with named fields",
@@ -442,7 +440,7 @@ impl Container {
}
// Parse `#[serde(bound = "T: SomeBound")]`
Meta(NameValue(ref m)) if m.path == BOUND => {
Meta(NameValue(m)) if m.path == BOUND => {
if let Ok(where_predicates) = parse_lit_into_where(cx, BOUND, BOUND, &m.lit) {
ser_bound.set(&m.path, where_predicates.clone());
de_bound.set(&m.path, where_predicates);
@@ -450,7 +448,7 @@ impl Container {
}
// Parse `#[serde(bound(serialize = "...", deserialize = "..."))]`
Meta(List(ref m)) if m.path == BOUND => {
Meta(List(m)) if m.path == BOUND => {
if let Ok((ser, de)) = get_where_predicates(cx, &m.nested) {
ser_bound.set_opt(&m.path, ser);
de_bound.set_opt(&m.path, de);
@@ -458,21 +456,17 @@ impl Container {
}
// Parse `#[serde(untagged)]`
Meta(Path(ref word)) if word == UNTAGGED => match item.data {
Meta(Path(word)) if word == UNTAGGED => match item.data {
syn::Data::Enum(_) => {
untagged.set_true(word);
}
syn::Data::Struct(syn::DataStruct {
ref struct_token, ..
}) => {
syn::Data::Struct(syn::DataStruct { struct_token, .. }) => {
cx.error_spanned_by(
struct_token,
"#[serde(untagged)] can only be used on enums",
);
}
syn::Data::Union(syn::DataUnion {
ref union_token, ..
}) => {
syn::Data::Union(syn::DataUnion { union_token, .. }) => {
cx.error_spanned_by(
union_token,
"#[serde(untagged)] can only be used on enums",
@@ -481,28 +475,24 @@ impl Container {
},
// Parse `#[serde(tag = "type")]`
Meta(NameValue(ref m)) if m.path == TAG => {
Meta(NameValue(m)) if m.path == TAG => {
if let Ok(s) = get_lit_str(cx, TAG, &m.lit) {
match item.data {
match &item.data {
syn::Data::Enum(_) => {
internal_tag.set(&m.path, s.value());
}
syn::Data::Struct(syn::DataStruct { ref fields, .. }) => {
match *fields {
syn::Fields::Named(_) => {
internal_tag.set(&m.path, s.value());
}
syn::Fields::Unnamed(_) | syn::Fields::Unit => {
cx.error_spanned_by(
syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
syn::Fields::Named(_) => {
internal_tag.set(&m.path, s.value());
}
syn::Fields::Unnamed(_) | syn::Fields::Unit => {
cx.error_spanned_by(
fields,
"#[serde(tag = \"...\")] can only be used on enums and structs with named fields",
);
}
}
}
syn::Data::Union(syn::DataUnion {
ref union_token, ..
}) => {
},
syn::Data::Union(syn::DataUnion { union_token, .. }) => {
cx.error_spanned_by(
union_token,
"#[serde(tag = \"...\")] can only be used on enums and structs with named fields",
@@ -513,23 +503,19 @@ impl Container {
}
// Parse `#[serde(content = "c")]`
Meta(NameValue(ref m)) if m.path == CONTENT => {
Meta(NameValue(m)) if m.path == CONTENT => {
if let Ok(s) = get_lit_str(cx, CONTENT, &m.lit) {
match item.data {
match &item.data {
syn::Data::Enum(_) => {
content.set(&m.path, s.value());
}
syn::Data::Struct(syn::DataStruct {
ref struct_token, ..
}) => {
syn::Data::Struct(syn::DataStruct { struct_token, .. }) => {
cx.error_spanned_by(
struct_token,
"#[serde(content = \"...\")] can only be used on enums",
);
}
syn::Data::Union(syn::DataUnion {
ref union_token, ..
}) => {
syn::Data::Union(syn::DataUnion { union_token, .. }) => {
cx.error_spanned_by(
union_token,
"#[serde(content = \"...\")] can only be used on enums",
@@ -540,28 +526,28 @@ impl Container {
}
// Parse `#[serde(from = "Type")]
Meta(NameValue(ref m)) if m.path == FROM => {
Meta(NameValue(m)) if m.path == FROM => {
if let Ok(from_ty) = parse_lit_into_ty(cx, FROM, &m.lit) {
type_from.set_opt(&m.path, Some(from_ty));
}
}
// Parse `#[serde(try_from = "Type")]
Meta(NameValue(ref m)) if m.path == TRY_FROM => {
Meta(NameValue(m)) if m.path == TRY_FROM => {
if let Ok(try_from_ty) = parse_lit_into_ty(cx, TRY_FROM, &m.lit) {
type_try_from.set_opt(&m.path, Some(try_from_ty));
}
}
// Parse `#[serde(into = "Type")]
Meta(NameValue(ref m)) if m.path == INTO => {
Meta(NameValue(m)) if m.path == INTO => {
if let Ok(into_ty) = parse_lit_into_ty(cx, INTO, &m.lit) {
type_into.set_opt(&m.path, Some(into_ty));
}
}
// Parse `#[serde(remote = "...")]`
Meta(NameValue(ref m)) if m.path == REMOTE => {
Meta(NameValue(m)) if m.path == REMOTE => {
if let Ok(path) = parse_lit_into_path(cx, REMOTE, &m.lit) {
if is_primitive_path(&path, "Self") {
remote.set(&m.path, item.ident.clone().into());
@@ -572,23 +558,23 @@ impl Container {
}
// Parse `#[serde(field_identifier)]`
Meta(Path(ref word)) if word == FIELD_IDENTIFIER => {
Meta(Path(word)) if word == FIELD_IDENTIFIER => {
field_identifier.set_true(word);
}
// Parse `#[serde(variant_identifier)]`
Meta(Path(ref word)) if word == VARIANT_IDENTIFIER => {
Meta(Path(word)) if word == VARIANT_IDENTIFIER => {
variant_identifier.set_true(word);
}
// Parse `#[serde(crate = "foo")]`
Meta(NameValue(ref m)) if m.path == CRATE => {
Meta(NameValue(m)) if m.path == CRATE => {
if let Ok(path) = parse_lit_into_path(cx, CRATE, &m.lit) {
serde_path.set(&m.path, path)
}
}
Meta(ref meta_item) => {
Meta(meta_item) => {
let path = meta_item
.path()
.into_token_stream()
@@ -600,7 +586,7 @@ impl Container {
);
}
Lit(ref lit) => {
Lit(lit) => {
cx.error_spanned_by(lit, "unexpected literal in serde container attribute");
}
}
@@ -714,11 +700,11 @@ fn decide_tag(
(Some(_), None, None) => TagType::None,
(None, Some((_, tag)), None) => {
// Check that there are no tuple variants.
if let syn::Data::Enum(ref data) = item.data {
if let syn::Data::Enum(data) = &item.data {
for variant in &data.variants {
match variant.fields {
match &variant.fields {
syn::Fields::Named(_) | syn::Fields::Unit => {}
syn::Fields::Unnamed(ref fields) => {
syn::Fields::Unnamed(fields) => {
if fields.unnamed.len() != 1 {
cx.error_spanned_by(
variant,
@@ -806,54 +792,30 @@ fn decide_identifier(
);
Identifier::No
}
(&syn::Data::Enum(_), Some(_), None) => Identifier::Field,
(&syn::Data::Enum(_), None, Some(_)) => Identifier::Variant,
(
&syn::Data::Struct(syn::DataStruct {
ref struct_token, ..
}),
Some(_),
None,
) => {
(syn::Data::Enum(_), Some(_), None) => Identifier::Field,
(syn::Data::Enum(_), None, Some(_)) => Identifier::Variant,
(syn::Data::Struct(syn::DataStruct { struct_token, .. }), Some(_), None) => {
cx.error_spanned_by(
struct_token,
"#[serde(field_identifier)] can only be used on an enum",
);
Identifier::No
}
(
&syn::Data::Union(syn::DataUnion {
ref union_token, ..
}),
Some(_),
None,
) => {
(syn::Data::Union(syn::DataUnion { union_token, .. }), Some(_), None) => {
cx.error_spanned_by(
union_token,
"#[serde(field_identifier)] can only be used on an enum",
);
Identifier::No
}
(
&syn::Data::Struct(syn::DataStruct {
ref struct_token, ..
}),
None,
Some(_),
) => {
(syn::Data::Struct(syn::DataStruct { struct_token, .. }), None, Some(_)) => {
cx.error_spanned_by(
struct_token,
"#[serde(variant_identifier)] can only be used on an enum",
);
Identifier::No
}
(
&syn::Data::Union(syn::DataUnion {
ref union_token, ..
}),
None,
Some(_),
) => {
(syn::Data::Union(syn::DataUnion { union_token, .. }), None, Some(_)) => {
cx.error_spanned_by(
union_token,
"#[serde(variant_identifier)] can only be used on an enum",
@@ -899,9 +861,9 @@ impl Variant {
.flat_map(|attr| get_serde_meta_items(cx, attr))
.flatten()
{
match meta_item {
match &meta_item {
// Parse `#[serde(rename = "foo")]`
Meta(NameValue(ref m)) if m.path == RENAME => {
Meta(NameValue(m)) if m.path == RENAME => {
if let Ok(s) = get_lit_str(cx, RENAME, &m.lit) {
ser_name.set(&m.path, s.value());
de_name.set_if_none(s.value());
@@ -910,7 +872,7 @@ impl Variant {
}
// Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
Meta(List(ref m)) if m.path == RENAME => {
Meta(List(m)) if m.path == RENAME => {
if let Ok((ser, de)) = get_multiple_renames(cx, &m.nested) {
ser_name.set_opt(&m.path, ser.map(syn::LitStr::value));
for de_value in de {
@@ -921,14 +883,14 @@ impl Variant {
}
// Parse `#[serde(alias = "foo")]`
Meta(NameValue(ref m)) if m.path == ALIAS => {
Meta(NameValue(m)) if m.path == ALIAS => {
if let Ok(s) = get_lit_str(cx, ALIAS, &m.lit) {
de_aliases.insert(&m.path, s.value());
}
}
// Parse `#[serde(rename_all = "foo")]`
Meta(NameValue(ref m)) if m.path == RENAME_ALL => {
Meta(NameValue(m)) if m.path == RENAME_ALL => {
if let Ok(s) = get_lit_str(cx, RENAME_ALL, &m.lit) {
match RenameRule::from_str(&s.value()) {
Ok(rename_rule) => {
@@ -947,7 +909,7 @@ impl Variant {
}
// Parse `#[serde(rename_all(serialize = "foo", deserialize = "bar"))]`
Meta(List(ref m)) if m.path == RENAME_ALL => {
Meta(List(m)) if m.path == RENAME_ALL => {
if let Ok((ser, de)) = get_renames(cx, &m.nested) {
if let Some(ser) = ser {
match RenameRule::from_str(&ser.value()) {
@@ -977,28 +939,28 @@ impl Variant {
}
// Parse `#[serde(skip)]`
Meta(Path(ref word)) if word == SKIP => {
Meta(Path(word)) if word == SKIP => {
skip_serializing.set_true(word);
skip_deserializing.set_true(word);
}
// Parse `#[serde(skip_deserializing)]`
Meta(Path(ref word)) if word == SKIP_DESERIALIZING => {
Meta(Path(word)) if word == SKIP_DESERIALIZING => {
skip_deserializing.set_true(word);
}
// Parse `#[serde(skip_serializing)]`
Meta(Path(ref word)) if word == SKIP_SERIALIZING => {
Meta(Path(word)) if word == SKIP_SERIALIZING => {
skip_serializing.set_true(word);
}
// Parse `#[serde(other)]`
Meta(Path(ref word)) if word == OTHER => {
Meta(Path(word)) if word == OTHER => {
other.set_true(word);
}
// Parse `#[serde(bound = "T: SomeBound")]`
Meta(NameValue(ref m)) if m.path == BOUND => {
Meta(NameValue(m)) if m.path == BOUND => {
if let Ok(where_predicates) = parse_lit_into_where(cx, BOUND, BOUND, &m.lit) {
ser_bound.set(&m.path, where_predicates.clone());
de_bound.set(&m.path, where_predicates);
@@ -1006,7 +968,7 @@ impl Variant {
}
// Parse `#[serde(bound(serialize = "...", deserialize = "..."))]`
Meta(List(ref m)) if m.path == BOUND => {
Meta(List(m)) if m.path == BOUND => {
if let Ok((ser, de)) = get_where_predicates(cx, &m.nested) {
ser_bound.set_opt(&m.path, ser);
de_bound.set_opt(&m.path, de);
@@ -1014,7 +976,7 @@ impl Variant {
}
// Parse `#[serde(with = "...")]`
Meta(NameValue(ref m)) if m.path == WITH => {
Meta(NameValue(m)) if m.path == WITH => {
if let Ok(path) = parse_lit_into_expr_path(cx, WITH, &m.lit) {
let mut ser_path = path.clone();
ser_path
@@ -1032,22 +994,22 @@ impl Variant {
}
// Parse `#[serde(serialize_with = "...")]`
Meta(NameValue(ref m)) if m.path == SERIALIZE_WITH => {
Meta(NameValue(m)) if m.path == SERIALIZE_WITH => {
if let Ok(path) = parse_lit_into_expr_path(cx, SERIALIZE_WITH, &m.lit) {
serialize_with.set(&m.path, path);
}
}
// Parse `#[serde(deserialize_with = "...")]`
Meta(NameValue(ref m)) if m.path == DESERIALIZE_WITH => {
Meta(NameValue(m)) if m.path == DESERIALIZE_WITH => {
if let Ok(path) = parse_lit_into_expr_path(cx, DESERIALIZE_WITH, &m.lit) {
deserialize_with.set(&m.path, path);
}
}
// Defer `#[serde(borrow)]` and `#[serde(borrow = "'a + 'b")]`
Meta(ref m) if m.path() == BORROW => match variant.fields {
syn::Fields::Unnamed(ref fields) if fields.unnamed.len() == 1 => {
Meta(m) if m.path() == BORROW => match &variant.fields {
syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
borrow.set(m.path(), m.clone());
}
_ => {
@@ -1058,7 +1020,7 @@ impl Variant {
}
},
Meta(ref meta_item) => {
Meta(meta_item) => {
let path = meta_item
.path()
.into_token_stream()
@@ -1070,7 +1032,7 @@ impl Variant {
);
}
Lit(ref lit) => {
Lit(lit) => {
cx.error_spanned_by(lit, "unexpected literal in serde variant attribute");
}
}
@@ -1172,7 +1134,7 @@ pub enum Default {
impl Default {
pub fn is_none(&self) -> bool {
match *self {
match self {
Default::None => true,
Default::Default | Default::Path(_) => false,
}
@@ -1203,8 +1165,8 @@ impl Field {
let mut getter = Attr::none(cx, GETTER);
let mut flatten = BoolAttr::none(cx, FLATTEN);
let ident = match field.ident {
Some(ref ident) => unraw(ident),
let ident = match &field.ident {
Some(ident) => unraw(ident),
None => index.to_string(),
};
@@ -1219,9 +1181,9 @@ impl Field {
.flatten()
.chain(variant_borrow)
{
match meta_item {
match &meta_item {
// Parse `#[serde(rename = "foo")]`
Meta(NameValue(ref m)) if m.path == RENAME => {
Meta(NameValue(m)) if m.path == RENAME => {
if let Ok(s) = get_lit_str(cx, RENAME, &m.lit) {
ser_name.set(&m.path, s.value());
de_name.set_if_none(s.value());
@@ -1230,7 +1192,7 @@ impl Field {
}
// Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
Meta(List(ref m)) if m.path == RENAME => {
Meta(List(m)) if m.path == RENAME => {
if let Ok((ser, de)) = get_multiple_renames(cx, &m.nested) {
ser_name.set_opt(&m.path, ser.map(syn::LitStr::value));
for de_value in de {
@@ -1241,63 +1203,63 @@ impl Field {
}
// Parse `#[serde(alias = "foo")]`
Meta(NameValue(ref m)) if m.path == ALIAS => {
Meta(NameValue(m)) if m.path == ALIAS => {
if let Ok(s) = get_lit_str(cx, ALIAS, &m.lit) {
de_aliases.insert(&m.path, s.value());
}
}
// Parse `#[serde(default)]`
Meta(Path(ref word)) if word == DEFAULT => {
Meta(Path(word)) if word == DEFAULT => {
default.set(word, Default::Default);
}
// Parse `#[serde(default = "...")]`
Meta(NameValue(ref m)) if m.path == DEFAULT => {
Meta(NameValue(m)) if m.path == DEFAULT => {
if let Ok(path) = parse_lit_into_expr_path(cx, DEFAULT, &m.lit) {
default.set(&m.path, Default::Path(path));
}
}
// Parse `#[serde(skip_serializing)]`
Meta(Path(ref word)) if word == SKIP_SERIALIZING => {
Meta(Path(word)) if word == SKIP_SERIALIZING => {
skip_serializing.set_true(word);
}
// Parse `#[serde(skip_deserializing)]`
Meta(Path(ref word)) if word == SKIP_DESERIALIZING => {
Meta(Path(word)) if word == SKIP_DESERIALIZING => {
skip_deserializing.set_true(word);
}
// Parse `#[serde(skip)]`
Meta(Path(ref word)) if word == SKIP => {
Meta(Path(word)) if word == SKIP => {
skip_serializing.set_true(word);
skip_deserializing.set_true(word);
}
// Parse `#[serde(skip_serializing_if = "...")]`
Meta(NameValue(ref m)) if m.path == SKIP_SERIALIZING_IF => {
Meta(NameValue(m)) if m.path == SKIP_SERIALIZING_IF => {
if let Ok(path) = parse_lit_into_expr_path(cx, SKIP_SERIALIZING_IF, &m.lit) {
skip_serializing_if.set(&m.path, path);
}
}
// Parse `#[serde(serialize_with = "...")]`
Meta(NameValue(ref m)) if m.path == SERIALIZE_WITH => {
Meta(NameValue(m)) if m.path == SERIALIZE_WITH => {
if let Ok(path) = parse_lit_into_expr_path(cx, SERIALIZE_WITH, &m.lit) {
serialize_with.set(&m.path, path);
}
}
// Parse `#[serde(deserialize_with = "...")]`
Meta(NameValue(ref m)) if m.path == DESERIALIZE_WITH => {
Meta(NameValue(m)) if m.path == DESERIALIZE_WITH => {
if let Ok(path) = parse_lit_into_expr_path(cx, DESERIALIZE_WITH, &m.lit) {
deserialize_with.set(&m.path, path);
}
}
// Parse `#[serde(with = "...")]`
Meta(NameValue(ref m)) if m.path == WITH => {
Meta(NameValue(m)) if m.path == WITH => {
if let Ok(path) = parse_lit_into_expr_path(cx, WITH, &m.lit) {
let mut ser_path = path.clone();
ser_path
@@ -1315,7 +1277,7 @@ impl Field {
}
// Parse `#[serde(bound = "T: SomeBound")]`
Meta(NameValue(ref m)) if m.path == BOUND => {
Meta(NameValue(m)) if m.path == BOUND => {
if let Ok(where_predicates) = parse_lit_into_where(cx, BOUND, BOUND, &m.lit) {
ser_bound.set(&m.path, where_predicates.clone());
de_bound.set(&m.path, where_predicates);
@@ -1323,7 +1285,7 @@ impl Field {
}
// Parse `#[serde(bound(serialize = "...", deserialize = "..."))]`
Meta(List(ref m)) if m.path == BOUND => {
Meta(List(m)) if m.path == BOUND => {
if let Ok((ser, de)) = get_where_predicates(cx, &m.nested) {
ser_bound.set_opt(&m.path, ser);
de_bound.set_opt(&m.path, de);
@@ -1331,14 +1293,14 @@ impl Field {
}
// Parse `#[serde(borrow)]`
Meta(Path(ref word)) if word == BORROW => {
Meta(Path(word)) if word == BORROW => {
if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
borrowed_lifetimes.set(word, borrowable);
}
}
// Parse `#[serde(borrow = "'a + 'b")]`
Meta(NameValue(ref m)) if m.path == BORROW => {
Meta(NameValue(m)) if m.path == BORROW => {
if let Ok(lifetimes) = parse_lit_into_lifetimes(cx, BORROW, &m.lit) {
if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
for lifetime in &lifetimes {
@@ -1358,18 +1320,18 @@ impl Field {
}
// Parse `#[serde(getter = "...")]`
Meta(NameValue(ref m)) if m.path == GETTER => {
Meta(NameValue(m)) if m.path == GETTER => {
if let Ok(path) = parse_lit_into_expr_path(cx, GETTER, &m.lit) {
getter.set(&m.path, path);
}
}
// Parse `#[serde(flatten)]`
Meta(Path(ref word)) if word == FLATTEN => {
Meta(Path(word)) if word == FLATTEN => {
flatten.set_true(word);
}
Meta(ref meta_item) => {
Meta(meta_item) => {
let path = meta_item
.path()
.into_token_stream()
@@ -1381,7 +1343,7 @@ impl Field {
);
}
Lit(ref lit) => {
Lit(lit) => {
cx.error_spanned_by(lit, "unexpected literal in serde field attribute");
}
}
@@ -1551,14 +1513,14 @@ where
let mut de_meta = VecAttr::none(cx, attr_name);
for meta in metas {
match *meta {
Meta(NameValue(ref meta)) if meta.path == SERIALIZE => {
match meta {
Meta(NameValue(meta)) if meta.path == SERIALIZE => {
if let Ok(v) = f(cx, attr_name, SERIALIZE, &meta.lit) {
ser_meta.insert(&meta.path, v);
}
}
Meta(NameValue(ref meta)) if meta.path == DESERIALIZE => {
Meta(NameValue(meta)) if meta.path == DESERIALIZE => {
if let Ok(v) = f(cx, attr_name, DESERIALIZE, &meta.lit) {
de_meta.insert(&meta.path, v);
}
@@ -1610,7 +1572,7 @@ pub fn get_serde_meta_items(cx: &Ctxt, attr: &syn::Attribute) -> Result<Vec<syn:
}
match attr.parse_meta() {
Ok(List(ref meta)) => Ok(meta.nested.iter().cloned().collect()),
Ok(List(meta)) => Ok(meta.nested.into_iter().collect()),
Ok(other) => {
cx.error_spanned_by(other, "expected #[serde(...)]");
Err(())
@@ -1632,7 +1594,7 @@ fn get_lit_str2<'a>(
meta_item_name: Symbol,
lit: &'a syn::Lit,
) -> Result<&'a syn::LitStr, ()> {
if let syn::Lit::Str(ref lit) = *lit {
if let syn::Lit::Str(lit) = lit {
Ok(lit)
} else {
cx.error_spanned_by(
@@ -1762,8 +1724,8 @@ fn is_implicitly_borrowed_reference(ty: &syn::Type) -> bool {
// cow: Cow<'a, str>,
// }
fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
let path = match *ty {
syn::Type::Path(ref ty) => &ty.path,
let path = match ty {
syn::Type::Path(ty) => &ty.path,
_ => {
return false;
}
@@ -1774,8 +1736,8 @@ fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
return false;
}
};
let args = match seg.arguments {
syn::PathArguments::AngleBracketed(ref bracketed) => &bracketed.args,
let args = match &seg.arguments {
syn::PathArguments::AngleBracketed(bracketed) => &bracketed.args,
_ => {
return false;
}
@@ -1783,14 +1745,14 @@ fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
seg.ident == "Cow"
&& args.len() == 2
&& match (&args[0], &args[1]) {
(&syn::GenericArgument::Lifetime(_), &syn::GenericArgument::Type(ref arg)) => elem(arg),
(syn::GenericArgument::Lifetime(_), syn::GenericArgument::Type(arg)) => elem(arg),
_ => false,
}
}
fn is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
let path = match *ty {
syn::Type::Path(ref ty) => &ty.path,
let path = match ty {
syn::Type::Path(ty) => &ty.path,
_ => {
return false;
}
@@ -1801,16 +1763,16 @@ fn is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
return false;
}
};
let args = match seg.arguments {
syn::PathArguments::AngleBracketed(ref bracketed) => &bracketed.args,
let args = match &seg.arguments {
syn::PathArguments::AngleBracketed(bracketed) => &bracketed.args,
_ => {
return false;
}
};
seg.ident == "Option"
&& args.len() == 1
&& match args[0] {
syn::GenericArgument::Type(ref arg) => elem(arg),
&& match &args[0] {
syn::GenericArgument::Type(arg) => elem(arg),
_ => false,
}
}
@@ -1836,8 +1798,8 @@ fn is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
// r: &'a str,
// }
fn is_reference(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
match *ty {
syn::Type::Reference(ref ty) => ty.mutability.is_none() && elem(&ty.elem),
match ty {
syn::Type::Reference(ty) => ty.mutability.is_none() && elem(&ty.elem),
_ => false,
}
}
@@ -1847,15 +1809,15 @@ fn is_str(ty: &syn::Type) -> bool {
}
fn is_slice_u8(ty: &syn::Type) -> bool {
match *ty {
syn::Type::Slice(ref ty) => is_primitive_type(&ty.elem, "u8"),
match ty {
syn::Type::Slice(ty) => is_primitive_type(&ty.elem, "u8"),
_ => false,
}
}
fn is_primitive_type(ty: &syn::Type, primitive: &str) -> bool {
match *ty {
syn::Type::Path(ref ty) => ty.qself.is_none() && is_primitive_path(&ty.path, primitive),
match ty {
syn::Type::Path(ty) => ty.qself.is_none() && is_primitive_path(&ty.path, primitive),
_ => false,
}
}
@@ -1893,40 +1855,40 @@ fn borrowable_lifetimes(
}
fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
match *ty {
syn::Type::Slice(ref ty) => {
match ty {
syn::Type::Slice(ty) => {
collect_lifetimes(&ty.elem, out);
}
syn::Type::Array(ref ty) => {
syn::Type::Array(ty) => {
collect_lifetimes(&ty.elem, out);
}
syn::Type::Ptr(ref ty) => {
syn::Type::Ptr(ty) => {
collect_lifetimes(&ty.elem, out);
}
syn::Type::Reference(ref ty) => {
syn::Type::Reference(ty) => {
out.extend(ty.lifetime.iter().cloned());
collect_lifetimes(&ty.elem, out);
}
syn::Type::Tuple(ref ty) => {
syn::Type::Tuple(ty) => {
for elem in &ty.elems {
collect_lifetimes(elem, out);
}
}
syn::Type::Path(ref ty) => {
if let Some(ref qself) = ty.qself {
syn::Type::Path(ty) => {
if let Some(qself) = &ty.qself {
collect_lifetimes(&qself.ty, out);
}
for seg in &ty.path.segments {
if let syn::PathArguments::AngleBracketed(ref bracketed) = seg.arguments {
if let syn::PathArguments::AngleBracketed(bracketed) = &seg.arguments {
for arg in &bracketed.args {
match *arg {
syn::GenericArgument::Lifetime(ref lifetime) => {
match arg {
syn::GenericArgument::Lifetime(lifetime) => {
out.insert(lifetime.clone());
}
syn::GenericArgument::Type(ref ty) => {
syn::GenericArgument::Type(ty) => {
collect_lifetimes(ty, out);
}
syn::GenericArgument::Binding(ref binding) => {
syn::GenericArgument::Binding(binding) => {
collect_lifetimes(&binding.ty, out);
}
syn::GenericArgument::Constraint(_)
@@ -1936,10 +1898,10 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
}
}
}
syn::Type::Paren(ref ty) => {
syn::Type::Paren(ty) => {
collect_lifetimes(&ty.elem, out);
}
syn::Type::Group(ref ty) => {
syn::Type::Group(ty) => {
collect_lifetimes(&ty.elem, out);
}
syn::Type::BareFn(_)
@@ -1974,7 +1936,7 @@ fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream {
}
fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree {
if let TokenTree::Group(ref mut g) = token {
if let TokenTree::Group(g) = &mut token {
*g = Group::new(g.delimiter(), respan_token_stream(g.stream().clone(), span));
}
token.set_span(span);
serde_derive/src/internals/check.rs
+20 -23
View File
@@ -41,17 +41,17 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
/// Flattening has some restrictions we can test.
fn check_flatten(cx: &Ctxt, cont: &Container) {
match cont.data {
Data::Enum(ref variants) => {
match &cont.data {
Data::Enum(variants) => {
for variant in variants {
for field in &variant.fields {
check_flatten_field(cx, variant.style, field);
}
}
}
Data::Struct(style, ref fields) => {
Data::Struct(style, fields) => {
for field in fields {
check_flatten_field(cx, style, field);
check_flatten_field(cx, *style, field);
}
}
}
@@ -85,8 +85,8 @@ fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
/// `field_identifier` all but possibly one variant must be unit variants. The
/// last variant may be a newtype variant which is an implicit "other" case.
fn check_identifier(cx: &Ctxt, cont: &Container) {
let variants = match cont.data {
Data::Enum(ref variants) => variants,
let variants = match &cont.data {
Data::Enum(variants) => variants,
Data::Struct(_, _) => {
return;
}
@@ -169,8 +169,8 @@ fn check_identifier(cx: &Ctxt, cont: &Container) {
/// Skip-(de)serializing attributes are not allowed on variants marked
/// (de)serialize_with.
fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
let variants = match cont.data {
Data::Enum(ref variants) => variants,
let variants = match &cont.data {
Data::Enum(variants) => variants,
Data::Struct(_, _) => {
return;
}
@@ -246,13 +246,13 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
/// duplicate keys in the serialized output and/or ambiguity in
/// the to-be-deserialized input.
fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
let variants = match cont.data {
Data::Enum(ref variants) => variants,
let variants = match &cont.data {
Data::Enum(variants) => variants,
Data::Struct(_, _) => return,
};
let tag = match *cont.attrs.tag() {
TagType::Internal { ref tag } => tag.as_str(),
let tag = match cont.attrs.tag() {
TagType::Internal { tag } => tag.as_str(),
TagType::External | TagType::Adjacent { .. } | TagType::None => return,
};
@@ -293,11 +293,8 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
/// In the case of adjacently-tagged enums, the type and the
/// contents tag must differ, for the same reason.
fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
let (type_tag, content_tag) = match *cont.attrs.tag() {
TagType::Adjacent {
ref tag,
ref content,
} => (tag, content),
let (type_tag, content_tag) = match cont.attrs.tag() {
TagType::Adjacent { tag, content } => (tag, content),
TagType::Internal { .. } | TagType::External | TagType::None => return,
};
@@ -339,7 +336,7 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
);
}
let fields = match cont.data {
let fields = match &mut cont.data {
Data::Enum(_) => {
cx.error_spanned_by(
cont.original,
@@ -354,7 +351,7 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
);
return;
}
Data::Struct(_, ref mut fields) => fields,
Data::Struct(_, fields) => fields,
};
let mut transparent_field = None;
@@ -392,14 +389,14 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
}
fn member_message(member: &Member) -> String {
match *member {
Member::Named(ref ident) => format!("`{}`", ident),
Member::Unnamed(ref i) => format!("#{}", i.index),
match member {
Member::Named(ident) => format!("`{}`", ident),
Member::Unnamed(i) => format!("#{}", i.index),
}
}
fn allow_transparent(field: &Field, derive: Derive) -> bool {
if let Type::Path(ref ty) = *field.ty {
if let Type::Path(ty) = field.ty {
if let Some(seg) = ty.path.segments.last() {
if seg.ident == "PhantomData" {
return false;
serde_derive/src/pretend.rs
+5 -5
View File
@@ -52,8 +52,8 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
let type_ident = &cont.ident;
let (_, ty_generics, _) = cont.generics.split_for_impl();
let patterns = match cont.data {
Data::Enum(ref variants) => variants
let patterns = match &cont.data {
Data::Enum(variants) => variants
.iter()
.filter_map(|variant| match variant.style {
Style::Struct => {
@@ -64,7 +64,7 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
_ => None,
})
.collect::<Vec<_>>(),
Data::Struct(Style::Struct, ref fields) => {
Data::Struct(Style::Struct, fields) => {
let pat = struct_pattern(fields);
vec![quote!(#type_ident #pat)]
}
@@ -93,8 +93,8 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
// }
//
fn pretend_variants_used(cont: &Container) -> TokenStream {
let variants = match cont.data {
Data::Enum(ref variants) => variants,
let variants = match &cont.data {
Data::Enum(variants) => variants,
Data::Struct(_, _) => {
return quote!();
}
serde_derive/src/ser.rs
+20 -23
View File
@@ -164,15 +164,13 @@ fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
} else if let Some(type_into) = cont.attrs.type_into() {
serialize_into(params, type_into)
} else {
match cont.data {
Data::Enum(ref variants) => serialize_enum(params, variants, &cont.attrs),
Data::Struct(Style::Struct, ref fields) => {
serialize_struct(params, fields, &cont.attrs)
}
Data::Struct(Style::Tuple, ref fields) => {
match &cont.data {
Data::Enum(variants) => serialize_enum(params, variants, &cont.attrs),
Data::Struct(Style::Struct, fields) => serialize_struct(params, fields, &cont.attrs),
Data::Struct(Style::Tuple, fields) => {
serialize_tuple_struct(params, fields, &cont.attrs)
}
Data::Struct(Style::Newtype, ref fields) => {
Data::Struct(Style::Newtype, fields) => {
serialize_newtype_struct(params, &fields[0], &cont.attrs)
}
Data::Struct(Style::Unit, _) => serialize_unit_struct(&cont.attrs),
@@ -181,8 +179,8 @@ fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
}
fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
let fields = match cont.data {
Data::Struct(_, ref fields) => fields,
let fields = match &cont.data {
Data::Struct(_, fields) => fields,
Data::Enum(_) => unreachable!(),
};
@@ -259,7 +257,7 @@ fn serialize_tuple_struct(
let mut serialized_fields = fields
.iter()
.enumerate()
.filter(|&(_, ref field)| !field.attrs.skip_serializing())
.filter(|(_, field)| !field.attrs.skip_serializing())
.peekable();
let let_mut = mut_if(serialized_fields.peek().is_some());
@@ -296,8 +294,8 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
}
fn serialize_struct_tag_field(cattrs: &attr::Container, struct_trait: &StructTrait) -> TokenStream {
match *cattrs.tag() {
attr::TagType::Internal { ref tag } => {
match cattrs.tag() {
attr::TagType::Internal { tag } => {
let type_name = cattrs.name().serialize_name();
let func = struct_trait.serialize_field(Span::call_site());
quote! {
@@ -467,17 +465,16 @@ fn serialize_variant(
}
};
let body = Match(match *cattrs.tag() {
let body = Match(match cattrs.tag() {
attr::TagType::External => {
serialize_externally_tagged_variant(params, variant, variant_index, cattrs)
}
attr::TagType::Internal { ref tag } => {
attr::TagType::Internal { tag } => {
serialize_internally_tagged_variant(params, variant, cattrs, tag)
}
attr::TagType::Adjacent {
ref tag,
ref content,
} => serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content),
attr::TagType::Adjacent { tag, content } => {
serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content)
}
attr::TagType::None => serialize_untagged_variant(params, variant, cattrs),
});
@@ -804,7 +801,7 @@ fn serialize_tuple_variant(
let mut serialized_fields = fields
.iter()
.enumerate()
.filter(|&(_, ref field)| !field.attrs.skip_serializing())
.filter(|(_, field)| !field.attrs.skip_serializing())
.peekable();
let let_mut = mut_if(serialized_fields.peek().is_some());
@@ -1039,7 +1036,7 @@ fn serialize_tuple_struct_visitor(
fields
.iter()
.enumerate()
.filter(|&(_, ref field)| !field.attrs.skip_serializing())
.filter(|(_, field)| !field.attrs.skip_serializing())
.map(|(i, field)| {
let mut field_expr = if is_enum {
let id = Ident::new(&format!("__field{}", i), Span::call_site());
@@ -1163,9 +1160,9 @@ fn wrap_serialize_variant_with(
.fields
.iter()
.map(|field| {
let id = match field.member {
Member::Named(ref ident) => ident.clone(),
Member::Unnamed(ref member) => {
let id = match &field.member {
Member::Named(ident) => ident.clone(),
Member::Unnamed(member) => {
Ident::new(&format!("__field{}", member.index), Span::call_site())
}
};