mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions 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
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
6 changed files with 230 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
serde_derive/src/de.rs
View File

@ -89,7 +89,10 @@ fn precondition_sized(cx: &Ctxt, cont: &Container) {
if let Data::Struct(_, ref fields) = cont.data {
if let Some(last) = fields.last() {
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 => {
let span = transparent_field.original.span();
quote_spanned!(span=> _serde::Deserialize::deserialize)
},
}
};
let assign = fields.iter().map(|field| {
@ -1830,7 +1833,8 @@ fn deserialize_externally_tagged_newtype_variant(
None => {
let field_ty = field.ty;
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! {
_serde::export::Result::map(#func(__variant), #this::#variant_ident)
}
@ -2470,7 +2474,7 @@ fn deserialize_map(
None => {
let span = field.original.span();
quote_spanned!(span=> _serde::de::Deserialize::deserialize)
},
}
Some(path) => quote!(#path),
};
quote! {

6
serde_derive/src/internals/ast.rs
View File

@ -60,7 +60,11 @@ pub enum Style {
impl<'a> Container<'a> {
/// 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 data = match item.data {

266
serde_derive/src/internals/attr.rs
View File

@ -42,10 +42,8 @@ impl<'c, T> Attr<'c, T> {
let tokens = obj.into_token_stream();
if self.value.is_some() {
self.cx.error_spanned_by(
tokens,
format!("duplicate serde attribute `{}`", self.name),
);
self.cx
.error_spanned_by(tokens, format!("duplicate serde attribute `{}`", self.name));
} else {
self.tokens = tokens;
self.value = Some(value);
@ -71,7 +69,7 @@ impl<'c, T> Attr<'c, T> {
fn get_with_tokens(self) -> Option<(TokenStream, T)> {
match self.value {
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) {
match RenameRule::from_str(&s.value()) {
Ok(rename_rule) => rename_all.set(&m.ident, rename_rule),
Err(()) => cx.error_spanned_by(s, format!(
"unknown rename rule for #[serde(rename_all \
= {:?})]",
s.value(),
)),
Err(()) => cx.error_spanned_by(
s,
format!(
"unknown rename rule for #[serde(rename_all \
= {:?})]",
s.value(),
),
),
}
}
}
@ -261,14 +262,17 @@ impl Container {
fields,
"#[serde(default)] can only be used on structs \
with named fields",
)
),
},
syn::Data::Enum(syn::DataEnum { ref 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::Enum(syn::DataEnum { ref 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(
union_token,
"#[serde(default)] can only be used on structs \
with named fields",
@ -279,22 +283,28 @@ impl Container {
Meta(NameValue(ref m)) if m.ident == "default" => {
if let Ok(path) = parse_lit_into_expr_path(cx, &m.ident, &m.lit) {
match item.data {
syn::Data::Struct(syn::DataStruct { ref fields, .. }) => match *fields {
syn::Fields::Named(_) => {
default.set(&m.ident, Default::Path(path));
syn::Data::Struct(syn::DataStruct { ref fields, .. }) => {
match *fields {
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 \
on structs with named fields",
)
},
syn::Data::Enum(syn::DataEnum { ref 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 {
ref union_token, ..
}) => cx.error_spanned_by(
union_token,
"#[serde(default = \"...\")] can only be used \
on structs with named fields",
@ -326,13 +336,17 @@ impl Container {
syn::Data::Enum(_) => {
untagged.set_true(word);
}
syn::Data::Struct(syn::DataStruct { ref struct_token, .. }) => {
syn::Data::Struct(syn::DataStruct {
ref 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 {
ref union_token, ..
}) => {
cx.error_spanned_by(
union_token,
"#[serde(untagged)] can only be used on enums",
@ -347,18 +361,22 @@ impl Container {
syn::Data::Enum(_) => {
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(
struct_token,
"#[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(
union_token,
"#[serde(tag = \"...\")] can only be used on enums",
);
},
}
}
}
}
@ -370,18 +388,22 @@ impl Container {
syn::Data::Enum(_) => {
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(
struct_token,
"#[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(
union_token,
"#[serde(content = \"...\")] can only be used on enums",
);
},
}
}
}
}
@ -422,10 +444,10 @@ impl Container {
}
Meta(ref meta_item) => {
cx.error_spanned_by(meta_item.name(), format!(
"unknown serde container attribute `{}`",
meta_item.name()
));
cx.error_spanned_by(
meta_item.name(),
format!("unknown serde container attribute `{}`", meta_item.name()),
);
}
Literal(ref lit) => {
@ -519,7 +541,11 @@ fn decide_tag(
internal_tag: Attr<String>,
content: Attr<String>,
) -> 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,
(Some(_), None, None) => EnumTag::None,
(None, Some((_, tag)), None) => {
@ -600,7 +626,11 @@ fn decide_identifier(
field_identifier: BoolAttr,
variant_identifier: BoolAttr,
) -> 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,
(_, Some((field_identifier_tokens, _)), Some((variant_identifier_tokens, _))) => {
cx.error_spanned_by(
@ -615,28 +645,52 @@ fn decide_identifier(
}
(&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::Struct(syn::DataStruct {
ref 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 {
ref 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 {
ref 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 {
ref union_token, ..
}),
None,
Some(_),
) => {
cx.error_spanned_by(
union_token,
"#[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) {
match RenameRule::from_str(&s.value()) {
Ok(rename_rule) => rename_all.set(&m.ident, rename_rule),
Err(()) => cx.error_spanned_by(s, format!(
"unknown rename rule for #[serde(rename_all \
= {:?})]",
s.value()
)),
Err(()) => cx.error_spanned_by(
s,
format!(
"unknown rename rule for #[serde(rename_all \
= {:?})]",
s.value()
),
),
}
}
}
@ -794,17 +851,14 @@ impl Variant {
},
Meta(ref meta_item) => {
cx.error_spanned_by(meta_item.name(), format!(
"unknown serde variant attribute `{}`",
meta_item.name()
));
cx.error_spanned_by(
meta_item.name(),
format!("unknown serde variant attribute `{}`", meta_item.name()),
);
}
Literal(ref lit) => {
cx.error_spanned_by(
lit,
"unexpected literal in serde variant attribute",
);
cx.error_spanned_by(lit, "unexpected literal in serde variant attribute");
}
}
}
@ -1071,10 +1125,13 @@ impl Field {
if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
for lifetime in &lifetimes {
if !borrowable.contains(lifetime) {
cx.error_spanned_by(field, format!(
"field `{}` does not have lifetime {}",
ident, lifetime
));
cx.error_spanned_by(
field,
format!(
"field `{}` does not have lifetime {}",
ident, lifetime
),
);
}
}
borrowed_lifetimes.set(&m.ident, lifetimes);
@ -1095,17 +1152,14 @@ impl Field {
}
Meta(ref meta_item) => {
cx.error_spanned_by(meta_item.name(), format!(
"unknown serde field attribute `{}`",
meta_item.name()
));
cx.error_spanned_by(
meta_item.name(),
format!("unknown serde field attribute `{}`", meta_item.name()),
);
}
Literal(ref lit) => {
cx.error_spanned_by(
lit,
"unexpected literal in serde field attribute",
);
cx.error_spanned_by(lit, "unexpected literal in serde field attribute");
}
}
}
@ -1299,11 +1353,14 @@ where
}
_ => {
cx.error_spanned_by(meta, format!(
"malformed {0} attribute, expected `{0}(serialize = ..., \
deserialize = ...)`",
attr_name
));
cx.error_spanned_by(
meta,
format!(
"malformed {0} attribute, expected `{0}(serialize = ..., \
deserialize = ...)`",
attr_name
),
);
return Err(());
}
}
@ -1349,21 +1406,22 @@ fn get_lit_str<'a>(
if let syn::Lit::Str(ref lit) = *lit {
Ok(lit)
} else {
cx.error_spanned_by(lit, format!(
"expected serde {} attribute to be a string: `{} = \"...\"`",
attr_name, meta_item_name
));
cx.error_spanned_by(
lit,
format!(
"expected serde {} attribute to be a string: `{} = \"...\"`",
attr_name, meta_item_name
),
);
Err(())
}
}
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));
parse_lit_str(string)
.map_err(|_| cx.error_spanned_by(
lit,
format!("failed to parse path: {:?}", string.value()),
))
parse_lit_str(string).map_err(|_| {
cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()))
})
}
fn parse_lit_into_expr_path(
@ -1372,11 +1430,9 @@ fn parse_lit_into_expr_path(
lit: &syn::Lit,
) -> Result<syn::ExprPath, ()> {
let string = try!(get_lit_str(cx, attr_name, attr_name, lit));
parse_lit_str(string)
.map_err(|_| cx.error_spanned_by(
lit,
format!("failed to parse path: {:?}", string.value()),
))
parse_lit_str(string).map_err(|_| {
cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()))
})
}
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));
parse_lit_str(string).map_err(|_| {
cx.error_spanned_by(lit, format!(
"failed to parse type: {} = {:?}",
attr_name,
string.value()
))
cx.error_spanned_by(
lit,
format!("failed to parse type: {} = {:?}", attr_name, string.value()),
)
})
}
@ -1434,19 +1489,16 @@ fn parse_lit_into_lifetimes(
let mut set = BTreeSet::new();
for lifetime in lifetimes {
if !set.insert(lifetime.clone()) {
cx.error_spanned_by(
lit,
format!("duplicate borrowed lifetime `{}`", lifetime),
);
cx.error_spanned_by(lit, format!("duplicate borrowed lifetime `{}`", lifetime));
}
}
return Ok(set);
}
cx.error_spanned_by(lit, format!(
"failed to parse borrowed lifetimes: {:?}",
string.value()
));
cx.error_spanned_by(
lit,
format!("failed to parse borrowed lifetimes: {:?}", string.value()),
);
Err(())
}

86
serde_derive/src/internals/check.rs
View File

@ -198,52 +198,67 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
for variant in variants.iter() {
if variant.attrs.serialize_with().is_some() {
if variant.attrs.skip_serializing() {
cx.error_spanned_by(variant.original, format!(
"variant `{}` cannot have both #[serde(serialize_with)] and \
#[serde(skip_serializing)]",
variant.ident
));
cx.error_spanned_by(
variant.original,
format!(
"variant `{}` cannot have both #[serde(serialize_with)] and \
#[serde(skip_serializing)]",
variant.ident
),
);
}
for field in &variant.fields {
let member = member_message(&field.member);
if field.attrs.skip_serializing() {
cx.error_spanned_by(variant.original, format!(
"variant `{}` cannot have both #[serde(serialize_with)] and \
a field {} marked with #[serde(skip_serializing)]",
variant.ident, member
));
cx.error_spanned_by(
variant.original,
format!(
"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() {
cx.error_spanned_by(variant.original, format!(
"variant `{}` cannot have both #[serde(serialize_with)] and \
a field {} marked with #[serde(skip_serializing_if)]",
variant.ident, member
));
cx.error_spanned_by(
variant.original,
format!(
"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.skip_deserializing() {
cx.error_spanned_by(variant.original, format!(
"variant `{}` cannot have both #[serde(deserialize_with)] and \
#[serde(skip_deserializing)]",
variant.ident
));
cx.error_spanned_by(
variant.original,
format!(
"variant `{}` cannot have both #[serde(deserialize_with)] and \
#[serde(skip_deserializing)]",
variant.ident
),
);
}
for field in &variant.fields {
if field.attrs.skip_deserializing() {
let member = member_message(&field.member);
cx.error_spanned_by(variant.original, format!(
"variant `{}` cannot have both #[serde(deserialize_with)] \
and a field {} marked with #[serde(skip_deserializing)]",
variant.ident, member
));
cx.error_spanned_by(
variant.original,
format!(
"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,
};
let diagnose_conflict = || cx.error_spanned_by(
cont.original,
format!("variant field name `{}` conflicts with internal tag", tag),
);
let diagnose_conflict = || {
cx.error_spanned_by(
cont.original,
format!("variant field name `{}` conflicts with internal tag", tag),
)
};
for variant in variants {
match variant.style {
@ -303,10 +320,13 @@ fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
};
if type_tag == content_tag {
cx.error_spanned_by(cont.original, format!(
"enum tags `{}` for type and content conflict with each other",
type_tag
));
cx.error_spanned_by(
cont.original,
format!(
"enum tags `{}` for type and content conflict with each other",
type_tag
),
);
}
}

2
serde_derive/src/ser.rs
View File

@ -206,7 +206,7 @@ fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
None => {
let span = transparent_field.original.span();
quote_spanned!(span=> _serde::Serialize::serialize)
},
}
};
quote_block! {

12
test_suite/tests/test_annotations.rs
View File

@ -96,10 +96,8 @@ where
#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct DefaultTupleStruct<A, B, C>(
A,
#[serde(default)]
B,
#[serde(default = "MyDefault::my_default")]
C,
#[serde(default)] B,
#[serde(default = "MyDefault::my_default")] C,
)
where
C: MyDefault;
@ -252,10 +250,8 @@ where
{
Tuple(
A,
#[serde(default)]
B,
#[serde(default = "MyDefault::my_default")]
C,
#[serde(default)] B,
#[serde(default = "MyDefault::my_default")] C,
),
}