pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-14 05:51:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format with rustfmt 2018-11-30

Browse Source
This commit is contained in:
David Tolnay
2018-12-10 22:09:02 -08:00
parent 8b4074ee77
commit 16daba8ea9
6 changed files with 230 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_derive/src/de.rs
+8 -4
View File
@@ -89,7 +89,10 @@ fn precondition_sized(cx: &Ctxt, cont: &Container) {
if let Data::Struct(_, ref fields) = cont.data { if let Data::Struct(_, ref fields) = cont.data {
if let Some(last) = fields.last() { if let Some(last) = fields.last() {
if let syn::Type::Slice(_) = *last.ty { if let syn::Type::Slice(_) = *last.ty {
cx.error_spanned_by(cont.original, "cannot deserialize a dynamically sized struct"); cx.error_spanned_by(
cont.original,
"cannot deserialize a dynamically sized struct",
);
} }
} }
} }
@@ -366,7 +369,7 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
None => { None => {
let span = transparent_field.original.span(); let span = transparent_field.original.span();
quote_spanned!(span=> _serde::Deserialize::deserialize) quote_spanned!(span=> _serde::Deserialize::deserialize)
}, }
}; };
let assign = fields.iter().map(|field| { let assign = fields.iter().map(|field| {
@@ -1830,7 +1833,8 @@ fn deserialize_externally_tagged_newtype_variant(
None => { None => {
let field_ty = field.ty; let field_ty = field.ty;
let span = field.original.span(); let span = field.original.span();
let func = quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>); let func =
quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
quote_expr! { quote_expr! {
_serde::export::Result::map(#func(__variant), #this::#variant_ident) _serde::export::Result::map(#func(__variant), #this::#variant_ident)
} }
@@ -2470,7 +2474,7 @@ fn deserialize_map(
None => { None => {
let span = field.original.span(); let span = field.original.span();
quote_spanned!(span=> _serde::de::Deserialize::deserialize) quote_spanned!(span=> _serde::de::Deserialize::deserialize)
}, }
Some(path) => quote!(#path), Some(path) => quote!(#path),
}; };
quote! { quote! {
serde_derive/src/internals/ast.rs
+5 -1
View File
@@ -60,7 +60,11 @@ pub enum Style {
impl<'a> Container<'a> { impl<'a> Container<'a> {
/// Convert the raw Syn ast into a parsed container object, collecting errors in `cx`. /// Convert the raw Syn ast into a parsed container object, collecting errors in `cx`.
pub fn from_ast(cx: &Ctxt, item: &'a syn::DeriveInput, derive: Derive) -> Option<Container<'a>> { pub fn from_ast(
cx: &Ctxt,
item: &'a syn::DeriveInput,
derive: Derive,
) -> Option<Container<'a>> {
let mut attrs = attr::Container::from_ast(cx, item); let mut attrs = attr::Container::from_ast(cx, item);
let mut data = match item.data { let mut data = match item.data {
serde_derive/src/internals/attr.rs
+159 -107
View File
@@ -42,10 +42,8 @@ impl<'c, T> Attr<'c, T> {
let tokens = obj.into_token_stream(); let tokens = obj.into_token_stream();
if self.value.is_some() { if self.value.is_some() {
self.cx.error_spanned_by( self.cx
tokens, .error_spanned_by(tokens, format!("duplicate serde attribute `{}`", self.name));
format!("duplicate serde attribute `{}`", self.name),
);
} else { } else {
self.tokens = tokens; self.tokens = tokens;
self.value = Some(value); self.value = Some(value);
@@ -71,7 +69,7 @@ impl<'c, T> Attr<'c, T> {
fn get_with_tokens(self) -> Option<(TokenStream, T)> { fn get_with_tokens(self) -> Option<(TokenStream, T)> {
match self.value { match self.value {
Some(v) => Some((self.tokens, v)), Some(v) => Some((self.tokens, v)),
None => None, None => None,
} }
} }
} }
@@ -232,11 +230,14 @@ impl Container {
if let Ok(s) = get_lit_str(cx, &m.ident, &m.ident, &m.lit) { if let Ok(s) = get_lit_str(cx, &m.ident, &m.ident, &m.lit) {
match RenameRule::from_str(&s.value()) { match RenameRule::from_str(&s.value()) {
Ok(rename_rule) => rename_all.set(&m.ident, rename_rule), Ok(rename_rule) => rename_all.set(&m.ident, rename_rule),
Err(()) => cx.error_spanned_by(s, format!( Err(()) => cx.error_spanned_by(
"unknown rename rule for #[serde(rename_all \ s,
= {:?})]", format!(
s.value(), "unknown rename rule for #[serde(rename_all \
)), = {:?})]",
s.value(),
),
),
} }
} }
} }
@@ -261,14 +262,17 @@ impl Container {
fields, fields,
"#[serde(default)] can only be used on structs \ "#[serde(default)] can only be used on structs \
with named fields", with named fields",
) ),
}, },
syn::Data::Enum(syn::DataEnum { ref enum_token, .. }) => cx.error_spanned_by( syn::Data::Enum(syn::DataEnum { ref enum_token, .. }) => cx
enum_token, .error_spanned_by(
"#[serde(default)] can only be used on structs \ enum_token,
with named fields", "#[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 {
ref union_token, ..
}) => cx.error_spanned_by(
union_token, union_token,
"#[serde(default)] can only be used on structs \ "#[serde(default)] can only be used on structs \
with named fields", with named fields",
@@ -279,22 +283,28 @@ impl Container {
Meta(NameValue(ref m)) if m.ident == "default" => { Meta(NameValue(ref m)) if m.ident == "default" => {
if let Ok(path) = parse_lit_into_expr_path(cx, &m.ident, &m.lit) { if let Ok(path) = parse_lit_into_expr_path(cx, &m.ident, &m.lit) {
match item.data { match item.data {
syn::Data::Struct(syn::DataStruct { ref fields, .. }) => match *fields { syn::Data::Struct(syn::DataStruct { ref fields, .. }) => {
syn::Fields::Named(_) => { match *fields {
default.set(&m.ident, Default::Path(path)); syn::Fields::Named(_) => {
default.set(&m.ident, Default::Path(path));
}
syn::Fields::Unnamed(_) | syn::Fields::Unit => cx
.error_spanned_by(
fields,
"#[serde(default = \"...\")] can only be used \
on structs with named fields",
),
} }
syn::Fields::Unnamed(_) | syn::Fields::Unit => cx.error_spanned_by( }
fields, syn::Data::Enum(syn::DataEnum { ref enum_token, .. }) => cx
.error_spanned_by(
enum_token,
"#[serde(default = \"...\")] can only be used \ "#[serde(default = \"...\")] can only be used \
on structs with named fields", on structs with named fields",
) ),
}, syn::Data::Union(syn::DataUnion {
syn::Data::Enum(syn::DataEnum { ref enum_token, .. }) => cx.error_spanned_by( ref union_token, ..
enum_token, }) => cx.error_spanned_by(
"#[serde(default = \"...\")] can only be used \
on structs with named fields",
),
syn::Data::Union(syn::DataUnion { ref union_token, .. }) => cx.error_spanned_by(
union_token, union_token,
"#[serde(default = \"...\")] can only be used \ "#[serde(default = \"...\")] can only be used \
on structs with named fields", on structs with named fields",
@@ -326,13 +336,17 @@ impl Container {
syn::Data::Enum(_) => { syn::Data::Enum(_) => {
untagged.set_true(word); untagged.set_true(word);
} }
syn::Data::Struct(syn::DataStruct { ref struct_token, .. }) => { syn::Data::Struct(syn::DataStruct {
ref struct_token, ..
}) => {
cx.error_spanned_by( cx.error_spanned_by(
struct_token, struct_token,
"#[serde(untagged)] can only be used on enums", "#[serde(untagged)] can only be used on enums",
); );
} }
syn::Data::Union(syn::DataUnion { ref union_token, .. }) => { syn::Data::Union(syn::DataUnion {
ref union_token, ..
}) => {
cx.error_spanned_by( cx.error_spanned_by(
union_token, union_token,
"#[serde(untagged)] can only be used on enums", "#[serde(untagged)] can only be used on enums",
@@ -347,18 +361,22 @@ impl Container {
syn::Data::Enum(_) => { syn::Data::Enum(_) => {
internal_tag.set(&m.ident, s.value()); internal_tag.set(&m.ident, s.value());
} }
syn::Data::Struct(syn::DataStruct { ref struct_token, .. }) => { syn::Data::Struct(syn::DataStruct {
ref struct_token, ..
}) => {
cx.error_spanned_by( cx.error_spanned_by(
struct_token, struct_token,
"#[serde(tag = \"...\")] can only be used on enums", "#[serde(tag = \"...\")] can only be used on enums",
); );
}, }
syn::Data::Union(syn::DataUnion { ref union_token, .. }) => { syn::Data::Union(syn::DataUnion {
ref union_token, ..
}) => {
cx.error_spanned_by( cx.error_spanned_by(
union_token, union_token,
"#[serde(tag = \"...\")] can only be used on enums", "#[serde(tag = \"...\")] can only be used on enums",
); );
}, }
} }
} }
} }
@@ -370,18 +388,22 @@ impl Container {
syn::Data::Enum(_) => { syn::Data::Enum(_) => {
content.set(&m.ident, s.value()); content.set(&m.ident, s.value());
} }
syn::Data::Struct(syn::DataStruct { ref struct_token, .. }) => { syn::Data::Struct(syn::DataStruct {
ref struct_token, ..
}) => {
cx.error_spanned_by( cx.error_spanned_by(
struct_token, struct_token,
"#[serde(content = \"...\")] can only be used on enums", "#[serde(content = \"...\")] can only be used on enums",
); );
}, }
syn::Data::Union(syn::DataUnion { ref union_token, .. }) => { syn::Data::Union(syn::DataUnion {
ref union_token, ..
}) => {
cx.error_spanned_by( cx.error_spanned_by(
union_token, union_token,
"#[serde(content = \"...\")] can only be used on enums", "#[serde(content = \"...\")] can only be used on enums",
); );
}, }
} }
} }
} }
@@ -422,10 +444,10 @@ impl Container {
} }
Meta(ref meta_item) => { Meta(ref meta_item) => {
cx.error_spanned_by(meta_item.name(), format!( cx.error_spanned_by(
"unknown serde container attribute `{}`", meta_item.name(),
meta_item.name() format!("unknown serde container attribute `{}`", meta_item.name()),
)); );
} }
Literal(ref lit) => { Literal(ref lit) => {
@@ -519,7 +541,11 @@ fn decide_tag(
internal_tag: Attr<String>, internal_tag: Attr<String>,
content: Attr<String>, content: Attr<String>,
) -> EnumTag { ) -> EnumTag {
match (untagged.0.get_with_tokens(), internal_tag.get_with_tokens(), content.get_with_tokens()) { match (
untagged.0.get_with_tokens(),
internal_tag.get_with_tokens(),
content.get_with_tokens(),
) {
(None, None, None) => EnumTag::External, (None, None, None) => EnumTag::External,
(Some(_), None, None) => EnumTag::None, (Some(_), None, None) => EnumTag::None,
(None, Some((_, tag)), None) => { (None, Some((_, tag)), None) => {
@@ -600,7 +626,11 @@ fn decide_identifier(
field_identifier: BoolAttr, field_identifier: BoolAttr,
variant_identifier: BoolAttr, variant_identifier: BoolAttr,
) -> Identifier { ) -> Identifier {
match (&item.data, field_identifier.0.get_with_tokens(), variant_identifier.0.get_with_tokens()) { match (
&item.data,
field_identifier.0.get_with_tokens(),
variant_identifier.0.get_with_tokens(),
) {
(_, None, None) => Identifier::No, (_, None, None) => Identifier::No,
(_, Some((field_identifier_tokens, _)), Some((variant_identifier_tokens, _))) => { (_, Some((field_identifier_tokens, _)), Some((variant_identifier_tokens, _))) => {
cx.error_spanned_by( cx.error_spanned_by(
@@ -615,28 +645,52 @@ fn decide_identifier(
} }
(&syn::Data::Enum(_), Some(_), None) => Identifier::Field, (&syn::Data::Enum(_), Some(_), None) => Identifier::Field,
(&syn::Data::Enum(_), None, Some(_)) => Identifier::Variant, (&syn::Data::Enum(_), None, Some(_)) => Identifier::Variant,
(&syn::Data::Struct(syn::DataStruct { ref struct_token, .. }), Some(_), None) => { (
&syn::Data::Struct(syn::DataStruct {
ref struct_token, ..
}),
Some(_),
None,
) => {
cx.error_spanned_by( cx.error_spanned_by(
struct_token, struct_token,
"#[serde(field_identifier)] can only be used on an enum", "#[serde(field_identifier)] can only be used on an enum",
); );
Identifier::No Identifier::No
} }
(&syn::Data::Union(syn::DataUnion { ref union_token, .. }), Some(_), None) => { (
&syn::Data::Union(syn::DataUnion {
ref union_token, ..
}),
Some(_),
None,
) => {
cx.error_spanned_by( cx.error_spanned_by(
union_token, union_token,
"#[serde(field_identifier)] can only be used on an enum", "#[serde(field_identifier)] can only be used on an enum",
); );
Identifier::No Identifier::No
} }
(&syn::Data::Struct(syn::DataStruct { ref struct_token, .. }), None, Some(_)) => { (
&syn::Data::Struct(syn::DataStruct {
ref struct_token, ..
}),
None,
Some(_),
) => {
cx.error_spanned_by( cx.error_spanned_by(
struct_token, struct_token,
"#[serde(variant_identifier)] can only be used on an enum", "#[serde(variant_identifier)] can only be used on an enum",
); );
Identifier::No Identifier::No
} }
(&syn::Data::Union(syn::DataUnion { ref union_token, .. }), None, Some(_)) => { (
&syn::Data::Union(syn::DataUnion {
ref union_token, ..
}),
None,
Some(_),
) => {
cx.error_spanned_by( cx.error_spanned_by(
union_token, union_token,
"#[serde(variant_identifier)] can only be used on an enum", "#[serde(variant_identifier)] can only be used on an enum",
@@ -700,11 +754,14 @@ impl Variant {
if let Ok(s) = get_lit_str(cx, &m.ident, &m.ident, &m.lit) { if let Ok(s) = get_lit_str(cx, &m.ident, &m.ident, &m.lit) {
match RenameRule::from_str(&s.value()) { match RenameRule::from_str(&s.value()) {
Ok(rename_rule) => rename_all.set(&m.ident, rename_rule), Ok(rename_rule) => rename_all.set(&m.ident, rename_rule),
Err(()) => cx.error_spanned_by(s, format!( Err(()) => cx.error_spanned_by(
"unknown rename rule for #[serde(rename_all \ s,
= {:?})]", format!(
s.value() "unknown rename rule for #[serde(rename_all \
)), = {:?})]",
s.value()
),
),
} }
} }
} }
@@ -794,17 +851,14 @@ impl Variant {
}, },
Meta(ref meta_item) => { Meta(ref meta_item) => {
cx.error_spanned_by(meta_item.name(), format!( cx.error_spanned_by(
"unknown serde variant attribute `{}`", meta_item.name(),
meta_item.name() format!("unknown serde variant attribute `{}`", meta_item.name()),
)); );
} }
Literal(ref lit) => { Literal(ref lit) => {
cx.error_spanned_by( cx.error_spanned_by(lit, "unexpected literal in serde variant attribute");
lit,
"unexpected literal in serde variant attribute",
);
} }
} }
} }
@@ -1071,10 +1125,13 @@ impl Field {
if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) { if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
for lifetime in &lifetimes { for lifetime in &lifetimes {
if !borrowable.contains(lifetime) { if !borrowable.contains(lifetime) {
cx.error_spanned_by(field, format!( cx.error_spanned_by(
"field `{}` does not have lifetime {}", field,
ident, lifetime format!(
)); "field `{}` does not have lifetime {}",
ident, lifetime
),
);
} }
} }
borrowed_lifetimes.set(&m.ident, lifetimes); borrowed_lifetimes.set(&m.ident, lifetimes);
@@ -1095,17 +1152,14 @@ impl Field {
} }
Meta(ref meta_item) => { Meta(ref meta_item) => {
cx.error_spanned_by(meta_item.name(), format!( cx.error_spanned_by(
"unknown serde field attribute `{}`", meta_item.name(),
meta_item.name() format!("unknown serde field attribute `{}`", meta_item.name()),
)); );
} }
Literal(ref lit) => { Literal(ref lit) => {
cx.error_spanned_by( cx.error_spanned_by(lit, "unexpected literal in serde field attribute");
lit,
"unexpected literal in serde field attribute",
);
} }
} }
} }
@@ -1299,11 +1353,14 @@ where
} }
_ => { _ => {
cx.error_spanned_by(meta, format!( cx.error_spanned_by(
"malformed {0} attribute, expected `{0}(serialize = ..., \ meta,
deserialize = ...)`", format!(
attr_name "malformed {0} attribute, expected `{0}(serialize = ..., \
)); deserialize = ...)`",
attr_name
),
);
return Err(()); return Err(());
} }
} }
@@ -1349,21 +1406,22 @@ fn get_lit_str<'a>(
if let syn::Lit::Str(ref lit) = *lit { if let syn::Lit::Str(ref lit) = *lit {
Ok(lit) Ok(lit)
} else { } else {
cx.error_spanned_by(lit, format!( cx.error_spanned_by(
"expected serde {} attribute to be a string: `{} = \"...\"`", lit,
attr_name, meta_item_name format!(
)); "expected serde {} attribute to be a string: `{} = \"...\"`",
attr_name, meta_item_name
),
);
Err(()) Err(())
} }
} }
fn parse_lit_into_path(cx: &Ctxt, attr_name: &Ident, lit: &syn::Lit) -> Result<syn::Path, ()> { fn parse_lit_into_path(cx: &Ctxt, attr_name: &Ident, lit: &syn::Lit) -> Result<syn::Path, ()> {
let string = try!(get_lit_str(cx, attr_name, attr_name, lit)); let string = try!(get_lit_str(cx, attr_name, attr_name, lit));
parse_lit_str(string) parse_lit_str(string).map_err(|_| {
.map_err(|_| cx.error_spanned_by( cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()))
lit, })
format!("failed to parse path: {:?}", string.value()),
))
} }
fn parse_lit_into_expr_path( fn parse_lit_into_expr_path(
@@ -1372,11 +1430,9 @@ fn parse_lit_into_expr_path(
lit: &syn::Lit, lit: &syn::Lit,
) -> Result<syn::ExprPath, ()> { ) -> Result<syn::ExprPath, ()> {
let string = try!(get_lit_str(cx, attr_name, attr_name, lit)); let string = try!(get_lit_str(cx, attr_name, attr_name, lit));
parse_lit_str(string) parse_lit_str(string).map_err(|_| {
.map_err(|_| cx.error_spanned_by( cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()))
lit, })
format!("failed to parse path: {:?}", string.value()),
))
} }
fn parse_lit_into_where( fn parse_lit_into_where(
@@ -1401,11 +1457,10 @@ fn parse_lit_into_ty(cx: &Ctxt, attr_name: &Ident, lit: &syn::Lit) -> Result<syn
let string = try!(get_lit_str(cx, attr_name, attr_name, lit)); let string = try!(get_lit_str(cx, attr_name, attr_name, lit));
parse_lit_str(string).map_err(|_| { parse_lit_str(string).map_err(|_| {
cx.error_spanned_by(lit, format!( cx.error_spanned_by(
"failed to parse type: {} = {:?}", lit,
attr_name, format!("failed to parse type: {} = {:?}", attr_name, string.value()),
string.value() )
))
}) })
} }
@@ -1434,19 +1489,16 @@ fn parse_lit_into_lifetimes(
let mut set = BTreeSet::new(); let mut set = BTreeSet::new();
for lifetime in lifetimes { for lifetime in lifetimes {
if !set.insert(lifetime.clone()) { if !set.insert(lifetime.clone()) {
cx.error_spanned_by( cx.error_spanned_by(lit, format!("duplicate borrowed lifetime `{}`", lifetime));
lit,
format!("duplicate borrowed lifetime `{}`", lifetime),
);
} }
} }
return Ok(set); return Ok(set);
} }
cx.error_spanned_by(lit, format!( cx.error_spanned_by(
"failed to parse borrowed lifetimes: {:?}", lit,
string.value() format!("failed to parse borrowed lifetimes: {:?}", string.value()),
)); );
Err(()) Err(())
} }
serde_derive/src/internals/check.rs
+53 -33
View File
@@ -198,52 +198,67 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
for variant in variants.iter() { for variant in variants.iter() {
if variant.attrs.serialize_with().is_some() { if variant.attrs.serialize_with().is_some() {
if variant.attrs.skip_serializing() { if variant.attrs.skip_serializing() {
cx.error_spanned_by(variant.original, format!( cx.error_spanned_by(
"variant `{}` cannot have both #[serde(serialize_with)] and \ variant.original,
#[serde(skip_serializing)]", format!(
variant.ident "variant `{}` cannot have both #[serde(serialize_with)] and \
)); #[serde(skip_serializing)]",
variant.ident
),
);
} }
for field in &variant.fields { for field in &variant.fields {
let member = member_message(&field.member); let member = member_message(&field.member);
if field.attrs.skip_serializing() { if field.attrs.skip_serializing() {
cx.error_spanned_by(variant.original, format!( cx.error_spanned_by(
"variant `{}` cannot have both #[serde(serialize_with)] and \ variant.original,
a field {} marked with #[serde(skip_serializing)]", format!(
variant.ident, member "variant `{}` cannot have both #[serde(serialize_with)] and \
)); a field {} marked with #[serde(skip_serializing)]",
variant.ident, member
),
);
} }
if field.attrs.skip_serializing_if().is_some() { if field.attrs.skip_serializing_if().is_some() {
cx.error_spanned_by(variant.original, format!( cx.error_spanned_by(
"variant `{}` cannot have both #[serde(serialize_with)] and \ variant.original,
a field {} marked with #[serde(skip_serializing_if)]", format!(
variant.ident, member "variant `{}` cannot have both #[serde(serialize_with)] and \
)); a field {} marked with #[serde(skip_serializing_if)]",
variant.ident, member
),
);
} }
} }
} }
if variant.attrs.deserialize_with().is_some() { if variant.attrs.deserialize_with().is_some() {
if variant.attrs.skip_deserializing() { if variant.attrs.skip_deserializing() {
cx.error_spanned_by(variant.original, format!( cx.error_spanned_by(
"variant `{}` cannot have both #[serde(deserialize_with)] and \ variant.original,
#[serde(skip_deserializing)]", format!(
variant.ident "variant `{}` cannot have both #[serde(deserialize_with)] and \
)); #[serde(skip_deserializing)]",
variant.ident
),
);
} }
for field in &variant.fields { for field in &variant.fields {
if field.attrs.skip_deserializing() { if field.attrs.skip_deserializing() {
let member = member_message(&field.member); let member = member_message(&field.member);
cx.error_spanned_by(variant.original, format!( cx.error_spanned_by(
"variant `{}` cannot have both #[serde(deserialize_with)] \ variant.original,
and a field {} marked with #[serde(skip_deserializing)]", format!(
variant.ident, member "variant `{}` cannot have both #[serde(deserialize_with)] \
)); and a field {} marked with #[serde(skip_deserializing)]",
variant.ident, member
),
);
} }
} }
} }
@@ -265,10 +280,12 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
EnumTag::External | EnumTag::Adjacent { .. } | EnumTag::None => return, EnumTag::External | EnumTag::Adjacent { .. } | EnumTag::None => return,
}; };
let diagnose_conflict = || cx.error_spanned_by( let diagnose_conflict = || {
cont.original, cx.error_spanned_by(
format!("variant field name `{}` conflicts with internal tag", tag), cont.original,
); format!("variant field name `{}` conflicts with internal tag", tag),
)
};
for variant in variants { for variant in variants {
match variant.style { match variant.style {
@@ -303,10 +320,13 @@ fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
}; };
if type_tag == content_tag { if type_tag == content_tag {
cx.error_spanned_by(cont.original, format!( cx.error_spanned_by(
"enum tags `{}` for type and content conflict with each other", cont.original,
type_tag format!(
)); "enum tags `{}` for type and content conflict with each other",
type_tag
),
);
} }
} }
serde_derive/src/ser.rs
+1 -1
View File
@@ -206,7 +206,7 @@ fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
None => { None => {
let span = transparent_field.original.span(); let span = transparent_field.original.span();
quote_spanned!(span=> _serde::Serialize::serialize) quote_spanned!(span=> _serde::Serialize::serialize)
}, }
}; };
quote_block! { quote_block! {
test_suite/tests/test_annotations.rs
+4 -8
View File
@@ -96,10 +96,8 @@ where
#[derive(Debug, PartialEq, Serialize, Deserialize)] #[derive(Debug, PartialEq, Serialize, Deserialize)]
struct DefaultTupleStruct<A, B, C>( struct DefaultTupleStruct<A, B, C>(
A, A,
#[serde(default)] #[serde(default)] B,
B, #[serde(default = "MyDefault::my_default")] C,
#[serde(default = "MyDefault::my_default")]
C,
) )
where where
C: MyDefault; C: MyDefault;
@@ -252,10 +250,8 @@ where
{ {
Tuple( Tuple(
A, A,
#[serde(default)] #[serde(default)] B,
B, #[serde(default = "MyDefault::my_default")] C,
#[serde(default = "MyDefault::my_default")]
C,
), ),
} }