pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-07-19 20:25:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format with rustfmt-nightly 0.3.4

Browse Source
This commit is contained in:
David Tolnay
2017-12-23 20:13:08 -08:00
parent c2b390fe63
commit ee75e6c0e9
32 changed files with 2035 additions and 1894 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde/src/de/ignored_any.rs
+1 -1
View File
@@ -8,7 +8,7 @@
use lib::*;
use de::{Deserialize, Deserializer, Visitor, SeqAccess, MapAccess, Error};
use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
/// An efficient way of discarding data from a deserializer.
///
serde/src/de/impls.rs
+57 -27
View File
@@ -52,7 +52,6 @@ impl<'de> Deserialize<'de> for () {
struct BoolVisitor;
impl<'de> Visitor<'de> for BoolVisitor {
type Value = bool;
@@ -253,7 +252,10 @@ impl<'de> Visitor<'de> for StringVisitor {
{
match String::from_utf8(v) {
Ok(s) => Ok(s),
Err(e) => Err(Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self),),
Err(e) => Err(Error::invalid_value(
Unexpected::Bytes(&e.into_bytes()),
&self,
)),
}
}
}
@@ -306,7 +308,10 @@ impl<'a, 'de> Visitor<'de> for StringInPlaceVisitor<'a> {
*self.0 = s;
Ok(())
}
Err(e) => Err(Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self),),
Err(e) => Err(Error::invalid_value(
Unexpected::Bytes(&e.into_bytes()),
&self,
)),
}
}
}
@@ -529,7 +534,9 @@ where
where
D: Deserializer<'de>,
{
deserializer.deserialize_option(OptionVisitor { marker: PhantomData })
deserializer.deserialize_option(OptionVisitor {
marker: PhantomData,
})
}
// The Some variant's repr is opaque, so we can't play cute tricks with its
@@ -566,7 +573,9 @@ impl<'de, T> Deserialize<'de> for PhantomData<T> {
where
D: Deserializer<'de>,
{
let visitor = PhantomDataVisitor { marker: PhantomData };
let visitor = PhantomDataVisitor {
marker: PhantomData,
};
deserializer.deserialize_unit_struct("PhantomData", visitor)
}
}
@@ -699,7 +708,8 @@ seq_impl!(
LinkedList::clear,
LinkedList::new(),
nop_reserve,
LinkedList::push_back);
LinkedList::push_back
);
#[cfg(feature = "std")]
seq_impl!(
@@ -719,7 +729,8 @@ seq_impl!(
Vec::clear,
Vec::with_capacity(size_hint::cautious(seq.size_hint())),
Vec::reserve,
Vec::push);
Vec::push
);
#[cfg(any(feature = "std", feature = "alloc"))]
seq_impl!(
@@ -729,7 +740,8 @@ seq_impl!(
VecDeque::clear,
VecDeque::with_capacity(size_hint::cautious(seq.size_hint())),
VecDeque::reserve,
VecDeque::push_back);
VecDeque::push_back
);
////////////////////////////////////////////////////////////////////////////////
@@ -740,7 +752,9 @@ struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
impl<A> ArrayVisitor<A> {
fn new() -> Self {
ArrayVisitor { marker: PhantomData }
ArrayVisitor {
marker: PhantomData,
}
}
}
@@ -1257,7 +1271,12 @@ impl<'de> Deserialize<'de> for net::SocketAddr {
parse_socket_impl!(net::SocketAddrV4, net::SocketAddrV4::new);
#[cfg(feature = "std")]
parse_socket_impl!(net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(ip, port, 0, 0));
parse_socket_impl!(net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(
ip,
port,
0,
0
));
////////////////////////////////////////////////////////////////////////////////
@@ -1368,7 +1387,9 @@ impl<'de> Visitor<'de> for OsStringVisitor {
match try!(data.variant()) {
(OsStringKind::Unix, v) => v.newtype_variant().map(OsString::from_vec),
(OsStringKind::Windows, _) => Err(Error::custom("cannot deserialize Windows OS string on Unix",),),
(OsStringKind::Windows, _) => Err(Error::custom(
"cannot deserialize Windows OS string on Unix",
)),
}
}
@@ -1380,11 +1401,11 @@ impl<'de> Visitor<'de> for OsStringVisitor {
use std::os::windows::ffi::OsStringExt;
match try!(data.variant()) {
(OsStringKind::Windows, v) => {
v.newtype_variant::<Vec<u16>>()
.map(|vec| OsString::from_wide(&vec))
}
(OsStringKind::Unix, _) => Err(Error::custom("cannot deserialize Unix OS string on Windows",),),
(OsStringKind::Windows, v) => v.newtype_variant::<Vec<u16>>()
.map(|vec| OsString::from_wide(&vec)),
(OsStringKind::Unix, _) => Err(Error::custom(
"cannot deserialize Unix OS string on Windows",
)),
}
}
}
@@ -1710,13 +1731,17 @@ impl<'de> Deserialize<'de> for SystemTime {
match key {
Field::Secs => {
if secs.is_some() {
return Err(<A::Error as Error>::duplicate_field("secs_since_epoch"));
return Err(<A::Error as Error>::duplicate_field(
"secs_since_epoch",
));
}
secs = Some(try!(map.next_value()));
}
Field::Nanos => {
if nanos.is_some() {
return Err(<A::Error as Error>::duplicate_field("nanos_since_epoch"));
return Err(<A::Error as Error>::duplicate_field(
"nanos_since_epoch",
));
}
nanos = Some(try!(map.next_value()));
}
@@ -1880,7 +1905,13 @@ where
}
const FIELDS: &'static [&'static str] = &["start", "end"];
deserializer.deserialize_struct("Range", FIELDS, RangeVisitor { phantom: PhantomData })
deserializer.deserialize_struct(
"Range",
FIELDS,
RangeVisitor {
phantom: PhantomData,
},
)
}
}
@@ -1945,9 +1976,10 @@ where
match value {
0 => Ok(Field::Ok),
1 => Ok(Field::Err),
_ => {
Err(Error::invalid_value(Unexpected::Unsigned(value as u64), &self),)
}
_ => Err(Error::invalid_value(
Unexpected::Unsigned(value as u64),
&self,
)),
}
}
@@ -1969,14 +2001,12 @@ where
match value {
b"Ok" => Ok(Field::Ok),
b"Err" => Ok(Field::Err),
_ => {
match str::from_utf8(value) {
_ => match str::from_utf8(value) {
Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
Err(_) => {
Err(Error::invalid_value(Unexpected::Bytes(value), &self))
}
}
}
},
}
}
}
@@ -2020,7 +2050,7 @@ where
#[cfg(feature = "std")]
impl<'de, T> Deserialize<'de> for Wrapping<T>
where
T: Deserialize<'de>
T: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Wrapping<T>, D::Error>
where
serde/src/de/mod.rs
+5 -2
View File
@@ -526,7 +526,8 @@ pub trait Deserialize<'de>: Sized {
/// than it deserves.
#[doc(hidden)]
fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
// Default implementation just delegates to `deserialize` impl.
*place = Deserialize::deserialize(deserializer)?;
@@ -1106,7 +1107,9 @@ pub trait Deserializer<'de>: Sized {
/// change, as a value serialized in human-readable mode is not required to
/// deserialize from the same data in compact mode.
#[inline]
fn is_human_readable(&self) -> bool { true }
fn is_human_readable(&self) -> bool {
true
}
}
////////////////////////////////////////////////////////////////////////////////
serde/src/de/value.rs
+34 -14
View File
@@ -37,7 +37,7 @@
use lib::*;
use de::{self, IntoDeserializer, Expected, SeqAccess};
use de::{self, Expected, IntoDeserializer, SeqAccess};
use private::de::size_hint;
use ser;
use self::private::{First, Second};
@@ -62,7 +62,9 @@ impl de::Error for Error {
where
T: Display,
{
Error { err: msg.to_string().into_boxed_str() }
Error {
err: msg.to_string().into_boxed_str(),
}
}
#[cfg(not(any(feature = "std", feature = "alloc")))]
@@ -112,7 +114,9 @@ where
type Deserializer = UnitDeserializer<E>;
fn into_deserializer(self) -> UnitDeserializer<E> {
UnitDeserializer { marker: PhantomData }
UnitDeserializer {
marker: PhantomData,
}
}
}
@@ -658,7 +662,10 @@ where
} else {
// First argument is the number of elements in the data, second
// argument is the number of elements expected by the Deserialize.
Err(de::Error::invalid_length(self.count + remaining, &ExpectedInSeq(self.count)),)
Err(de::Error::invalid_length(
self.count + remaining,
&ExpectedInSeq(self.count),
))
}
}
}
@@ -852,7 +859,10 @@ where
} else {
// First argument is the number of elements in the data, second
// argument is the number of elements expected by the Deserialize.
Err(de::Error::invalid_length(self.count + remaining, &ExpectedInMap(self.count)),)
Err(de::Error::invalid_length(
self.count + remaining,
&ExpectedInMap(self.count),
))
}
}
}
@@ -901,11 +911,7 @@ where
Ok(value)
}
fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<V::Value, Self::Error>
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
@@ -1223,7 +1229,12 @@ mod private {
}
pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
(t, UnitOnly { marker: PhantomData })
(
t,
UnitOnly {
marker: PhantomData,
},
)
}
impl<'de, E> de::VariantAccess<'de> for UnitOnly<E>
@@ -1240,14 +1251,20 @@ mod private {
where
T: de::DeserializeSeed<'de>,
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),)
Err(de::Error::invalid_type(
Unexpected::UnitVariant,
&"newtype variant",
))
}
fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),)
Err(de::Error::invalid_type(
Unexpected::UnitVariant,
&"tuple variant",
))
}
fn struct_variant<V>(
@@ -1258,7 +1275,10 @@ mod private {
where
V: de::Visitor<'de>,
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),)
Err(de::Error::invalid_type(
Unexpected::UnitVariant,
&"struct variant",
))
}
}
serde/src/export.rs
+1 -1
View File
@@ -12,7 +12,7 @@ pub use lib::default::Default;
pub use lib::fmt::{self, Formatter};
pub use lib::marker::PhantomData;
pub use lib::option::Option::{self, None, Some};
pub use lib::result::Result::{self, Ok, Err};
pub use lib::result::Result::{self, Err, Ok};
pub use self::string::from_utf8_lossy;
serde/src/lib.rs
+10 -20
View File
@@ -80,29 +80,20 @@
// Serde types in rustdoc of other crates get linked to here.
#![doc(html_root_url = "https://docs.rs/serde/1.0.24")]
// Support using Serde without the standard library!
#![cfg_attr(not(feature = "std"), no_std)]
// Unstable functionality only if the user asks for it. For tracking and
// discussion of these features please refer to this issue:
//
// https://github.com/serde-rs/serde/issues/812
#![cfg_attr(feature = "unstable", feature(nonzero, specialization))]
#![cfg_attr(feature = "alloc", feature(alloc))]
#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
// Whitelisted clippy lints
#![cfg_attr(feature = "cargo-clippy", allow(
cast_lossless,
const_static_lifetime,
doc_markdown,
linkedlist,
needless_pass_by_value,
type_complexity,
unreadable_literal,
zero_prefixed_literal,
))]
#![cfg_attr(feature = "cargo-clippy",
allow(cast_lossless, const_static_lifetime, doc_markdown, linkedlist,
needless_pass_by_value, type_complexity, unreadable_literal,
zero_prefixed_literal))]
// Whitelisted clippy_pedantic lints
#![cfg_attr(feature = "cargo-clippy", allow(
// integer and float ser/de requires these sorts of casts
@@ -125,7 +116,6 @@
empty_enum,
use_debug,
))]
// Blacklisted Rust lints.
#![deny(missing_docs, unused_imports)]
@@ -149,8 +139,8 @@ mod lib {
}
pub use self::core::{cmp, iter, mem, ops, slice, str};
pub use self::core::{i8, i16, i32, i64, isize};
pub use self::core::{u8, u16, u32, u64, usize};
pub use self::core::{isize, i16, i32, i64, i8};
pub use self::core::{usize, u16, u32, u64, u8};
pub use self::core::{f32, f64};
pub use self::core::cell::{Cell, RefCell};
@@ -193,9 +183,9 @@ mod lib {
pub use alloc::arc::Arc;
#[cfg(feature = "std")]
pub use std::collections::{BinaryHeap, BTreeMap, BTreeSet, LinkedList, VecDeque};
pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
#[cfg(all(feature = "alloc", not(feature = "std")))]
pub use alloc::{BinaryHeap, BTreeMap, BTreeSet, LinkedList, VecDeque};
pub use alloc::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
#[cfg(feature = "std")]
pub use std::{error, net};
@@ -203,9 +193,9 @@ mod lib {
#[cfg(feature = "std")]
pub use std::collections::{HashMap, HashSet};
#[cfg(feature = "std")]
pub use std::ffi::{CString, CStr, OsString, OsStr};
pub use std::ffi::{CStr, CString, OsStr, OsString};
#[cfg(feature = "std")]
pub use std::hash::{Hash, BuildHasher};
pub use std::hash::{BuildHasher, Hash};
#[cfg(feature = "std")]
pub use std::io::Write;
#[cfg(feature = "std")]
serde/src/private/de.rs
+123 -87
View File
@@ -8,16 +8,16 @@
use lib::*;
use de::{Deserialize, Deserializer, DeserializeSeed, IntoDeserializer, Error, Visitor};
use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor};
#[cfg(any(feature = "std", feature = "alloc"))]
use de::Unexpected;
#[cfg(any(feature = "std", feature = "alloc"))]
pub use self::content::{Content, ContentRefDeserializer, ContentDeserializer,
TaggedContentVisitor, TagOrContentField, TagOrContentFieldVisitor,
TagContentOtherField, TagContentOtherFieldVisitor,
InternallyTaggedUnitVisitor, UntaggedUnitVisitor};
pub use self::content::{Content, ContentDeserializer, ContentRefDeserializer,
InternallyTaggedUnitVisitor, TagContentOtherField,
TagContentOtherFieldVisitor, TagOrContentField, TagOrContentFieldVisitor,
TaggedContentVisitor, UntaggedUnitVisitor};
/// If the missing field is of type `Option<T>` then treat is as `None`,
/// otherwise it is an error.
@@ -120,7 +120,10 @@ where
{
match String::from_utf8(v) {
Ok(s) => Ok(Cow::Owned(s)),
Err(e) => Err(Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self),),
Err(e) => Err(Error::invalid_value(
Unexpected::Bytes(&e.into_bytes()),
&self,
)),
}
}
}
@@ -225,8 +228,8 @@ mod content {
use lib::*;
use de::{self, Deserialize, DeserializeSeed, Deserializer, Visitor, SeqAccess, MapAccess,
EnumAccess, Unexpected};
use de::{self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, MapAccess, SeqAccess,
Unexpected, Visitor};
use super::size_hint;
/// Used from generated code to buffer the contents of the Deserializer when
@@ -502,7 +505,9 @@ mod content {
where
V: EnumAccess<'de>,
{
Err(de::Error::custom("untagged and internally tagged enums do not support enum input",),)
Err(de::Error::custom(
"untagged and internally tagged enums do not support enum input",
))
}
}
@@ -521,7 +526,10 @@ mod content {
impl<'de> TagOrContentVisitor<'de> {
fn new(name: &'static str) -> Self {
TagOrContentVisitor { name: name, value: PhantomData }
TagOrContentVisitor {
name: name,
value: PhantomData,
}
}
}
@@ -558,7 +566,9 @@ mod content {
where
F: de::Error,
{
ContentVisitor::new().visit_i8(value).map(TagOrContent::Content)
ContentVisitor::new()
.visit_i8(value)
.map(TagOrContent::Content)
}
fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
@@ -592,7 +602,9 @@ mod content {
where
F: de::Error,
{
ContentVisitor::new().visit_u8(value).map(TagOrContent::Content)
ContentVisitor::new()
.visit_u8(value)
.map(TagOrContent::Content)
}
fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
@@ -731,14 +743,18 @@ mod content {
where
F: de::Error,
{
ContentVisitor::new().visit_unit().map(TagOrContent::Content)
ContentVisitor::new()
.visit_unit()
.map(TagOrContent::Content)
}
fn visit_none<F>(self) -> Result<Self::Value, F>
where
F: de::Error,
{
ContentVisitor::new().visit_none().map(TagOrContent::Content)
ContentVisitor::new()
.visit_none()
.map(TagOrContent::Content)
}
fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
@@ -861,8 +877,7 @@ mod content {
{
let mut tag = None;
let mut vec = Vec::with_capacity(size_hint::cautious(map.size_hint()));
while let Some(k) =
try!(map.next_key_seed(TagOrContentVisitor::new(self.tag_name))) {
while let Some(k) = try!(map.next_key_seed(TagOrContentVisitor::new(self.tag_name))) {
match k {
TagOrContent::Tag => {
if tag.is_some() {
@@ -878,14 +893,10 @@ mod content {
}
match tag {
None => Err(de::Error::missing_field(self.tag_name)),
Some(tag) => {
Ok(
TaggedContent {
Some(tag) => Ok(TaggedContent {
tag: tag,
content: Content::Map(vec),
},
)
}
}),
}
}
}
@@ -967,7 +978,11 @@ mod content {
type Value = TagContentOtherField;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "{:?}, {:?}, or other ignored fields", self.tag, self.content)
write!(
formatter,
"{:?}, {:?}, or other ignored fields",
self.tag, self.content
)
}
fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
@@ -1031,10 +1046,8 @@ mod content {
Ok(value)
}
Content::Map(v) => {
let map = v.into_iter().map(|(k, v)| {
(ContentDeserializer::new(k),
ContentDeserializer::new(v))
});
let map = v.into_iter()
.map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
let mut map_visitor = de::value::MapDeserializer::new(map);
let value = try!(visitor.visit_map(&mut map_visitor));
try!(map_visitor.end());
@@ -1081,44 +1094,41 @@ mod content {
let (variant, value) = match iter.next() {
Some(v) => v,
None => {
return Err(
de::Error::invalid_value(
return Err(de::Error::invalid_value(
de::Unexpected::Map,
&"map with a single key",
),
);
));
}
};
// enums are encoded in json as maps with a single key:value pair
if iter.next().is_some() {
return Err(
de::Error::invalid_value(
return Err(de::Error::invalid_value(
de::Unexpected::Map,
&"map with a single key",
),
);
));
}
(variant, Some(value))
}
s @ Content::String(_) | s @ Content::Str(_) => (s, None),
other => {
return Err(de::Error::invalid_type(other.unexpected(), &"string or map"),);
return Err(de::Error::invalid_type(
other.unexpected(),
&"string or map",
));
}
};
visitor.visit_enum(
EnumDeserializer {
visitor.visit_enum(EnumDeserializer {
variant: variant,
value: value,
err: PhantomData,
},
)
})
}
fn deserialize_unit_struct<V>(
self,
_name: &'static str,
visitor: V
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
@@ -1216,9 +1226,10 @@ mod content {
{
match self.value {
Some(value) => seed.deserialize(ContentDeserializer::new(value)),
None => {
Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"newtype variant"),)
}
None => Err(de::Error::invalid_type(
de::Unexpected::UnitVariant,
&"newtype variant",
)),
}
}
@@ -1230,8 +1241,14 @@ mod content {
Some(Content::Seq(v)) => {
de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant"),),
None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant"),),
Some(other) => Err(de::Error::invalid_type(
other.unexpected(),
&"tuple variant",
)),
None => Err(de::Error::invalid_type(
de::Unexpected::UnitVariant,
&"tuple variant",
)),
}
}
@@ -1250,8 +1267,14 @@ mod content {
Some(Content::Seq(v)) => {
de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant"),),
_ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant"),),
Some(other) => Err(de::Error::invalid_type(
other.unexpected(),
&"struct variant",
)),
_ => Err(de::Error::invalid_type(
de::Unexpected::UnitVariant,
&"struct variant",
)),
}
}
}
@@ -1319,10 +1342,7 @@ mod content {
T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some(value) => {
seed.deserialize(ContentDeserializer::new(value))
.map(Some)
}
Some(value) => seed.deserialize(ContentDeserializer::new(value)).map(Some),
None => Ok(None),
}
}
@@ -1458,12 +1478,12 @@ mod content {
Ok(value)
}
Content::Map(ref v) => {
let map = v.into_iter()
.map(
|&(ref k, ref v)| {
(ContentRefDeserializer::new(k), ContentRefDeserializer::new(v))
},
);
let map = v.into_iter().map(|&(ref k, ref v)| {
(
ContentRefDeserializer::new(k),
ContentRefDeserializer::new(v),
)
});
let mut map_visitor = de::value::MapDeserializer::new(map);
let value = try!(visitor.visit_map(&mut map_visitor));
try!(map_visitor.end());
@@ -1506,38 +1526,35 @@ mod content {
let &(ref variant, ref value) = match iter.next() {
Some(v) => v,
None => {
return Err(
de::Error::invalid_value(
return Err(de::Error::invalid_value(
de::Unexpected::Map,
&"map with a single key",
),
);
));
}
};
// enums are encoded in json as maps with a single key:value pair
if iter.next().is_some() {
return Err(
de::Error::invalid_value(
return Err(de::Error::invalid_value(
de::Unexpected::Map,
&"map with a single key",
),
);
));
}
(variant, Some(value))
}
ref s @ Content::String(_) | ref s @ Content::Str(_) => (s, None),
ref other => {
return Err(de::Error::invalid_type(other.unexpected(), &"string or map"),);
return Err(de::Error::invalid_type(
other.unexpected(),
&"string or map",
));
}
};
visitor.visit_enum(
EnumRefDeserializer {
visitor.visit_enum(EnumRefDeserializer {
variant: variant,
value: value,
err: PhantomData,
},
)
})
}
forward_to_deserialize_any! {
@@ -1613,9 +1630,10 @@ mod content {
{
match self.value {
Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
None => {
Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"newtype variant"),)
}
None => Err(de::Error::invalid_type(
de::Unexpected::UnitVariant,
&"newtype variant",
)),
}
}
@@ -1627,8 +1645,14 @@ mod content {
Some(&Content::Seq(ref v)) => {
de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant"),),
None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant"),),
Some(other) => Err(de::Error::invalid_type(
other.unexpected(),
&"tuple variant",
)),
None => Err(de::Error::invalid_type(
de::Unexpected::UnitVariant,
&"tuple variant",
)),
}
}
@@ -1647,8 +1671,14 @@ mod content {
Some(&Content::Seq(ref v)) => {
de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant"),),
_ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant"),),
Some(other) => Err(de::Error::invalid_type(
other.unexpected(),
&"struct variant",
)),
_ => Err(de::Error::invalid_type(
de::Unexpected::UnitVariant,
&"struct variant",
)),
}
}
}
@@ -1716,10 +1746,8 @@ mod content {
T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some(value) => {
seed.deserialize(ContentRefDeserializer::new(value))
.map(Some)
}
Some(value) => seed.deserialize(ContentRefDeserializer::new(value))
.map(Some),
None => Ok(None),
}
}
@@ -1764,8 +1792,7 @@ mod content {
match self.iter.next() {
Some(&(ref key, ref value)) => {
self.value = Some(value);
seed.deserialize(ContentRefDeserializer::new(key))
.map(Some)
seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
}
None => Ok(None),
}
@@ -1851,7 +1878,11 @@ mod content {
type Value = ();
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "unit variant {}::{}", self.type_name, self.variant_name)
write!(
formatter,
"unit variant {}::{}",
self.type_name, self.variant_name
)
}
fn visit_seq<S>(self, _: S) -> Result<(), S::Error>
@@ -1891,7 +1922,11 @@ mod content {
type Value = ();
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "unit variant {}::{}", self.type_name, self.variant_name)
write!(
formatter,
"unit variant {}::{}",
self.type_name, self.variant_name
)
}
fn visit_unit<E>(self) -> Result<(), E>
@@ -2016,7 +2051,8 @@ where
pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T>
where T: Deserialize<'de>,
where
T: Deserialize<'de>,
{
type Value = ();
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
serde/src/private/ser.rs
+64 -54
View File
@@ -8,10 +8,10 @@
use lib::*;
use ser::{self, Serialize, Serializer, SerializeMap, SerializeStruct, Impossible};
use ser::{self, Impossible, Serialize, SerializeMap, SerializeStruct, Serializer};
#[cfg(any(feature = "std", feature = "alloc"))]
use self::content::{SerializeTupleVariantAsMapValue, SerializeStructVariantAsMapValue};
use self::content::{SerializeStructVariantAsMapValue, SerializeTupleVariantAsMapValue};
/// Used to check that serde(getter) attributes return the expected type.
/// Not public API.
@@ -32,15 +32,13 @@ where
S: Serializer,
T: Serialize,
{
value.serialize(
TaggedSerializer {
value.serialize(TaggedSerializer {
type_ident: type_ident,
variant_ident: variant_ident,
tag: tag,
variant_name: variant_name,
delegate: serializer,
},
)
})
}
struct TaggedSerializer<S> {
@@ -63,8 +61,7 @@ enum Unsupported {
Sequence,
Tuple,
TupleStruct,
#[cfg(not(any(feature = "std", feature = "alloc")))]
Enum,
#[cfg(not(any(feature = "std", feature = "alloc")))] Enum,
}
impl Display for Unsupported {
@@ -92,13 +89,10 @@ where
S: Serializer,
{
fn bad_type(self, what: Unsupported) -> S::Error {
ser::Error::custom(
format_args!(
ser::Error::custom(format_args!(
"cannot serialize tagged newtype variant {}::{} containing {}",
self.type_ident,
self.variant_ident,
what),
)
self.type_ident, self.variant_ident, what
))
}
}
@@ -281,7 +275,11 @@ where
let mut map = try!(self.delegate.serialize_map(Some(2)));
try!(map.serialize_entry(self.tag, self.variant_name));
try!(map.serialize_key(inner_variant));
Ok(SerializeTupleVariantAsMapValue::new(map, inner_variant, len),)
Ok(SerializeTupleVariantAsMapValue::new(
map,
inner_variant,
len,
))
}
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
@@ -324,7 +322,11 @@ where
let mut map = try!(self.delegate.serialize_map(Some(2)));
try!(map.serialize_entry(self.tag, self.variant_name));
try!(map.serialize_key(inner_variant));
Ok(SerializeStructVariantAsMapValue::new(map, inner_variant, len),)
Ok(SerializeStructVariantAsMapValue::new(
map,
inner_variant,
len,
))
}
#[cfg(not(any(feature = "std", feature = "alloc")))]
@@ -402,7 +404,10 @@ mod content {
}
fn end(mut self) -> Result<M::Ok, M::Error> {
try!(self.map.serialize_value(&Content::TupleStruct(self.name, self.fields)));
try!(
self.map
.serialize_value(&Content::TupleStruct(self.name, self.fields))
);
self.map.end()
}
}
@@ -444,7 +449,10 @@ mod content {
}
fn end(mut self) -> Result<M::Ok, M::Error> {
try!(self.map.serialize_value(&Content::Struct(self.name, self.fields)));
try!(
self.map
.serialize_value(&Content::Struct(self.name, self.fields))
);
self.map.end()
}
}
@@ -485,7 +493,12 @@ mod content {
TupleVariant(&'static str, u32, &'static str, Vec<Content>),
Map(Vec<(Content, Content)>),
Struct(&'static str, Vec<(&'static str, Content)>),
StructVariant(&'static str, u32, &'static str, Vec<(&'static str, Content)>),
StructVariant(
&'static str,
u32,
&'static str,
Vec<(&'static str, Content)>,
),
}
impl Serialize for Content {
@@ -687,7 +700,10 @@ mod content {
where
T: Serialize,
{
Ok(Content::NewtypeStruct(name, Box::new(try!(value.serialize(self)))),)
Ok(Content::NewtypeStruct(
name,
Box::new(try!(value.serialize(self))),
))
}
fn serialize_newtype_variant<T: ?Sized>(
@@ -700,32 +716,26 @@ mod content {
where
T: Serialize,
{
Ok(
Content::NewtypeVariant(
Ok(Content::NewtypeVariant(
name,
variant_index,
variant,
Box::new(try!(value.serialize(self))),
),
)
))
}
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, E> {
Ok(
SerializeSeq {
Ok(SerializeSeq {
elements: Vec::with_capacity(len.unwrap_or(0)),
error: PhantomData,
},
)
})
}
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, E> {
Ok(
SerializeTuple {
Ok(SerializeTuple {
elements: Vec::with_capacity(len),
error: PhantomData,
},
)
})
}
fn serialize_tuple_struct(
@@ -733,13 +743,11 @@ mod content {
name: &'static str,
len: usize,
) -> Result<Self::SerializeTupleStruct, E> {
Ok(
SerializeTupleStruct {
Ok(SerializeTupleStruct {
name: name,
fields: Vec::with_capacity(len),
error: PhantomData,
},
)
})
}
fn serialize_tuple_variant(
@@ -749,25 +757,21 @@ mod content {
variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant, E> {
Ok(
SerializeTupleVariant {
Ok(SerializeTupleVariant {
name: name,
variant_index: variant_index,
variant: variant,
fields: Vec::with_capacity(len),
error: PhantomData,
},
)
})
}
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, E> {
Ok(
SerializeMap {
Ok(SerializeMap {
entries: Vec::with_capacity(len.unwrap_or(0)),
key: None,
error: PhantomData,
},
)
})
}
fn serialize_struct(
@@ -775,13 +779,11 @@ mod content {
name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, E> {
Ok(
SerializeStruct {
Ok(SerializeStruct {
name: name,
fields: Vec::with_capacity(len),
error: PhantomData,
},
)
})
}
fn serialize_struct_variant(
@@ -791,15 +793,13 @@ mod content {
variant: &'static str,
len: usize,
) -> Result<Self::SerializeStructVariant, E> {
Ok(
SerializeStructVariant {
Ok(SerializeStructVariant {
name: name,
variant_index: variant_index,
variant: variant,
fields: Vec::with_capacity(len),
error: PhantomData,
},
)
})
}
}
@@ -907,7 +907,12 @@ mod content {
}
fn end(self) -> Result<Content, E> {
Ok(Content::TupleVariant(self.name, self.variant_index, self.variant, self.fields),)
Ok(Content::TupleVariant(
self.name,
self.variant_index,
self.variant,
self.fields,
))
}
}
@@ -1013,7 +1018,12 @@ mod content {
}
fn end(self) -> Result<Content, E> {
Ok(Content::StructVariant(self.name, self.variant_index, self.variant, self.fields),)
Ok(Content::StructVariant(
self.name,
self.variant_index,
self.variant,
self.fields,
))
}
}
}
serde/src/ser/impls.rs
+18 -10
View File
@@ -464,7 +464,8 @@ impl Serialize for SystemTime {
S: Serializer,
{
use super::SerializeStruct;
let duration_since_epoch = self.duration_since(UNIX_EPOCH).expect("SystemTime must be later than UNIX_EPOCH");
let duration_since_epoch = self.duration_since(UNIX_EPOCH)
.expect("SystemTime must be later than UNIX_EPOCH");
let mut state = try!(serializer.serialize_struct("SystemTime", 2));
try!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs()));
try!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos()));
@@ -513,10 +514,12 @@ impl Serialize for net::IpAddr {
}
} else {
match *self {
net::IpAddr::V4(ref a) =>
serializer.serialize_newtype_variant("IpAddr", 0, "V4", a),
net::IpAddr::V6(ref a) =>
serializer.serialize_newtype_variant("IpAddr", 1, "V6", a),
net::IpAddr::V4(ref a) => {
serializer.serialize_newtype_variant("IpAddr", 0, "V4", a)
}
net::IpAddr::V6(ref a) => {
serializer.serialize_newtype_variant("IpAddr", 1, "V6", a)
}
}
}
}
@@ -567,10 +570,12 @@ impl Serialize for net::SocketAddr {
}
} else {
match *self {
net::SocketAddr::V4(ref addr) =>
serializer.serialize_newtype_variant("SocketAddr", 0, "V4", addr),
net::SocketAddr::V6(ref addr) =>
serializer.serialize_newtype_variant("SocketAddr", 1, "V6", addr),
net::SocketAddr::V4(ref addr) => {
serializer.serialize_newtype_variant("SocketAddr", 0, "V4", addr)
}
net::SocketAddr::V6(ref addr) => {
serializer.serialize_newtype_variant("SocketAddr", 1, "V6", addr)
}
}
}
}
@@ -600,7 +605,10 @@ impl Serialize for net::SocketAddrV6 {
{
if serializer.is_human_readable() {
const MAX_LEN: usize = 47;
debug_assert_eq!(MAX_LEN, "[1001:1002:1003:1004:1005:1006:1007:1008]:65000".len());
debug_assert_eq!(
MAX_LEN,
"[1001:1002:1003:1004:1005:1006:1007:1008]:65000".len()
);
serialize_display_bounded_length!(self, MAX_LEN, serializer)
} else {
(self.ip(), self.port()).serialize(serializer)
serde/src/ser/impossible.rs
+2 -2
View File
@@ -10,8 +10,8 @@
use lib::*;
use ser::{self, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct,
SerializeTupleVariant, SerializeMap, SerializeStruct, SerializeStructVariant};
use ser::{self, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
SerializeTuple, SerializeTupleStruct, SerializeTupleVariant};
/// Helper type for implementing a `Serializer` that does not support
/// serializing one of the compound types.
serde/src/ser/mod.rs
+3 -1
View File
@@ -1412,7 +1412,9 @@ pub trait Serializer: Sized {
/// change, as a value serialized in human-readable mode is not required to
/// deserialize from the same data in compact mode.
#[inline]
fn is_human_readable(&self) -> bool { true }
fn is_human_readable(&self) -> bool {
true
}
}
/// Returned from `Serializer::serialize_seq`.
serde_derive/src/bound.rs
+12 -28
View File
@@ -27,14 +27,10 @@ pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
ty_params: generics
.ty_params
.iter()
.map(
|ty_param| {
syn::TyParam {
.map(|ty_param| syn::TyParam {
default: None,
..ty_param.clone()
}
},
)
})
.collect(),
..generics.clone()
}
@@ -137,8 +133,7 @@ where
relevant_ty_params: HashSet::new(),
};
match cont.body {
Body::Enum(ref variants) => {
for variant in variants.iter() {
Body::Enum(ref variants) => for variant in variants.iter() {
let relevant_fields = variant
.fields
.iter()
@@ -146,8 +141,7 @@ where
for field in relevant_fields {
visit::walk_ty(&mut visitor, field.ty);
}
}
}
},
Body::Struct(_, ref fields) => {
for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
visit::walk_ty(&mut visitor, field.ty);
@@ -160,10 +154,8 @@ where
.iter()
.map(|ty_param| ty_param.ident.clone())
.filter(|id| visitor.relevant_ty_params.contains(id))
.map(
|id| {
syn::WherePredicate::BoundPredicate(
syn::WhereBoundPredicate {
.map(|id| {
syn::WherePredicate::BoundPredicate(syn::WhereBoundPredicate {
bound_lifetimes: Vec::new(),
// the type parameter that is being bounded e.g. T
bounded_ty: syn::Ty::Path(None, id.into()),
@@ -177,10 +169,8 @@ where
syn::TraitBoundModifier::None,
),
],
},
)
},
);
})
});
let mut generics = generics.clone();
generics.where_clause.predicates.extend(new_predicates);
@@ -196,8 +186,7 @@ pub fn with_self_bound(
generics
.where_clause
.predicates
.push(
syn::WherePredicate::BoundPredicate(
.push(syn::WherePredicate::BoundPredicate(
syn::WhereBoundPredicate {
bound_lifetimes: Vec::new(),
// the type that is being bounded e.g. MyStruct<'a, T>
@@ -213,8 +202,7 @@ pub fn with_self_bound(
),
],
},
),
);
));
generics
}
@@ -231,15 +219,11 @@ pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Gen
.push(syn::TyParamBound::Region(syn::Lifetime::new(lifetime)));
}
generics
.lifetimes
.push(
syn::LifetimeDef {
generics.lifetimes.push(syn::LifetimeDef {
attrs: Vec::new(),
lifetime: syn::Lifetime::new(lifetime),
bounds: Vec::new(),
},
);
});
generics
}
serde_derive/src/de.rs
+196 -256
View File
@@ -7,10 +7,10 @@
// except according to those terms.
use syn::{self, Ident};
use quote::{self, Tokens, ToTokens};
use quote::{self, ToTokens, Tokens};
use bound;
use fragment::{Fragment, Expr, Stmts, Match};
use fragment::{Expr, Fragment, Match, Stmts};
use internals::ast::{Body, Container, Field, Style, Variant};
use internals::{self, attr};
@@ -129,8 +129,7 @@ fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generi
attr::Default::Default => {
bound::with_self_bound(cont, &generics, &path!(_serde::export::Default))
}
attr::Default::None |
attr::Default::Path(_) => generics,
attr::Default::None | attr::Default::Path(_) => generics,
};
let delife = borrowed.de_lifetime();
@@ -156,10 +155,8 @@ fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generi
// attribute specify their own bound so we do not generate one. All other fields
// may need a `T: Deserialize` bound where T is the type of the field.
fn needs_deserialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
!field.skip_deserializing() &&
field.deserialize_with().is_none() &&
field.de_bound().is_none() &&
variant.map_or(true, |variant| variant.deserialize_with().is_none())
!field.skip_deserializing() && field.deserialize_with().is_none() && field.de_bound().is_none()
&& variant.map_or(true, |variant| variant.deserialize_with().is_none())
}
// Fields with a `default` attribute (not `default=...`), and fields with a
@@ -183,13 +180,11 @@ impl BorrowedLifetimes {
fn de_lifetime_def(&self) -> Option<syn::LifetimeDef> {
match *self {
BorrowedLifetimes::Borrowed(ref bounds) => {
Some(syn::LifetimeDef {
BorrowedLifetimes::Borrowed(ref bounds) => Some(syn::LifetimeDef {
attrs: Vec::new(),
lifetime: syn::Lifetime::new("'de"),
bounds: bounds.iter().cloned().collect(),
})
}
}),
BorrowedLifetimes::Static => None,
}
}
@@ -230,8 +225,7 @@ fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
}
deserialize_struct(None, params, fields, &cont.attrs, None, Untagged::No)
}
Body::Struct(Style::Tuple, ref fields) |
Body::Struct(Style::Newtype, ref fields) => {
Body::Struct(Style::Tuple, ref fields) | Body::Struct(Style::Newtype, ref fields) => {
if fields.iter().any(|field| field.ident.is_some()) {
panic!("tuple struct has named fields");
}
@@ -255,9 +249,10 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
// deserialize_in_place for remote derives.
assert!(!params.has_getter);
if cont.attrs.from_type().is_some()
|| cont.attrs.identifier().is_some()
|| cont.body.all_fields().all(|f| f.attrs.deserialize_with().is_some())
if cont.attrs.from_type().is_some() || cont.attrs.identifier().is_some()
|| cont.body
.all_fields()
.all(|f| f.attrs.deserialize_with().is_some())
{
return None;
}
@@ -266,8 +261,7 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
Body::Struct(Style::Struct, ref fields) => {
deserialize_struct_in_place(None, params, fields, &cont.attrs, None, Untagged::No)
}
Body::Struct(Style::Tuple, ref fields) |
Body::Struct(Style::Newtype, ref fields) => {
Body::Struct(Style::Tuple, ref fields) | Body::Struct(Style::Newtype, ref fields) => {
deserialize_tuple_in_place(None, params, fields, &cont.attrs, None)
}
Body::Enum(_) | Body::Struct(Style::Unit, _) => {
@@ -338,7 +332,8 @@ fn deserialize_tuple(
deserializer: Option<Tokens>,
) -> Fragment {
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime();
// If there are getters (implying private fields), construct the local type
@@ -389,9 +384,7 @@ fn deserialize_tuple(
quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
};
let all_skipped = fields
.iter()
.all(|field| field.attrs.skip_deserializing());
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
let visitor_var = if all_skipped {
quote!(_)
} else {
@@ -434,7 +427,8 @@ fn deserialize_tuple_in_place(
deserializer: Option<Tokens>,
) -> Fragment {
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime();
let is_enum = variant_ident.is_some();
@@ -472,9 +466,7 @@ fn deserialize_tuple_in_place(
quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
};
let all_skipped = fields
.iter()
.all(|field| field.attrs.skip_deserializing());
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
let visitor_var = if all_skipped {
quote!(_)
} else {
@@ -528,8 +520,7 @@ fn deserialize_seq(
let expecting = format!("tuple of {} elements", deserialized_count);
let mut index_in_seq = 0usize;
let let_values = vars.clone().zip(fields)
.map(|(var, field)| {
let let_values = vars.clone().zip(fields).map(|(var, field)| {
if field.attrs.skip_deserializing() {
let default = Expr(expr_is_missing(&field, cattrs));
quote! {
@@ -542,8 +533,7 @@ fn deserialize_seq(
quote!(try!(_serde::de::SeqAccess::next_element::<#field_ty>(&mut __seq)))
}
Some(path) => {
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(
params, field.ty, path);
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
quote!({
#wrapper
_serde::export::Option::map(
@@ -584,20 +574,12 @@ fn deserialize_seq(
}
let let_default = match *cattrs.default() {
attr::Default::Default => {
Some(
quote!(
attr::Default::Default => Some(quote!(
let __default: Self::Value = _serde::export::Default::default();
),
)
}
attr::Default::Path(ref path) => {
Some(
quote!(
)),
attr::Default::Path(ref path) => Some(quote!(
let __default: Self::Value = #path();
),
)
}
)),
attr::Default::None => {
// We don't need the default value, to prevent an unused variable warning
// we'll leave the line empty.
@@ -627,10 +609,14 @@ fn deserialize_seq_in_place(
let expecting = format!("tuple of {} elements", deserialized_count);
let mut index_in_seq = 0usize;
let write_values = vars.clone().zip(fields).enumerate()
let write_values = vars.clone()
.zip(fields)
.enumerate()
.map(|(field_index, (_, field))| {
// If there's no field name, assume we're a tuple-struct and use a numeric index
let field_name = field.ident.clone()
let field_name = field
.ident
.clone()
.unwrap_or_else(|| Ident::new(field_index.to_string()));
if field.attrs.skip_deserializing() {
@@ -653,8 +639,8 @@ fn deserialize_seq_in_place(
}
}
Some(path) => {
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(
params, field.ty, path);
let (wrapper, wrapper_ty) =
wrap_deserialize_field_with(params, field.ty, path);
quote!({
#wrapper
match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) {
@@ -676,20 +662,12 @@ fn deserialize_seq_in_place(
let this = &params.this;
let (_, ty_generics, _) = params.generics.split_for_impl();
let let_default = match *cattrs.default() {
attr::Default::Default => {
Some(
quote!(
attr::Default::Default => Some(quote!(
let __default: #this #ty_generics = _serde::export::Default::default();
),
)
}
attr::Default::Path(ref path) => {
Some(
quote!(
)),
attr::Default::Path(ref path) => Some(quote!(
let __default: #this #ty_generics = #path();
),
)
}
)),
attr::Default::None => {
// We don't need the default value, to prevent an unused variable warning
// we'll leave the line empty.
@@ -742,10 +720,7 @@ fn deserialize_newtype_struct(type_path: &Tokens, params: &Parameters, field: &F
}
#[cfg(feature = "deserialize_in_place")]
fn deserialize_newtype_struct_in_place(
params: &Parameters,
field: &Field
) -> Tokens {
fn deserialize_newtype_struct_in_place(params: &Parameters, field: &Field) -> Tokens {
// We do not generate deserialize_in_place if every field has a deserialize_with.
assert!(field.attrs.deserialize_with().is_none());
@@ -777,7 +752,8 @@ fn deserialize_struct(
let is_enum = variant_ident.is_some();
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime();
// If there are getters (implying private fields), construct the local type
@@ -828,9 +804,7 @@ fn deserialize_struct(
}
};
let all_skipped = fields
.iter()
.all(|field| field.attrs.skip_deserializing());
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
let visitor_var = if all_skipped {
quote!(_)
} else {
@@ -840,16 +814,14 @@ fn deserialize_struct(
// untagged struct variants do not get a visit_seq method
let visit_seq = match untagged {
Untagged::Yes => None,
Untagged::No => {
Some(quote! {
Untagged::No => Some(quote! {
#[inline]
fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
where __A: _serde::de::SeqAccess<#delife>
{
#visit_seq
}
})
}
}),
};
quote_block! {
@@ -895,7 +867,8 @@ fn deserialize_struct_in_place(
let is_enum = variant_ident.is_some();
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime();
let expecting = match variant_ident {
@@ -932,10 +905,7 @@ fn deserialize_struct_in_place(
}
};
let all_skipped = fields
.iter()
.all(|field| field.attrs.skip_deserializing());
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
let visitor_var = if all_skipped {
quote!(_)
} else {
@@ -945,17 +915,14 @@ fn deserialize_struct_in_place(
// untagged struct variants do not get a visit_seq method
let visit_seq = match untagged {
Untagged::Yes => None,
Untagged::No => {
Some(quote! {
Untagged::No => Some(quote! {
#[inline]
fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
where __A: _serde::de::SeqAccess<#delife>
{
#visit_seq
}
})
}
}),
};
let in_place_impl_generics = de_impl_generics.in_place();
@@ -1017,7 +984,8 @@ fn deserialize_externally_tagged_enum(
cattrs: &attr::Container,
) -> Fragment {
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime();
let type_name = cattrs.name().deserialize_name();
@@ -1028,7 +996,7 @@ fn deserialize_externally_tagged_enum(
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)),)
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
.collect();
let variants_stmt = {
@@ -1038,24 +1006,30 @@ fn deserialize_externally_tagged_enum(
}
};
let variant_visitor = Stmts(deserialize_generated_identifier(variant_names_idents, cattrs, true),);
let variant_visitor = Stmts(deserialize_generated_identifier(
variant_names_idents,
cattrs,
true,
));
// Match arms to extract a variant from a string
let variant_arms = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(
|(i, variant)| {
.map(|(i, variant)| {
let variant_name = field_i(i);
let block = Match(deserialize_externally_tagged_variant(params, variant, cattrs),);
let block = Match(deserialize_externally_tagged_variant(
params,
variant,
cattrs,
));
quote! {
(__Field::#variant_name, __variant) => #block
}
},
);
});
let all_skipped = variants
.iter()
@@ -1121,7 +1095,7 @@ fn deserialize_internally_tagged_enum(
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)),)
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
.collect();
let variants_stmt = {
@@ -1131,10 +1105,15 @@ fn deserialize_internally_tagged_enum(
}
};
let variant_visitor = Stmts(deserialize_generated_identifier(variant_names_idents, cattrs, true),);
let variant_visitor = Stmts(deserialize_generated_identifier(
variant_names_idents,
cattrs,
true,
));
// Match arms to extract a variant from a string
let variant_arms = variants.iter()
let variant_arms = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(|(i, variant)| {
@@ -1144,7 +1123,9 @@ fn deserialize_internally_tagged_enum(
params,
variant,
cattrs,
quote!(_serde::private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)),
quote!(
_serde::private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)
),
));
quote! {
@@ -1175,14 +1156,15 @@ fn deserialize_adjacently_tagged_enum(
content: &str,
) -> Fragment {
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime();
let variant_names_idents: Vec<_> = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)),)
.map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
.collect();
let variants_stmt = {
@@ -1192,30 +1174,30 @@ fn deserialize_adjacently_tagged_enum(
}
};
let variant_visitor = Stmts(deserialize_generated_identifier(variant_names_idents, cattrs, true),);
let variant_visitor = Stmts(deserialize_generated_identifier(
variant_names_idents,
cattrs,
true,
));
let ref variant_arms: Vec<_> = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing())
.map(
|(i, variant)| {
.map(|(i, variant)| {
let variant_index = field_i(i);
let block = Match(
deserialize_untagged_variant(
let block = Match(deserialize_untagged_variant(
params,
variant,
cattrs,
quote!(__deserializer),
),
);
));
quote! {
__Field::#variant_index => #block
}
},
)
})
.collect();
let expecting = format!("adjacently tagged enum {}", params.type_name());
@@ -1251,25 +1233,21 @@ fn deserialize_adjacently_tagged_enum(
let fallthrough = if variants.iter().all(is_unit) {
None
} else {
Some(
quote! {
Some(quote! {
_ => #missing_content
},
)
})
};
let arms = variants
.iter()
.enumerate()
.filter(|&(_, variant)| !variant.attrs.skip_deserializing() && is_unit(variant),)
.map(
|(i, variant)| {
.filter(|&(_, variant)| !variant.attrs.skip_deserializing() && is_unit(variant))
.map(|(i, variant)| {
let variant_index = field_i(i);
let variant_ident = &variant.ident;
quote! {
__Field::#variant_index => _serde::export::Ok(#this::#variant_ident),
}
},
);
});
missing_content = quote! {
match __field {
#(#arms)*
@@ -1288,8 +1266,7 @@ fn deserialize_adjacently_tagged_enum(
let next_relevant_key = if deny_unknown_fields {
next_key
} else {
quote! {
{
quote!({
let mut __rk : _serde::export::Option<_serde::private::de::TagOrContentField> = _serde::export::None;
while let _serde::export::Some(__k) = #next_key {
match __k {
@@ -1309,8 +1286,7 @@ fn deserialize_adjacently_tagged_enum(
}
__rk
}
}
})
};
// Step through remaining keys, looking for duplicates of previously-seen
@@ -1472,16 +1448,14 @@ fn deserialize_untagged_enum(
let attempts = variants
.iter()
.filter(|variant| !variant.attrs.skip_deserializing())
.map(
|variant| {
.map(|variant| {
Expr(deserialize_untagged_variant(
params,
variant,
cattrs,
quote!(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)),
))
},
);
});
// TODO this message could be better by saving the errors from the failed
// attempts. The heuristic used by TOML was to count the number of fields
@@ -1489,8 +1463,10 @@ fn deserialize_untagged_enum(
// largest number of fields. I'm not sure I like that. Maybe it would be
// better to save all the errors and combine them into one message that
// explains why none of the variants matched.
let fallthrough_msg =
format!("data did not match any variant of untagged enum {}", params.type_name());
let fallthrough_msg = format!(
"data did not match any variant of untagged enum {}",
params.type_name()
);
quote_block! {
let __content = try!(<_serde::private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
@@ -1536,9 +1512,14 @@ fn deserialize_externally_tagged_variant(
Style::Tuple => {
deserialize_tuple(Some(variant_ident), params, &variant.fields, cattrs, None)
}
Style::Struct => {
deserialize_struct(Some(variant_ident), params, &variant.fields, cattrs, None, Untagged::No)
}
Style::Struct => deserialize_struct(
Some(variant_ident),
params,
&variant.fields,
cattrs,
None,
Untagged::No,
),
}
}
@@ -1564,24 +1545,20 @@ fn deserialize_internally_tagged_variant(
_serde::export::Ok(#this::#variant_ident)
}
}
Style::Newtype => {
deserialize_untagged_newtype_variant(
Style::Newtype => deserialize_untagged_newtype_variant(
variant_ident,
params,
&variant.fields[0],
deserializer,
)
}
Style::Struct => {
deserialize_struct(
),
Style::Struct => deserialize_struct(
Some(variant_ident),
params,
&variant.fields,
cattrs,
Some(deserializer),
Untagged::No,
)
}
),
Style::Tuple => unreachable!("checked in serde_derive_internals"),
}
}
@@ -1618,33 +1595,27 @@ fn deserialize_untagged_variant(
|()| #this::#variant_ident)
}
}
Style::Newtype => {
deserialize_untagged_newtype_variant(
Style::Newtype => deserialize_untagged_newtype_variant(
variant_ident,
params,
&variant.fields[0],
deserializer,
)
}
Style::Tuple => {
deserialize_tuple(
),
Style::Tuple => deserialize_tuple(
Some(variant_ident),
params,
&variant.fields,
cattrs,
Some(deserializer),
)
}
Style::Struct => {
deserialize_struct(
),
Style::Struct => deserialize_struct(
Some(variant_ident),
params,
&variant.fields,
cattrs,
Some(deserializer),
Untagged::Yes,
)
}
),
}
}
@@ -1719,7 +1690,12 @@ fn deserialize_generated_identifier(
(Some(ignore_variant), Some(fallthrough))
};
let visitor_impl = Stmts(deserialize_identifier(this, &fields, is_variant, fallthrough),);
let visitor_impl = Stmts(deserialize_identifier(
this,
&fields,
is_variant,
fallthrough,
));
quote_block! {
#[allow(non_camel_case_types)]
@@ -1785,7 +1761,12 @@ fn deserialize_custom_identifier(
let names_idents: Vec<_> = ordinary
.iter()
.map(|variant| (variant.attrs.name().deserialize_name(), variant.ident.clone()),)
.map(|variant| {
(
variant.attrs.name().deserialize_name(),
variant.ident.clone(),
)
})
.collect();
let names = names_idents.iter().map(|&(ref name, _)| name);
@@ -1804,10 +1785,15 @@ fn deserialize_custom_identifier(
Some(fields)
};
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime();
let visitor_impl =
Stmts(deserialize_identifier(this.clone(), &names_idents, is_variant, fallthrough),);
let visitor_impl = Stmts(deserialize_identifier(
this.clone(),
&names_idents,
is_variant,
fallthrough,
));
quote_block! {
#names_const
@@ -1851,11 +1837,7 @@ fn deserialize_identifier(
"field identifier"
};
let index_expecting = if is_variant {
"variant"
} else {
"field"
};
let index_expecting = if is_variant { "variant" } else { "field" };
let variant_indices = 0u64..;
let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
@@ -1939,7 +1921,7 @@ fn deserialize_struct_visitor(
.iter()
.enumerate()
.filter(|&(_, field)| !field.attrs.skip_deserializing())
.map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)),)
.map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)))
.collect();
let fields_stmt = {
@@ -1973,17 +1955,16 @@ fn deserialize_map(
let let_values = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(
|&(field, ref name)| {
.map(|&(field, ref name)| {
let field_ty = &field.ty;
quote! {
let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
}
},
);
});
// Match arms to extract a value for a field.
let value_arms = fields_names.iter()
let value_arms = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| {
let deser_name = field.attrs.name().deserialize_name();
@@ -1996,8 +1977,7 @@ fn deserialize_map(
}
}
Some(path) => {
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(
params, field.ty, path);
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
quote!({
#wrapper
try!(_serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map)).value
@@ -2023,9 +2003,7 @@ fn deserialize_map(
})
};
let all_skipped = fields
.iter()
.all(|field| field.attrs.skip_deserializing());
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
quote! {
// FIXME: Once we drop support for Rust 1.15:
@@ -2048,8 +2026,7 @@ fn deserialize_map(
let extract_values = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(
|&(field, ref name)| {
.map(|&(field, ref name)| {
let missing_expr = Match(expr_is_missing(&field, cattrs));
quote! {
@@ -2058,41 +2035,25 @@ fn deserialize_map(
_serde::export::None => #missing_expr
};
}
},
);
});
let result = fields_names
.iter()
.map(
|&(field, ref name)| {
let ident = field
.ident
.clone()
.expect("struct contains unnamed fields");
let result = fields_names.iter().map(|&(field, ref name)| {
let ident = field.ident.clone().expect("struct contains unnamed fields");
if field.attrs.skip_deserializing() {
let value = Expr(expr_is_missing(&field, cattrs));
quote!(#ident: #value)
} else {
quote!(#ident: #name)
}
},
);
});
let let_default = match *cattrs.default() {
attr::Default::Default => {
Some(
quote!(
attr::Default::Default => Some(quote!(
let __default: Self::Value = _serde::export::Default::default();
),
)
}
attr::Default::Path(ref path) => {
Some(
quote!(
)),
attr::Default::Path(ref path) => Some(quote!(
let __default: Self::Value = #path();
),
)
}
)),
attr::Default::None => {
// We don't need the default value, to prevent an unused variable warning
// we'll leave the line empty.
@@ -2131,7 +2092,7 @@ fn deserialize_struct_in_place_visitor(
.iter()
.enumerate()
.filter(|&(_, field)| !field.attrs.skip_deserializing())
.map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)),)
.map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)))
.collect();
let fields_stmt = {
@@ -2165,16 +2126,15 @@ fn deserialize_map_in_place(
let let_flags = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(
|&(_, ref name)| {
.map(|&(_, ref name)| {
quote! {
let mut #name: bool = false;
}
},
);
});
// Match arms to extract a value for a field.
let value_arms_from = fields_names.iter()
let value_arms_from = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(|&(field, ref name)| {
let deser_name = field.attrs.name().deserialize_name();
@@ -2187,8 +2147,7 @@ fn deserialize_map_in_place(
}
}
Some(path) => {
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(
params, field.ty, path);
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
quote!({
#wrapper
self.place.#field_name = try!(_serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map)).value
@@ -2215,9 +2174,7 @@ fn deserialize_map_in_place(
})
};
let all_skipped = fields
.iter()
.all(|field| field.attrs.skip_deserializing());
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
quote! {
@@ -2241,8 +2198,7 @@ fn deserialize_map_in_place(
let check_flags = fields_names
.iter()
.filter(|&&(field, _)| !field.attrs.skip_deserializing())
.map(
|&(field, ref name)| {
.map(|&(field, ref 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. Maybe this could be handled
@@ -2263,27 +2219,18 @@ fn deserialize_map_in_place(
};
}
}
},
);
});
let this = &params.this;
let (_, _, ty_generics, _) = split_with_de_lifetime(params,);
let (_, _, ty_generics, _) = split_with_de_lifetime(params);
let let_default = match *cattrs.default() {
attr::Default::Default => {
Some(
quote!(
attr::Default::Default => Some(quote!(
let __default: #this #ty_generics = _serde::export::Default::default();
),
)
}
attr::Default::Path(ref path) => {
Some(
quote!(
)),
attr::Default::Path(ref path) => Some(quote!(
let __default: #this #ty_generics = #path();
),
)
}
)),
attr::Default::None => {
// We don't need the default value, to prevent an unused variable warning
// we'll leave the line empty.
@@ -2316,7 +2263,8 @@ fn wrap_deserialize_with(
deserialize_with: &syn::Path,
) -> (Tokens, Tokens) {
let this = &params.this;
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
split_with_de_lifetime(params);
let delife = params.borrowed.de_lifetime();
let wrapper = quote! {
@@ -2367,40 +2315,29 @@ fn wrap_deserialize_variant_with(
let field_access = (0..variant.fields.len()).map(|n| Ident::new(format!("{}", n)));
let unwrap_fn = match variant.style {
Style::Struct => {
let field_idents = variant.fields.iter().map(|field| field.ident.as_ref().unwrap());
quote! {
{
let field_idents = variant
.fields
.iter()
.map(|field| field.ident.as_ref().unwrap());
quote!({
|__wrap| {
#this::#variant_ident { #(#field_idents: __wrap.value.#field_access),* }
}
})
}
}
}
Style::Tuple => {
quote! {
{
Style::Tuple => quote!({
|__wrap| {
#this::#variant_ident(#(__wrap.value.#field_access),*)
}
}
}
}
Style::Newtype => {
quote! {
{
}),
Style::Newtype => quote!({
|__wrap| {
#this::#variant_ident(__wrap.value)
}
}
}
}
Style::Unit => {
quote! {
{
}),
Style::Unit => quote!({
|__wrap| { #this::#variant_ident }
}
}
}
}),
};
(wrapper, wrapper_ty, unwrap_fn)
@@ -2418,8 +2355,7 @@ fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
}
match *cattrs.default() {
attr::Default::Default |
attr::Default::Path(_) => {
attr::Default::Default | attr::Default::Path(_) => {
let ident = &field.ident;
return quote_expr!(__default.#ident);
}
@@ -2467,7 +2403,9 @@ impl<'a> ToTokens for InPlaceImplGenerics<'a> {
lifetime.bounds.push(place_lifetime.lifetime.clone());
}
for generic in &mut generics.ty_params {
generic.bounds.push(syn::TyParamBound::Region(place_lifetime.lifetime.clone()));
generic
.bounds
.push(syn::TyParamBound::Region(place_lifetime.lifetime.clone()));
}
generics.lifetimes.insert(0, place_lifetime);
if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
@@ -2493,9 +2431,7 @@ impl<'a> ToTokens for DeTyGenerics<'a> {
fn to_tokens(&self, tokens: &mut Tokens) {
let mut generics = self.0.generics.clone();
if self.0.borrowed.de_lifetime_def().is_some() {
generics
.lifetimes
.insert(0, syn::LifetimeDef::new("'de"));
generics.lifetimes.insert(0, syn::LifetimeDef::new("'de"));
}
let (_, ty_generics, _) = generics.split_for_impl();
ty_generics.to_tokens(tokens);
@@ -2509,9 +2445,7 @@ impl<'a> ToTokens for InPlaceTyGenerics<'a> {
generics.lifetimes.insert(0, place_lifetime());
if self.0.borrowed.de_lifetime_def().is_some() {
generics
.lifetimes
.insert(0, syn::LifetimeDef::new("'de"));
generics.lifetimes.insert(0, syn::LifetimeDef::new("'de"));
}
let (_, ty_generics, _) = generics.split_for_impl();
ty_generics.to_tokens(tokens);
@@ -2530,8 +2464,14 @@ fn place_lifetime() -> syn::LifetimeDef {
syn::LifetimeDef::new("'place")
}
fn split_with_de_lifetime(params: &Parameters,)
-> (DeImplGenerics, DeTyGenerics, syn::TyGenerics, &syn::WhereClause) {
fn split_with_de_lifetime(
params: &Parameters,
) -> (
DeImplGenerics,
DeTyGenerics,
syn::TyGenerics,
&syn::WhereClause,
) {
let de_impl_generics = DeImplGenerics(&params);
let de_ty_generics = DeTyGenerics(&params);
let (_, ty_generics, where_clause) = params.generics.split_for_impl();
serde_derive/src/fragment.rs
+1 -1
View File
@@ -6,7 +6,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use quote::{Tokens, ToTokens};
use quote::{ToTokens, Tokens};
pub enum Fragment {
/// Tokens that can be used as an expression.
serde_derive/src/lib.rs
+1 -3
View File
@@ -23,16 +23,14 @@
//! [https://serde.rs/derive.html]: https://serde.rs/derive.html
#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.24")]
#![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
#![cfg_attr(feature = "cargo-clippy", allow(used_underscore_binding))]
// The `quote!` macro requires deep recursion.
#![recursion_limit = "192"]
extern crate syn;
#[macro_use]
extern crate quote;
extern crate syn;
extern crate serde_derive_internals as internals;
serde_derive/src/ser.rs
+61 -101
View File
@@ -10,7 +10,7 @@ use syn::{self, Ident};
use quote::Tokens;
use bound;
use fragment::{Fragment, Stmts, Match};
use fragment::{Fragment, Match, Stmts};
use internals::ast::{Body, Container, Field, Style, Variant};
use internals::{attr, Ctxt};
@@ -132,14 +132,12 @@ fn build_generics(cont: &Container) -> syn::Generics {
match cont.attrs.ser_bound() {
Some(predicates) => bound::with_where_predicates(&generics, predicates),
None => {
bound::with_bound(
None => bound::with_bound(
cont,
&generics,
needs_serialize_bound,
&path!(_serde::Serialize),
)
}
),
}
}
@@ -149,10 +147,8 @@ fn build_generics(cont: &Container) -> syn::Generics {
// their own bound so we do not generate one. All other fields may need a `T:
// Serialize` bound where T is the type of the field.
fn needs_serialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
!field.skip_serializing() &&
field.serialize_with().is_none() &&
field.ser_bound().is_none() &&
variant.map_or(true, |variant| variant.serialize_with().is_none())
!field.skip_serializing() && field.serialize_with().is_none() && field.ser_bound().is_none()
&& variant.map_or(true, |variant| variant.serialize_with().is_none())
}
fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
@@ -259,16 +255,14 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
let let_mut = mut_if(serialized_fields.peek().is_some());
let len = serialized_fields
.map(
|field| match field.attrs.skip_serializing_if() {
.map(|field| match field.attrs.skip_serializing_if() {
None => quote!(1),
Some(path) => {
let ident = field.ident.clone().expect("struct has unnamed fields");
let field_expr = get_field(params, field, ident);
quote!(if #path(#field_expr) { 0 } else { 1 })
}
},
)
})
.fold(quote!(0), |sum, expr| quote!(#sum + #expr));
quote_block! {
@@ -286,11 +280,9 @@ fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Cont
let arms: Vec<_> = variants
.iter()
.enumerate()
.map(
|(variant_index, variant)| {
.map(|(variant_index, variant)| {
serialize_variant(params, variant, variant_index as u32, cattrs)
},
)
})
.collect();
quote_expr! {
@@ -321,13 +313,7 @@ fn serialize_variant(
let fields_pat = match variant.style {
Style::Unit => quote!(),
Style::Newtype | Style::Tuple => quote!((..)),
Style::Struct => {
quote!(
{
..
}
)
}
Style::Struct => quote!({ .. }),
};
quote! {
#this::#variant_ident #fields_pat => #skipped_err,
@@ -356,21 +342,14 @@ fn serialize_variant(
let fields = variant
.fields
.iter()
.map(
|f| {
f.ident
.clone()
.expect("struct variant has unnamed fields")
},
);
.map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
quote! {
#this::#variant_ident { #(ref #fields),* }
}
}
};
let body = Match(
match *cattrs.tag() {
let body = Match(match *cattrs.tag() {
attr::EnumTag::External => {
serialize_externally_tagged_variant(params, variant, variant_index, cattrs)
}
@@ -382,8 +361,7 @@ fn serialize_variant(
ref content,
} => serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content),
attr::EnumTag::None => serialize_untagged_variant(params, variant, cattrs),
},
);
});
quote! {
#case => #body
@@ -441,8 +419,7 @@ fn serialize_externally_tagged_variant(
)
}
}
Style::Tuple => {
serialize_tuple_variant(
Style::Tuple => serialize_tuple_variant(
TupleVariant::ExternallyTagged {
type_name: type_name,
variant_index: variant_index,
@@ -450,10 +427,8 @@ fn serialize_externally_tagged_variant(
},
params,
&variant.fields,
)
}
Style::Struct => {
serialize_struct_variant(
),
Style::Struct => serialize_struct_variant(
StructVariant::ExternallyTagged {
variant_index: variant_index,
variant_name: variant_name,
@@ -461,8 +436,7 @@ fn serialize_externally_tagged_variant(
params,
&variant.fields,
&type_name,
)
}
),
}
}
@@ -520,8 +494,7 @@ fn serialize_internally_tagged_variant(
)
}
}
Style::Struct => {
serialize_struct_variant(
Style::Struct => serialize_struct_variant(
StructVariant::InternallyTagged {
tag: tag,
variant_name: variant_name,
@@ -529,8 +502,7 @@ fn serialize_internally_tagged_variant(
params,
&variant.fields,
&type_name,
)
}
),
Style::Tuple => unreachable!("checked in serde_derive_internals"),
}
}
@@ -546,8 +518,7 @@ fn serialize_adjacently_tagged_variant(
let type_name = cattrs.name().serialize_name();
let variant_name = variant.attrs.name().serialize_name();
let inner = Stmts(
if let Some(path) = variant.attrs.serialize_with() {
let inner = Stmts(if let Some(path) = variant.attrs.serialize_with() {
let ser = wrap_serialize_variant_with(params, path, &variant);
quote_expr! {
_serde::Serialize::serialize(#ser, __serializer)
@@ -577,17 +548,14 @@ fn serialize_adjacently_tagged_variant(
Style::Tuple => {
serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields)
}
Style::Struct => {
serialize_struct_variant(
Style::Struct => serialize_struct_variant(
StructVariant::Untagged,
params,
&variant.fields,
&variant_name,
)
),
}
}
},
);
});
let fields_ty = variant.fields.iter().map(|f| &f.ty);
let ref fields_ident: Vec<_> = match variant.style {
@@ -599,24 +567,14 @@ fn serialize_adjacently_tagged_variant(
}
}
Style::Newtype => vec![Ident::new("__field0")],
Style::Tuple => {
(0..variant.fields.len())
Style::Tuple => (0..variant.fields.len())
.map(|i| Ident::new(format!("__field{}", i)))
.collect()
}
Style::Struct => {
variant
.collect(),
Style::Struct => variant
.fields
.iter()
.map(
|f| {
f.ident
.clone()
.expect("struct variant has unnamed fields")
},
)
.collect()
}
.map(|f| f.ident.clone().expect("struct variant has unnamed fields"))
.collect(),
};
let (_, ty_generics, where_clause) = params.generics.split_for_impl();
@@ -753,7 +711,10 @@ enum StructVariant<'a> {
variant_index: u32,
variant_name: String,
},
InternallyTagged { tag: &'a str, variant_name: String },
InternallyTagged {
tag: &'a str,
variant_name: String,
},
Untagged,
}
@@ -764,19 +725,14 @@ fn serialize_struct_variant<'a>(
name: &str,
) -> Fragment {
let (method, skip_method) = match context {
StructVariant::ExternallyTagged { .. } => {
(
StructVariant::ExternallyTagged { .. } => (
quote!(_serde::ser::SerializeStructVariant::serialize_field),
quote!(_serde::ser::SerializeStructVariant::skip_field),
)
}
StructVariant::InternallyTagged { .. } |
StructVariant::Untagged => {
(
),
StructVariant::InternallyTagged { .. } | StructVariant::Untagged => (
quote!(_serde::ser::SerializeStruct::serialize_field),
quote!(_serde::ser::SerializeStruct::skip_field),
)
}
),
};
let serialize_fields = serialize_struct_visitor(fields, params, true, method, skip_method);
@@ -789,16 +745,14 @@ fn serialize_struct_variant<'a>(
let let_mut = mut_if(serialized_fields.peek().is_some());
let len = serialized_fields
.map(
|field| {
.map(|field| {
let ident = field.ident.clone().expect("struct has unnamed fields");
match field.attrs.skip_serializing_if() {
Some(path) => quote!(if #path(#ident) { 0 } else { 1 }),
None => quote!(1),
}
},
)
})
.fold(quote!(0), |sum, expr| quote!(#sum + #expr));
match context {
@@ -857,8 +811,7 @@ fn serialize_tuple_struct_visitor(
fields
.iter()
.enumerate()
.map(
|(i, field)| {
.map(|(i, field)| {
let mut field_expr = if is_enum {
let id = Ident::new(format!("__field{}", i));
quote!(#id)
@@ -883,8 +836,7 @@ fn serialize_tuple_struct_visitor(
None => ser,
Some(skip) => quote!(if !#skip { #ser }),
}
},
)
})
.collect()
}
@@ -898,8 +850,7 @@ fn serialize_struct_visitor(
fields
.iter()
.filter(|&field| !field.attrs.skip_serializing())
.map(
|field| {
.map(|field| {
let field_ident = field.ident.clone().expect("struct has unnamed field");
let mut field_expr = if is_enum {
quote!(#field_ident)
@@ -934,8 +885,7 @@ fn serialize_struct_visitor(
}
}
}
},
)
})
.collect()
}
@@ -945,10 +895,7 @@ fn wrap_serialize_field_with(
serialize_with: &syn::Path,
field_expr: Tokens,
) -> Tokens {
wrap_serialize_with(params,
serialize_with,
&[field_ty],
&[quote!(#field_expr)])
wrap_serialize_with(params, serialize_with, &[field_ty], &[quote!(#field_expr)])
}
fn wrap_serialize_variant_with(
@@ -957,15 +904,24 @@ fn wrap_serialize_variant_with(
variant: &Variant,
) -> Tokens {
let field_tys: Vec<_> = variant.fields.iter().map(|field| field.ty).collect();
let field_exprs: Vec<_> = variant.fields.iter()
let field_exprs: Vec<_> = variant
.fields
.iter()
.enumerate()
.map(|(i, field)| {
let id = field.ident.as_ref().map_or_else(|| Ident::new(format!("__field{}", i)),
|id| id.clone());
let id = field
.ident
.as_ref()
.map_or_else(|| Ident::new(format!("__field{}", i)), |id| id.clone());
quote!(#id)
})
.collect();
wrap_serialize_with(params, serialize_with, field_tys.as_slice(), field_exprs.as_slice())
wrap_serialize_with(
params,
serialize_with,
field_tys.as_slice(),
field_exprs.as_slice(),
)
}
fn wrap_serialize_with(
@@ -1014,7 +970,11 @@ fn wrap_serialize_with(
//
// where we want to omit the `mut` to avoid a warning.
fn mut_if(is_mut: bool) -> Option<Tokens> {
if is_mut { Some(quote!(mut)) } else { None }
if is_mut {
Some(quote!(mut))
} else {
None
}
}
fn get_field<I>(params: &Parameters, field: &Field, ident: I) -> Tokens
serde_derive_internals/src/ast.rs
+14 -20
View File
@@ -59,19 +59,15 @@ impl<'a> Container<'a> {
};
match body {
Body::Enum(ref mut variants) => {
for ref mut variant in variants {
Body::Enum(ref mut variants) => for ref mut variant in variants {
variant.attrs.rename_by_rule(attrs.rename_all());
for ref mut field in &mut variant.fields {
field.attrs.rename_by_rule(variant.attrs.rename_all());
}
}
}
Body::Struct(_, ref mut fields) => {
for field in fields {
},
Body::Struct(_, ref mut fields) => for field in fields {
field.attrs.rename_by_rule(attrs.rename_all());
}
}
},
}
let item = Container {
@@ -128,16 +124,18 @@ fn struct_from_ast<'a>(
container_default: &attr::Default,
) -> (Style, Vec<Field<'a>>) {
match *data {
syn::VariantData::Struct(ref fields) => {
(Style::Struct, fields_from_ast(cx, fields, attrs, container_default))
}
syn::VariantData::Struct(ref fields) => (
Style::Struct,
fields_from_ast(cx, fields, attrs, container_default),
),
syn::VariantData::Tuple(ref fields) if fields.len() == 1 => (
Style::Newtype,
fields_from_ast(cx, fields, attrs, container_default),
),
syn::VariantData::Tuple(ref fields) => {
(Style::Tuple, fields_from_ast(cx, fields, attrs, container_default))
}
syn::VariantData::Tuple(ref fields) => (
Style::Tuple,
fields_from_ast(cx, fields, attrs, container_default),
),
syn::VariantData::Unit => (Style::Unit, Vec::new()),
}
}
@@ -151,14 +149,10 @@ fn fields_from_ast<'a>(
fields
.iter()
.enumerate()
.map(
|(i, field)| {
Field {
.map(|(i, field)| Field {
ident: field.ident.clone(),
attrs: attr::Field::from_ast(cx, i, field, attrs, container_default),
ty: &field.ty,
}
},
)
})
.collect()
}
serde_derive_internals/src/attr.rs
+78 -89
View File
@@ -216,11 +216,11 @@ impl Container {
if let Ok(s) = get_string_from_lit(cx, name.as_ref(), name.as_ref(), lit) {
match RenameRule::from_str(&s) {
Ok(rename_rule) => rename_all.set(rename_rule),
Err(()) => {
cx.error(format!("unknown rename rule for #[serde(rename_all \
Err(()) => cx.error(format!(
"unknown rename rule for #[serde(rename_all \
= {:?})]",
s))
}
s
)),
}
}
}
@@ -231,19 +231,15 @@ impl Container {
}
// Parse `#[serde(default)]`
MetaItem(Word(ref name)) if name == "default" => {
match item.body {
MetaItem(Word(ref name)) if name == "default" => match item.body {
syn::Body::Struct(syn::VariantData::Struct(_)) => {
default.set(Default::Default);
}
_ => {
cx.error(
_ => cx.error(
"#[serde(default)] can only be used on structs \
with named fields",
)
}
}
}
),
},
// Parse `#[serde(default = "...")]`
MetaItem(NameValue(ref name, ref lit)) if name == "default" => {
@@ -252,12 +248,10 @@ impl Container {
syn::Body::Struct(syn::VariantData::Struct(_)) => {
default.set(Default::Path(path));
}
_ => {
cx.error(
_ => cx.error(
"#[serde(default = \"...\")] can only be used \
on structs with named fields",
)
}
),
}
}
}
@@ -265,7 +259,8 @@ impl Container {
// Parse `#[serde(bound = "D: Serialize")]`
MetaItem(NameValue(ref name, ref lit)) if name == "bound" => {
if let Ok(where_predicates) =
parse_lit_into_where(cx, name.as_ref(), name.as_ref(), lit) {
parse_lit_into_where(cx, name.as_ref(), name.as_ref(), lit)
{
ser_bound.set(where_predicates.clone());
de_bound.set(where_predicates);
}
@@ -280,16 +275,14 @@ impl Container {
}
// Parse `#[serde(untagged)]`
MetaItem(Word(ref name)) if name == "untagged" => {
match item.body {
MetaItem(Word(ref name)) if name == "untagged" => match item.body {
syn::Body::Enum(_) => {
untagged.set_true();
}
syn::Body::Struct(_) => {
cx.error("#[serde(untagged)] can only be used on enums")
}
}
}
},
// Parse `#[serde(tag = "type")]`
MetaItem(NameValue(ref name, ref lit)) if name == "tag" => {
@@ -312,12 +305,10 @@ impl Container {
syn::Body::Enum(_) => {
content.set(s);
}
syn::Body::Struct(_) => {
cx.error(
syn::Body::Struct(_) => cx.error(
"#[serde(content = \"...\")] can only be used on \
enums",
)
}
),
}
}
}
@@ -354,8 +345,10 @@ impl Container {
}
MetaItem(ref meta_item) => {
cx.error(format!("unknown serde container attribute `{}`",
meta_item.name()));
cx.error(format!(
"unknown serde container attribute `{}`",
meta_item.name()
));
}
Literal(_) => {
@@ -443,8 +436,7 @@ fn decide_tag(
if let syn::Body::Enum(ref variants) = item.body {
for variant in variants {
match variant.data {
syn::VariantData::Struct(_) |
syn::VariantData::Unit => {}
syn::VariantData::Struct(_) | syn::VariantData::Unit => {}
syn::VariantData::Tuple(ref fields) => {
if fields.len() != 1 {
cx.error(
@@ -464,21 +456,19 @@ fn decide_tag(
EnumTag::External // doesn't matter, will error
}
(false, None, Some(_)) => {
cx.error("#[serde(tag = \"...\", content = \"...\")] must be used together",);
cx.error("#[serde(tag = \"...\", content = \"...\")] must be used together");
EnumTag::External
}
(true, None, Some(_)) => {
cx.error("untagged enum cannot have #[serde(content = \"...\")]");
EnumTag::External
}
(false, Some(tag), Some(content)) => {
EnumTag::Adjacent {
(false, Some(tag), Some(content)) => EnumTag::Adjacent {
tag: tag,
content: content,
}
}
},
(true, Some(_), Some(_)) => {
cx.error("untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",);
cx.error("untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]");
EnumTag::External
}
}
@@ -493,7 +483,7 @@ fn decide_identifier(
match (&item.body, field_identifier.get(), variant_identifier.get()) {
(_, false, false) => Identifier::No,
(_, true, true) => {
cx.error("`field_identifier` and `variant_identifier` cannot both be set",);
cx.error("`field_identifier` and `variant_identifier` cannot both be set");
Identifier::No
}
(&syn::Body::Struct(_), true, false) => {
@@ -560,11 +550,11 @@ impl Variant {
if let Ok(s) = get_string_from_lit(cx, name.as_ref(), name.as_ref(), lit) {
match RenameRule::from_str(&s) {
Ok(rename_rule) => rename_all.set(rename_rule),
Err(()) => {
cx.error(format!("unknown rename rule for #[serde(rename_all \
Err(()) => cx.error(format!(
"unknown rename rule for #[serde(rename_all \
= {:?})]",
s))
}
s
)),
}
}
}
@@ -611,19 +601,20 @@ impl Variant {
}
// Defer `#[serde(borrow)]` and `#[serde(borrow = "'a + 'b")]`
MetaItem(ref mi) if mi.name() == "borrow" => {
match variant.data {
MetaItem(ref mi) if mi.name() == "borrow" => match variant.data {
syn::VariantData::Tuple(ref fields) if fields.len() == 1 => {
borrow.set(mi.clone());
}
_ => {
cx.error("#[serde(borrow)] may only be used on newtype variants");
}
}
}
},
MetaItem(ref meta_item) => {
cx.error(format!("unknown serde variant attribute `{}`", meta_item.name()));
cx.error(format!(
"unknown serde variant attribute `{}`",
meta_item.name()
));
}
Literal(_) => {
@@ -754,7 +745,12 @@ impl Field {
.as_ref()
.map(|borrow| vec![MetaItem(borrow.clone())]);
for meta_items in field.attrs.iter().filter_map(get_serde_meta_items).chain(variant_borrow) {
for meta_items in field
.attrs
.iter()
.filter_map(get_serde_meta_items)
.chain(variant_borrow)
{
for meta_item in meta_items {
match meta_item {
// Parse `#[serde(rename = "foo")]`
@@ -799,7 +795,7 @@ impl Field {
MetaItem(Word(ref name)) if name == "skip" => {
skip_serializing.set_true();
skip_deserializing.set_true();
},
}
// Parse `#[serde(skip_serializing_if = "...")]`
MetaItem(NameValue(ref name, ref lit)) if name == "skip_serializing_if" => {
@@ -837,7 +833,8 @@ impl Field {
// Parse `#[serde(bound = "D: Serialize")]`
MetaItem(NameValue(ref name, ref lit)) if name == "bound" => {
if let Ok(where_predicates) =
parse_lit_into_where(cx, name.as_ref(), name.as_ref(), lit) {
parse_lit_into_where(cx, name.as_ref(), name.as_ref(), lit)
{
ser_bound.set(where_predicates.clone());
de_bound.set(where_predicates);
}
@@ -864,13 +861,10 @@ impl Field {
if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, &field.ty) {
for lifetime in &lifetimes {
if !borrowable.contains(lifetime) {
cx.error(
format!(
cx.error(format!(
"field `{}` does not have lifetime {}",
ident,
lifetime.ident
),
);
ident, lifetime.ident
));
}
}
borrowed_lifetimes.set(lifetimes);
@@ -886,7 +880,10 @@ impl Field {
}
MetaItem(ref meta_item) => {
cx.error(format!("unknown serde field attribute `{}`", meta_item.name()),);
cx.error(format!(
"unknown serde field attribute `{}`",
meta_item.name()
));
}
Literal(_) => {
@@ -1034,13 +1031,11 @@ where
}
_ => {
cx.error(
format!(
cx.error(format!(
"malformed {0} attribute, expected `{0}(serialize = ..., \
deserialize = ...)`",
attr_name
),
);
));
return Err(());
}
}
@@ -1076,13 +1071,10 @@ fn get_string_from_lit(
if let syn::Lit::Str(ref s, _) = *lit {
Ok(s.clone())
} else {
cx.error(
format!(
cx.error(format!(
"expected serde {} attribute to be a string: `{} = \"...\"`",
attr_name,
meta_item_name
),
);
attr_name, meta_item_name
));
Err(())
}
}
@@ -1113,11 +1105,12 @@ fn parse_lit_into_where(
fn parse_lit_into_ty(cx: &Ctxt, attr_name: &str, lit: &syn::Lit) -> Result<syn::Ty, ()> {
let string = try!(get_string_from_lit(cx, attr_name, attr_name, lit));
syn::parse_type(&string).map_err(
|_| {
cx.error(format!("failed to parse type: {} = {:?}", attr_name, string),)
},
)
syn::parse_type(&string).map_err(|_| {
cx.error(format!(
"failed to parse type: {} = {:?}",
attr_name, string
))
})
}
// Parses a string literal like "'a + 'b + 'c" containing a nonempty list of
@@ -1148,7 +1141,7 @@ fn parse_lit_into_lifetimes(
return Ok(set);
}
}
Err(cx.error(format!("failed to parse borrowed lifetimes: {:?}", string)),)
Err(cx.error(format!("failed to parse borrowed lifetimes: {:?}", string)))
}
// Whether the type looks like it might be `std::borrow::Cow<T>` where elem="T".
@@ -1192,8 +1185,8 @@ fn is_cow(ty: &syn::Ty, elem: &str) -> bool {
return false;
}
};
seg.ident == "Cow" && params.lifetimes.len() == 1 &&
params.types == vec![syn::parse_type(elem).unwrap()] && params.bindings.is_empty()
seg.ident == "Cow" && params.lifetimes.len() == 1
&& params.types == vec![syn::parse_type(elem).unwrap()] && params.bindings.is_empty()
}
// Whether the type looks like it might be `&T` where elem="T". This can have
@@ -1219,8 +1212,8 @@ fn is_cow(ty: &syn::Ty, elem: &str) -> bool {
fn is_rptr(ty: &syn::Ty, elem: &str) -> bool {
match *ty {
syn::Ty::Rptr(Some(_), ref mut_ty) => {
mut_ty.mutability == syn::Mutability::Immutable &&
mut_ty.ty == syn::parse_type(elem).unwrap()
mut_ty.mutability == syn::Mutability::Immutable
&& mut_ty.ty == syn::parse_type(elem).unwrap()
}
_ => false,
}
@@ -1241,7 +1234,7 @@ fn borrowable_lifetimes(
let mut lifetimes = BTreeSet::new();
collect_lifetimes(ty, &mut lifetimes);
if lifetimes.is_empty() {
Err(cx.error(format!("field `{}` has no lifetimes to borrow", name)),)
Err(cx.error(format!("field `{}` has no lifetimes to borrow", name)))
} else {
Ok(lifetimes)
}
@@ -1249,9 +1242,7 @@ fn borrowable_lifetimes(
fn collect_lifetimes(ty: &syn::Ty, out: &mut BTreeSet<syn::Lifetime>) {
match *ty {
syn::Ty::Slice(ref elem) |
syn::Ty::Array(ref elem, _) |
syn::Ty::Paren(ref elem) => {
syn::Ty::Slice(ref elem) | syn::Ty::Array(ref elem, _) | syn::Ty::Paren(ref elem) => {
collect_lifetimes(elem, out);
}
syn::Ty::Ptr(ref elem) => {
@@ -1261,11 +1252,9 @@ fn collect_lifetimes(ty: &syn::Ty, out: &mut BTreeSet<syn::Lifetime>) {
out.extend(lifetime.iter().cloned());
collect_lifetimes(&elem.ty, out);
}
syn::Ty::Tup(ref elems) => {
for elem in elems {
syn::Ty::Tup(ref elems) => for elem in elems {
collect_lifetimes(elem, out);
}
}
},
syn::Ty::Path(ref qself, ref path) => {
if let Some(ref qself) = *qself {
collect_lifetimes(&qself.ty, out);
@@ -1282,11 +1271,11 @@ fn collect_lifetimes(ty: &syn::Ty, out: &mut BTreeSet<syn::Lifetime>) {
}
}
}
syn::Ty::BareFn(_) |
syn::Ty::Never |
syn::Ty::TraitObject(_) |
syn::Ty::ImplTrait(_) |
syn::Ty::Infer |
syn::Ty::Mac(_) => {}
syn::Ty::BareFn(_)
| syn::Ty::Never
| syn::Ty::TraitObject(_)
| syn::Ty::ImplTrait(_)
| syn::Ty::Infer
| syn::Ty::Mac(_) => {}
}
}
serde_derive_internals/src/case.rs
+45 -12
View File
@@ -31,7 +31,7 @@ pub enum RenameRule {
/// Rename direct children to "kebab-case" style.
KebabCase,
/// Rename direct children to "SCREAMING-KEBAB-CASE" style.
ScreamingKebabCase
ScreamingKebabCase,
}
impl RenameRule {
@@ -52,7 +52,9 @@ impl RenameRule {
}
ScreamingSnakeCase => SnakeCase.apply_to_variant(variant).to_ascii_uppercase(),
KebabCase => SnakeCase.apply_to_variant(variant).replace('_', "-"),
ScreamingKebabCase => ScreamingSnakeCase.apply_to_variant(variant).replace('_', "-")
ScreamingKebabCase => ScreamingSnakeCase
.apply_to_variant(variant)
.replace('_', "-"),
}
}
@@ -80,7 +82,7 @@ impl RenameRule {
}
ScreamingSnakeCase => field.to_ascii_uppercase(),
KebabCase => field.replace('_', "-"),
ScreamingKebabCase => ScreamingSnakeCase.apply_to_field(field).replace('_', "-")
ScreamingKebabCase => ScreamingSnakeCase.apply_to_field(field).replace('_', "-"),
}
}
}
@@ -104,10 +106,25 @@ impl FromStr for RenameRule {
#[test]
fn rename_variants() {
for &(original, lower, camel, snake, screaming, kebab, screaming_kebab) in
&[
("Outcome", "outcome", "outcome", "outcome", "OUTCOME", "outcome", "OUTCOME"),
("VeryTasty", "verytasty", "veryTasty", "very_tasty", "VERY_TASTY", "very-tasty", "VERY-TASTY"),
for &(original, lower, camel, snake, screaming, kebab, screaming_kebab) in &[
(
"Outcome",
"outcome",
"outcome",
"outcome",
"OUTCOME",
"outcome",
"OUTCOME",
),
(
"VeryTasty",
"verytasty",
"veryTasty",
"very_tasty",
"VERY_TASTY",
"very-tasty",
"VERY-TASTY",
),
("A", "a", "a", "a", "A", "a", "A"),
("Z42", "z42", "z42", "z42", "Z42", "z42", "Z42"),
] {
@@ -118,16 +135,32 @@ fn rename_variants() {
assert_eq!(SnakeCase.apply_to_variant(original), snake);
assert_eq!(ScreamingSnakeCase.apply_to_variant(original), screaming);
assert_eq!(KebabCase.apply_to_variant(original), kebab);
assert_eq!(ScreamingKebabCase.apply_to_variant(original), screaming_kebab);
assert_eq!(
ScreamingKebabCase.apply_to_variant(original),
screaming_kebab
);
}
}
#[test]
fn rename_fields() {
for &(original, pascal, camel, screaming, kebab, screaming_kebab) in
&[
("outcome", "Outcome", "outcome", "OUTCOME", "outcome", "OUTCOME"),
("very_tasty", "VeryTasty", "veryTasty", "VERY_TASTY", "very-tasty", "VERY-TASTY"),
for &(original, pascal, camel, screaming, kebab, screaming_kebab) in &[
(
"outcome",
"Outcome",
"outcome",
"OUTCOME",
"outcome",
"OUTCOME",
),
(
"very_tasty",
"VeryTasty",
"veryTasty",
"VERY_TASTY",
"very-tasty",
"VERY-TASTY",
),
("a", "A", "a", "A", "a", "A"),
("z42", "Z42", "z42", "Z42", "z42", "Z42"),
] {
serde_derive_internals/src/check.rs
+36 -17
View File
@@ -53,10 +53,13 @@ fn check_identifier(cx: &Ctxt, cont: &Container) {
};
for (i, variant) in variants.iter().enumerate() {
match (variant.style, cont.attrs.identifier(), variant.attrs.other()) {
match (
variant.style,
cont.attrs.identifier(),
variant.attrs.other(),
) {
// The `other` attribute may only be used in a field_identifier.
(_, Identifier::Variant, true) |
(_, Identifier::No, true) => {
(_, Identifier::Variant, true) | (_, Identifier::No, true) => {
cx.error("#[serde(other)] may only be used inside a field_identifier");
}
@@ -109,42 +112,58 @@ 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(format!("variant `{}` cannot have both #[serde(serialize_with)] and \
#[serde(skip_serializing)]", variant.ident));
cx.error(format!(
"variant `{}` cannot have both #[serde(serialize_with)] and \
#[serde(skip_serializing)]",
variant.ident
));
}
for (i, field) in variant.fields.iter().enumerate() {
let ident = field.ident.as_ref().map_or_else(|| format!("{}", i),
|ident| format!("`{}`", ident));
let ident = field
.ident
.as_ref()
.map_or_else(|| format!("{}", i), |ident| format!("`{}`", ident));
if field.attrs.skip_serializing() {
cx.error(format!("variant `{}` cannot have both #[serde(serialize_with)] and \
cx.error(format!(
"variant `{}` cannot have both #[serde(serialize_with)] and \
a field {} marked with #[serde(skip_serializing)]",
variant.ident, ident));
variant.ident, ident
));
}
if field.attrs.skip_serializing_if().is_some() {
cx.error(format!("variant `{}` cannot have both #[serde(serialize_with)] and \
cx.error(format!(
"variant `{}` cannot have both #[serde(serialize_with)] and \
a field {} marked with #[serde(skip_serializing_if)]",
variant.ident, ident));
variant.ident, ident
));
}
}
}
if variant.attrs.deserialize_with().is_some() {
if variant.attrs.skip_deserializing() {
cx.error(format!("variant `{}` cannot have both #[serde(deserialize_with)] and \
#[serde(skip_deserializing)]", variant.ident));
cx.error(format!(
"variant `{}` cannot have both #[serde(deserialize_with)] and \
#[serde(skip_deserializing)]",
variant.ident
));
}
for (i, field) in variant.fields.iter().enumerate() {
if field.attrs.skip_deserializing() {
let ident = field.ident.as_ref().map_or_else(|| format!("{}", i),
|ident| format!("`{}`", ident));
let ident = field
.ident
.as_ref()
.map_or_else(|| format!("{}", i), |ident| format!("`{}`", ident));
cx.error(format!("variant `{}` cannot have both #[serde(deserialize_with)] \
cx.error(format!(
"variant `{}` cannot have both #[serde(deserialize_with)] \
and a field {} marked with #[serde(skip_deserializing)]",
variant.ident, ident));
variant.ident, ident
));
}
}
}
serde_derive_internals/src/ctxt.rs
+3 -1
View File
@@ -16,7 +16,9 @@ pub struct Ctxt {
impl Ctxt {
pub fn new() -> Self {
Ctxt { errors: RefCell::new(Some(Vec::new())) }
Ctxt {
errors: RefCell::new(Some(Vec::new())),
}
}
pub fn error<T: Display>(&self, msg: T) {
serde_test/src/configure.rs
+9 -6
View File
@@ -73,11 +73,17 @@ pub struct Compact<T: ?Sized>(T);
/// ```
pub trait Configure {
/// Marks `self` as using `is_human_readable == true`
fn readable(self) -> Readable<Self> where Self: Sized {
fn readable(self) -> Readable<Self>
where
Self: Sized,
{
Readable(self)
}
/// Marks `self` as using `is_human_readable == false`
fn compact(self) -> Compact<Self> where Self: Sized {
fn compact(self) -> Compact<Self>
where
Self: Sized,
{
Compact(self)
}
}
@@ -158,7 +164,6 @@ where
}
}
macro_rules! forward_method {
($name: ident (self $(, $arg: ident : $arg_type: ty)* ) -> $return_type: ty) => {
fn $name (self $(, $arg : $arg_type)* ) -> $return_type {
@@ -455,8 +460,7 @@ macro_rules! impl_serializer {
impl_serializer!(Readable, true);
impl_serializer!(Compact, false);
use serde::de::{Visitor, EnumAccess, VariantAccess, MapAccess, DeserializeSeed, SeqAccess, Error};
use serde::de::{DeserializeSeed, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor};
macro_rules! forward_deserialize_methods {
( $wrapper : ident ( $( $name: ident ),* ) ) => {
@@ -468,7 +472,6 @@ macro_rules! forward_deserialize_methods {
};
}
macro_rules! impl_deserializer {
($wrapper : ident, $is_human_readable : expr) => {
impl <'de, D> Deserializer<'de> for $wrapper<D> where D: Deserializer<'de> {
serde_test/src/de.rs
+58 -44
View File
@@ -95,15 +95,11 @@ impl<'de> Deserializer<'de> {
where
V: Visitor<'de>,
{
let value = try!(
visitor.visit_seq(
DeserializerSeqVisitor {
let value = try!(visitor.visit_seq(DeserializerSeqVisitor {
de: self,
len: len,
end: end,
},
)
);
},));
assert_next_token!(self, end);
Ok(value)
}
@@ -117,15 +113,11 @@ impl<'de> Deserializer<'de> {
where
V: Visitor<'de>,
{
let value = try!(
visitor.visit_map(
DeserializerMapVisitor {
let value = try!(visitor.visit_map(DeserializerMapVisitor {
de: self,
len: len,
end: end,
},
)
);
},));
assert_next_token!(self, end);
Ok(value)
}
@@ -169,7 +161,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
Token::NewtypeStruct { .. } => visitor.visit_newtype_struct(self),
Token::Seq { len } => self.visit_seq(len, Token::SeqEnd, visitor),
Token::Tuple { len } => self.visit_seq(Some(len), Token::TupleEnd, visitor),
Token::TupleStruct { len, .. } => self.visit_seq(Some(len), Token::TupleStructEnd, visitor),
Token::TupleStruct { len, .. } => {
self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
}
Token::Map { len } => self.visit_map(len, Token::MapEnd, visitor),
Token::Struct { len, .. } => self.visit_map(Some(len), Token::StructEnd, visitor),
Token::Enum { .. } => {
@@ -195,17 +189,28 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
}
Token::UnitVariant { variant, .. } => visitor.visit_str(variant),
Token::NewtypeVariant { variant, .. } => {
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Any),)
}
Token::TupleVariant { variant, .. } => {
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Seq),)
}
Token::StructVariant { variant, .. } => {
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Map),)
}
Token::SeqEnd | Token::TupleEnd | Token::TupleStructEnd | Token::MapEnd |
Token::StructEnd | Token::TupleVariantEnd | Token::StructVariantEnd => {
Token::NewtypeVariant { variant, .. } => visitor.visit_map(EnumMapVisitor::new(
self,
Token::Str(variant),
EnumFormat::Any,
)),
Token::TupleVariant { variant, .. } => visitor.visit_map(EnumMapVisitor::new(
self,
Token::Str(variant),
EnumFormat::Seq,
)),
Token::StructVariant { variant, .. } => visitor.visit_map(EnumMapVisitor::new(
self,
Token::Str(variant),
EnumFormat::Map,
)),
Token::SeqEnd
| Token::TupleEnd
| Token::TupleStructEnd
| Token::MapEnd
| Token::StructEnd
| Token::TupleVariantEnd
| Token::StructVariantEnd => {
unexpected!(token);
}
}
@@ -216,8 +221,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
V: Visitor<'de>,
{
match self.peek_token() {
Token::Unit |
Token::None => {
Token::Unit | Token::None => {
self.next_token();
visitor.visit_none()
}
@@ -244,10 +248,11 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
visitor.visit_enum(DeserializerEnumVisitor { de: self })
}
Token::UnitVariant { name: n, .. } |
Token::NewtypeVariant { name: n, .. } |
Token::TupleVariant { name: n, .. } |
Token::StructVariant { name: n, .. } if name == n => {
Token::UnitVariant { name: n, .. }
| Token::NewtypeVariant { name: n, .. }
| Token::TupleVariant { name: n, .. }
| Token::StructVariant { name: n, .. } if name == n =>
{
visitor.visit_enum(DeserializerEnumVisitor { de: self })
}
_ => {
@@ -269,7 +274,11 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
}
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Error>
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, Error>
where
V: Visitor<'de>,
{
@@ -287,8 +296,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
V: Visitor<'de>,
{
match self.peek_token() {
Token::Unit |
Token::UnitStruct { .. } => {
Token::Unit | Token::UnitStruct { .. } => {
self.next_token();
visitor.visit_unit()
}
@@ -448,10 +456,10 @@ impl<'de, 'a> EnumAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
V: DeserializeSeed<'de>,
{
match self.de.peek_token() {
Token::UnitVariant { variant: v, .. } |
Token::NewtypeVariant { variant: v, .. } |
Token::TupleVariant { variant: v, .. } |
Token::StructVariant { variant: v, .. } => {
Token::UnitVariant { variant: v, .. }
| Token::NewtypeVariant { variant: v, .. }
| Token::TupleVariant { variant: v, .. }
| Token::StructVariant { variant: v, .. } => {
let de = v.into_deserializer();
let value = try!(seed.deserialize(de));
Ok((value, self))
@@ -505,7 +513,9 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
unexpected!(token);
}
}
Token::Seq { len: Some(enum_len) } => {
Token::Seq {
len: Some(enum_len),
} => {
let token = self.de.next_token();
if len == enum_len {
@@ -518,7 +528,11 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
}
}
fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value, Error>
fn struct_variant<V>(
self,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Error>
where
V: Visitor<'de>,
{
@@ -533,7 +547,9 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
unexpected!(token);
}
}
Token::Map { len: Some(enum_len) } => {
Token::Map {
len: Some(enum_len),
} => {
let token = self.de.next_token();
if fields.len() == enum_len {
@@ -581,10 +597,8 @@ impl<'de, 'a> MapAccess<'de> for EnumMapVisitor<'a, 'de> {
{
match self.variant.take() {
Some(Token::Str(variant)) => seed.deserialize(variant.into_deserializer()).map(Some),
Some(Token::Bytes(variant)) => {
seed.deserialize(BytesDeserializer { value: variant })
.map(Some)
}
Some(Token::Bytes(variant)) => seed.deserialize(BytesDeserializer { value: variant })
.map(Some),
Some(Token::U32(variant)) => seed.deserialize(variant.into_deserializer()).map(Some),
Some(other) => unexpected!(other),
None => Ok(None),
serde_test/src/error.rs
+7 -3
View File
@@ -9,7 +9,7 @@
use std::error;
use std::fmt::{self, Display};
use serde::{ser, de};
use serde::{de, ser};
#[derive(Clone, Debug)]
pub struct Error {
@@ -18,13 +18,17 @@ pub struct Error {
impl ser::Error for Error {
fn custom<T: Display>(msg: T) -> Self {
Error { msg: msg.to_string() }
Error {
msg: msg.to_string(),
}
}
}
impl de::Error for Error {
fn custom<T: Display>(msg: T) -> Self {
Error { msg: msg.to_string() }
Error {
msg: msg.to_string(),
}
}
}
serde_test/src/lib.rs
+2 -7
View File
@@ -156,17 +156,12 @@
//! ```
#![doc(html_root_url = "https://docs.rs/serde_test/1.0.24")]
#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
// Whitelisted clippy lints
#![cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
// Whitelisted clippy_pedantic lints
#![cfg_attr(feature = "cargo-clippy", allow(
missing_docs_in_private_items,
stutter,
use_debug,
use_self,
))]
#![cfg_attr(feature = "cargo-clippy",
allow(missing_docs_in_private_items, stutter, use_debug, use_self))]
#[macro_use]
extern crate serde;
serde_test/src/token.rs
+18 -4
View File
@@ -232,7 +232,10 @@ pub enum Token {
/// assert_tokens(&a, &[Token::UnitVariant { name: "E", variant: "A" }]);
/// # }
/// ```
UnitVariant { name: &'static str, variant: &'static str },
UnitVariant {
name: &'static str,
variant: &'static str,
},
/// The header to a serialized newtype struct of the given name.
///
@@ -286,7 +289,10 @@ pub enum Token {
/// ]);
/// # }
/// ```
NewtypeVariant { name: &'static str, variant: &'static str },
NewtypeVariant {
name: &'static str,
variant: &'static str,
},
/// The header to a sequence.
///
@@ -391,7 +397,11 @@ pub enum Token {
/// ]);
/// # }
/// ```
TupleVariant { name: &'static str, variant: &'static str, len: usize },
TupleVariant {
name: &'static str,
variant: &'static str,
len: usize,
},
/// An indicator of the end of a tuple variant.
TupleVariantEnd,
@@ -488,7 +498,11 @@ pub enum Token {
/// ]);
/// # }
/// ```
StructVariant { name: &'static str, variant: &'static str, len: usize },
StructVariant {
name: &'static str,
variant: &'static str,
len: usize,
},
/// An indicator of the end of a struct variant.
StructVariantEnd,
test_suite/tests/test_annotations.rs
+293 -249
View File
File diff suppressed because it is too large Load Diff
test_suite/tests/test_borrow.rs
+12 -15
View File
@@ -13,7 +13,7 @@ extern crate serde;
use serde::{Deserialize, Deserializer};
extern crate serde_test;
use serde_test::{Token, assert_de_tokens, assert_de_tokens_error};
use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
use std::borrow::Cow;
@@ -91,14 +91,14 @@ fn test_struct() {
bb: b"bytes",
},
&[
Token::Struct { name: "Borrowing", len: 2 },
Token::Struct {
name: "Borrowing",
len: 2,
},
Token::BorrowedStr("bs"),
Token::BorrowedStr("str"),
Token::BorrowedStr("bb"),
Token::BorrowedBytes(b"bytes"),
Token::StructEnd,
],
);
@@ -110,19 +110,18 @@ fn test_cow() {
struct Cows<'a, 'b> {
copied: Cow<'a, str>,
#[serde(borrow)]
borrowed: Cow<'b, str>,
#[serde(borrow)] borrowed: Cow<'b, str>,
}
let tokens = &[
Token::Struct { name: "Cows", len: 2 },
Token::Struct {
name: "Cows",
len: 2,
},
Token::Str("copied"),
Token::BorrowedStr("copied"),
Token::Str("borrowed"),
Token::BorrowedStr("borrowed"),
Token::StructEnd,
];
@@ -146,8 +145,7 @@ fn test_lifetimes() {
struct Cows<'a, 'b> {
_copied: Cow<'a, str>,
#[serde(borrow)]
_borrowed: Cow<'b, str>,
#[serde(borrow)] _borrowed: Cow<'b, str>,
}
// Tests that `'de: 'a` is not required by the Deserialize impl.
@@ -160,8 +158,7 @@ fn test_lifetimes() {
#[derive(Deserialize)]
struct Wrap<'a, 'b> {
#[serde(borrow = "'b")]
_cows: Cows<'a, 'b>,
#[serde(borrow = "'b")] _cows: Cows<'a, 'b>,
}
// Tests that `'de: 'a` is not required by the Deserialize impl.
test_suite/tests/test_de.rs
+6 -4
View File
@@ -94,9 +94,7 @@ struct StructSkipDefaultGeneric<T> {
impl Default for StructSkipDefault {
fn default() -> Self {
StructSkipDefault {
a: 16,
}
StructSkipDefault { a: 16 }
}
}
@@ -114,7 +112,11 @@ enum Enum {
Unit,
Simple(i32),
Seq(i32, i32, i32),
Map { a: i32, b: i32, c: i32 },
Map {
a: i32,
b: i32,
c: i32,
},
}
#[derive(PartialEq, Debug, Deserialize)]
test_suite/tests/test_gen.rs
+65 -98
View File
@@ -11,7 +11,6 @@
// types involved.
#![deny(warnings)]
#![cfg_attr(feature = "unstable", feature(non_ascii_idents))]
#[macro_use]
@@ -47,25 +46,21 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
struct With<T> {
t: T,
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
x: X,
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] x: X,
}
assert::<With<i32>>();
#[derive(Serialize, Deserialize)]
struct WithTogether<T> {
t: T,
#[serde(with="both_x")]
x: X,
#[serde(with = "both_x")] x: X,
}
assert::<WithTogether<i32>>();
#[derive(Serialize, Deserialize)]
struct WithRef<'a, T: 'a> {
#[serde(skip_deserializing)]
t: StdOption<&'a T>,
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
x: X,
#[serde(skip_deserializing)] t: StdOption<&'a T>,
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] x: X,
}
assert::<WithRef<i32>>();
@@ -93,19 +88,14 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
enum EnumWith<T> {
Unit,
Newtype(
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
X
),
Newtype(#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X),
Tuple(
T,
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
X
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X,
),
Struct {
t: T,
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
x: X,
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] x: X,
},
}
assert::<EnumWith<i32>>();
@@ -123,17 +113,13 @@ fn test_gen() {
assert_ser::<MultipleRef<i32>>();
#[derive(Serialize, Deserialize)]
struct Newtype(
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
X
);
struct Newtype(#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X);
assert::<Newtype>();
#[derive(Serialize, Deserialize)]
struct Tuple<T>(
T,
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
X
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X,
);
assert::<Tuple<i32>>();
@@ -143,7 +129,9 @@ fn test_gen() {
left: Box<TreeNode<D>>,
right: Box<TreeNode<D>>,
},
Leaf { data: D },
Leaf {
data: D,
},
}
assert::<TreeNode<i32>>();
@@ -188,29 +176,28 @@ fn test_gen() {
assert_ser::<OptionStatic>();
#[derive(Serialize, Deserialize)]
#[serde(bound="D: SerializeWith + DeserializeWith")]
#[serde(bound = "D: SerializeWith + DeserializeWith")]
struct WithTraits1<D, E> {
#[serde(serialize_with="SerializeWith::serialize_with",
deserialize_with="DeserializeWith::deserialize_with")]
#[serde(serialize_with = "SerializeWith::serialize_with",
deserialize_with = "DeserializeWith::deserialize_with")]
d: D,
#[serde(serialize_with="SerializeWith::serialize_with",
deserialize_with="DeserializeWith::deserialize_with",
bound="E: SerializeWith + DeserializeWith")]
#[serde(serialize_with = "SerializeWith::serialize_with",
deserialize_with = "DeserializeWith::deserialize_with",
bound = "E: SerializeWith + DeserializeWith")]
e: E,
}
assert::<WithTraits1<X, X>>();
#[derive(Serialize, Deserialize)]
#[serde(bound(serialize="D: SerializeWith",
deserialize="D: DeserializeWith"))]
#[serde(bound(serialize = "D: SerializeWith", deserialize = "D: DeserializeWith"))]
struct WithTraits2<D, E> {
#[serde(serialize_with="SerializeWith::serialize_with",
deserialize_with="DeserializeWith::deserialize_with")]
#[serde(serialize_with = "SerializeWith::serialize_with",
deserialize_with = "DeserializeWith::deserialize_with")]
d: D,
#[serde(serialize_with="SerializeWith::serialize_with",
bound(serialize="E: SerializeWith"))]
#[serde(deserialize_with="DeserializeWith::deserialize_with",
bound(deserialize="E: DeserializeWith"))]
#[serde(serialize_with = "SerializeWith::serialize_with",
bound(serialize = "E: SerializeWith"))]
#[serde(deserialize_with = "DeserializeWith::deserialize_with",
bound(deserialize = "E: DeserializeWith"))]
e: E,
}
assert::<WithTraits2<X, X>>();
@@ -249,15 +236,13 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
struct BracedSkipAll {
#[serde(skip_deserializing)]
f: u8,
#[serde(skip_deserializing)] f: u8,
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct BracedSkipAllDenyUnknown {
#[serde(skip_deserializing)]
f: u8,
#[serde(skip_deserializing)] f: u8,
}
#[cfg(feature = "unstable")]
@@ -270,17 +255,11 @@ fn test_gen() {
struct EmptyTupleDenyUnknown();
#[derive(Serialize, Deserialize)]
struct TupleSkipAll(
#[serde(skip_deserializing)]
u8
);
struct TupleSkipAll(#[serde(skip_deserializing)] u8);
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct TupleSkipAllDenyUnknown(
#[serde(skip_deserializing)]
u8
);
struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
#[derive(Serialize, Deserialize)]
enum EmptyEnum {}
@@ -301,14 +280,8 @@ fn test_gen() {
enum EmptyVariants {
Braced {},
Tuple(),
BracedSkip {
#[serde(skip_deserializing)]
f: u8,
},
TupleSkip(
#[serde(skip_deserializing)]
u8
),
BracedSkip { #[serde(skip_deserializing)] f: u8 },
TupleSkip(#[serde(skip_deserializing)] u8),
}
#[cfg(feature = "unstable")]
@@ -317,14 +290,8 @@ fn test_gen() {
enum EmptyVariantsDenyUnknown {
Braced {},
Tuple(),
BracedSkip {
#[serde(skip_deserializing)]
f: u8,
},
TupleSkip(
#[serde(skip_deserializing)]
u8
),
BracedSkip { #[serde(skip_deserializing)] f: u8 },
TupleSkip(#[serde(skip_deserializing)] u8),
}
#[derive(Serialize, Deserialize)]
@@ -344,10 +311,8 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
#[serde(untagged, remote = "Or")]
enum OrDef<A, B> {
#[allow(dead_code)]
A(A),
#[allow(dead_code)]
B(B),
#[allow(dead_code)] A(A),
#[allow(dead_code)] B(B),
}
struct Str<'a>(&'a str);
@@ -358,16 +323,13 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
struct Remote<'a> {
#[serde(with = "OrDef")]
or: Or<u8, bool>,
#[serde(borrow, with = "StrDef")]
s: Str<'a>,
#[serde(with = "OrDef")] or: Or<u8, bool>,
#[serde(borrow, with = "StrDef")] s: Str<'a>,
}
#[derive(Serialize, Deserialize)]
enum BorrowVariant<'a> {
#[serde(borrow, with = "StrDef")]
S(Str<'a>),
#[serde(borrow, with = "StrDef")] S(Str<'a>),
}
mod vis {
@@ -381,14 +343,14 @@ fn test_gen() {
// This would not work if SDef::serialize / deserialize are private.
#[derive(Serialize, Deserialize)]
struct RemoteVisibility {
#[serde(with = "vis::SDef")]
s: vis::S,
#[serde(with = "vis::SDef")] s: vis::S,
}
#[derive(Serialize, Deserialize)]
enum ExternallyTaggedVariantWith {
#[allow(dead_code)]
Normal { f1: String },
#[allow(dead_code)] Normal {
f1: String,
},
#[serde(serialize_with = "ser_x")]
#[serde(deserialize_with = "de_x")]
@@ -418,8 +380,9 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
#[serde(tag = "t")]
enum InternallyTaggedVariantWith {
#[allow(dead_code)]
Normal { f1: String },
#[allow(dead_code)] Normal {
f1: String,
},
#[serde(serialize_with = "ser_x")]
#[serde(deserialize_with = "de_x")]
@@ -444,8 +407,9 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
#[serde(tag = "t", content = "c")]
enum AdjacentlyTaggedVariantWith {
#[allow(dead_code)]
Normal { f1: String },
#[allow(dead_code)] Normal {
f1: String,
},
#[serde(serialize_with = "ser_x")]
#[serde(deserialize_with = "de_x")]
@@ -475,8 +439,9 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
#[serde(untagged)]
enum UntaggedVariantWith {
#[allow(dead_code)]
Normal { f1: String },
#[allow(dead_code)] Normal {
f1: String,
},
#[serde(serialize_with = "ser_x")]
#[serde(deserialize_with = "de_x")]
@@ -517,18 +482,14 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
enum StaticStrEnum<'a> {
Struct {
a: &'a str,
b: &'static str,
},
Struct { a: &'a str, b: &'static str },
Tuple(&'a str, &'static str),
Newtype(&'static str),
}
#[derive(Serialize, Deserialize)]
struct SkippedStaticStr {
#[serde(skip_deserializing)]
skipped: &'static str,
#[serde(skip_deserializing)] skipped: &'static str,
other: isize,
}
assert::<SkippedStaticStr>();
@@ -570,7 +531,7 @@ pub fn de_x<'de, D: Deserializer<'de>>(_: D) -> StdResult<X, D::Error> {
}
mod both_x {
pub use super::{ser_x as serialize, de_x as deserialize};
pub use super::{de_x as deserialize, ser_x as serialize};
}
impl SerializeWith for X {
@@ -586,27 +547,33 @@ impl DeserializeWith for X {
}
pub fn serialize_some_unit_variant<S>(_: S) -> StdResult<S::Ok, S::Error>
where S: Serializer,
where
S: Serializer,
{
unimplemented!()
}
pub fn deserialize_some_unit_variant<'de, D>(_: D) -> StdResult<(), D::Error>
where D: Deserializer<'de>,
where
D: Deserializer<'de>,
{
unimplemented!()
}
pub fn serialize_some_other_variant<S>(_: &str, _: &u8, _: S) -> StdResult<S::Ok, S::Error>
where S: Serializer,
where
S: Serializer,
{
unimplemented!()
}
pub fn deserialize_some_other_variant<'de, D>(_: D) -> StdResult<(String, u8), D::Error>
where D: Deserializer<'de>,
where
D: Deserializer<'de>,
{
unimplemented!()
}
pub fn is_zero(n: &u8) -> bool { *n == 0 }
pub fn is_zero(n: &u8) -> bool {
*n == 0
}
test_suite/tests/test_macros.rs
+276 -191
View File
File diff suppressed because it is too large Load Diff
test_suite/tests/test_remote.rs
+1 -3
View File
@@ -118,9 +118,7 @@ struct PrimitivePubDef(u8);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::NewtypePriv")]
struct NewtypePrivDef(
#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")] remote::Unit,
);
struct NewtypePrivDef(#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")] remote::Unit);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::NewtypePub")]