From ee75e6c0e9e5cc359163202554feb00a28b62d0d Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Dec 2017 20:13:08 -0800 Subject: [PATCH] Format with rustfmt-nightly 0.3.4 --- serde/src/de/ignored_any.rs | 2 +- serde/src/de/impls.rs | 90 ++-- serde/src/de/mod.rs | 7 +- serde/src/de/value.rs | 48 +- serde/src/export.rs | 2 +- serde/src/lib.rs | 30 +- serde/src/private/de.rs | 242 +++++---- serde/src/private/ser.rs | 182 ++++--- serde/src/ser/impls.rs | 28 +- serde/src/ser/impossible.rs | 4 +- serde/src/ser/mod.rs | 4 +- serde_derive/src/bound.rs | 118 ++-- serde_derive/src/de.rs | 776 ++++++++++++--------------- serde_derive/src/fragment.rs | 2 +- serde_derive/src/lib.rs | 4 +- serde_derive/src/ser.rs | 422 +++++++-------- serde_derive_internals/src/ast.rs | 48 +- serde_derive_internals/src/attr.rs | 225 ++++---- serde_derive_internals/src/case.rs | 69 ++- serde_derive_internals/src/check.rs | 61 ++- serde_derive_internals/src/ctxt.rs | 4 +- serde_test/src/configure.rs | 15 +- serde_test/src/de.rs | 114 ++-- serde_test/src/error.rs | 10 +- serde_test/src/lib.rs | 9 +- serde_test/src/token.rs | 22 +- test_suite/tests/test_annotations.rs | 650 +++++++++++----------- test_suite/tests/test_borrow.rs | 33 +- test_suite/tests/test_de.rs | 10 +- test_suite/tests/test_gen.rs | 163 +++--- test_suite/tests/test_macros.rs | 531 ++++++++++-------- test_suite/tests/test_remote.rs | 4 +- 32 files changed, 2035 insertions(+), 1894 deletions(-) diff --git a/serde/src/de/ignored_any.rs b/serde/src/de/ignored_any.rs index a4f3abe2..20b06b90 100644 --- a/serde/src/de/ignored_any.rs +++ b/serde/src/de/ignored_any.rs @@ -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. /// diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs index ddd1997c..801d9870 100644 --- a/serde/src/de/impls.rs +++ b/serde/src/de/impls.rs @@ -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 { 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 ArrayVisitor { 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::>() - .map(|vec| OsString::from_wide(&vec)) - } - (OsStringKind::Unix, _) => Err(Error::custom("cannot deserialize Unix OS string on Windows",),), + (OsStringKind::Windows, v) => v.newtype_variant::>() + .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(::duplicate_field("secs_since_epoch")); + return Err(::duplicate_field( + "secs_since_epoch", + )); } secs = Some(try!(map.next_value())); } Field::Nanos => { if nanos.is_some() { - return Err(::duplicate_field("nanos_since_epoch")); + return Err(::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) { - Ok(value) => Err(Error::unknown_variant(value, VARIANTS)), - Err(_) => { - Err(Error::invalid_value(Unexpected::Bytes(value), &self)) - } + _ => 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 where - T: Deserialize<'de> + T: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result, D::Error> where diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index 0403e5d1..fe5b35b3 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -526,7 +526,8 @@ pub trait Deserialize<'de>: Sized { /// than it deserves. #[doc(hidden)] fn deserialize_in_place(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 + } } //////////////////////////////////////////////////////////////////////////////// diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index 241d4df8..6dd1d21f 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -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; fn into_deserializer(self) -> UnitDeserializer { - 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( - self, - len: usize, - visitor: V, - ) -> Result + fn deserialize_tuple(self, len: usize, visitor: V) -> Result where V: de::Visitor<'de>, { @@ -1223,7 +1229,12 @@ mod private { } pub fn unit_only(t: T) -> (T, UnitOnly) { - (t, UnitOnly { marker: PhantomData }) + ( + t, + UnitOnly { + marker: PhantomData, + }, + ) } impl<'de, E> de::VariantAccess<'de> for UnitOnly @@ -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(self, _len: usize, _visitor: V) -> Result 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( @@ -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", + )) } } diff --git a/serde/src/export.rs b/serde/src/export.rs index cb416d9f..772f3103 100644 --- a/serde/src/export.rs +++ b/serde/src/export.rs @@ -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; diff --git a/serde/src/lib.rs b/serde/src/lib.rs index 53d4596d..7081256c 100644 --- a/serde/src/lib.rs +++ b/serde/src/lib.rs @@ -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")] diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs index 884dd70b..33b91a47 100644 --- a/serde/src/private/de.rs +++ b/serde/src/private/de.rs @@ -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` 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(self, value: i16) -> Result @@ -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(self, value: u16) -> Result @@ -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(self) -> Result where F: de::Error, { - ContentVisitor::new().visit_none().map(TagOrContent::Content) + ContentVisitor::new() + .visit_none() + .map(TagOrContent::Content) } fn visit_some(self, deserializer: D) -> Result @@ -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 { - tag: tag, - content: Content::Map(vec), - }, - ) - } + 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(self, field: &str) -> Result @@ -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( - de::Unexpected::Map, - &"map with a single key", - ), - ); + 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( - de::Unexpected::Map, - &"map with a single key", - ), - ); + 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 { - variant: variant, - value: value, - err: PhantomData, - }, - ) + visitor.visit_enum(EnumDeserializer { + variant: variant, + value: value, + err: PhantomData, + }) } fn deserialize_unit_struct( self, _name: &'static str, - visitor: V + visitor: V, ) -> Result 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( - de::Unexpected::Map, - &"map with a single key", - ), - ); + 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( - de::Unexpected::Map, - &"map with a single key", - ), - ); + 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 { - variant: variant, - value: value, - err: PhantomData, - }, - ) + 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(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(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(self, deserializer: D) -> Result diff --git a/serde/src/private/ser.rs b/serde/src/private/ser.rs index 3f60d7cd..3a7e92ba 100644 --- a/serde/src/private/ser.rs +++ b/serde/src/private/ser.rs @@ -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 { - type_ident: type_ident, - variant_ident: variant_ident, - tag: tag, - variant_name: variant_name, - delegate: serializer, - }, - ) + value.serialize(TaggedSerializer { + type_ident: type_ident, + variant_ident: variant_ident, + tag: tag, + variant_name: variant_name, + delegate: serializer, + }) } struct TaggedSerializer { @@ -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) -> Result { @@ -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 { - 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 { - 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), 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( @@ -700,32 +716,26 @@ mod content { where T: Serialize, { - Ok( - Content::NewtypeVariant( - name, - variant_index, - variant, - Box::new(try!(value.serialize(self))), - ), - ) + Ok(Content::NewtypeVariant( + name, + variant_index, + variant, + Box::new(try!(value.serialize(self))), + )) } fn serialize_seq(self, len: Option) -> Result { - Ok( - SerializeSeq { - elements: Vec::with_capacity(len.unwrap_or(0)), - error: PhantomData, - }, - ) + Ok(SerializeSeq { + elements: Vec::with_capacity(len.unwrap_or(0)), + error: PhantomData, + }) } fn serialize_tuple(self, len: usize) -> Result { - Ok( - SerializeTuple { - elements: Vec::with_capacity(len), - error: PhantomData, - }, - ) + 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 { - Ok( - SerializeTupleStruct { - name: name, - fields: Vec::with_capacity(len), - error: PhantomData, - }, - ) + 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 { - Ok( - SerializeTupleVariant { - name: name, - variant_index: variant_index, - variant: variant, - fields: Vec::with_capacity(len), - error: PhantomData, - }, - ) + Ok(SerializeTupleVariant { + name: name, + variant_index: variant_index, + variant: variant, + fields: Vec::with_capacity(len), + error: PhantomData, + }) } fn serialize_map(self, len: Option) -> Result { - Ok( - SerializeMap { - entries: Vec::with_capacity(len.unwrap_or(0)), - key: None, - error: PhantomData, - }, - ) + 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 { - Ok( - SerializeStruct { - name: name, - fields: Vec::with_capacity(len), - error: PhantomData, - }, - ) + 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 { - Ok( - SerializeStructVariant { - name: name, - variant_index: variant_index, - variant: variant, - fields: Vec::with_capacity(len), - error: PhantomData, - }, - ) + 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 { - 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 { - Ok(Content::StructVariant(self.name, self.variant_index, self.variant, self.fields),) + Ok(Content::StructVariant( + self.name, + self.variant_index, + self.variant, + self.fields, + )) } } } diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 3d124ab1..fcda834d 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -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) diff --git a/serde/src/ser/impossible.rs b/serde/src/ser/impossible.rs index f72748f6..af49d14d 100644 --- a/serde/src/ser/impossible.rs +++ b/serde/src/ser/impossible.rs @@ -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. diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index bd0a69ed..e23ef04a 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -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`. diff --git a/serde_derive/src/bound.rs b/serde_derive/src/bound.rs index 5dc68a0f..98f8f475 100644 --- a/serde_derive/src/bound.rs +++ b/serde_derive/src/bound.rs @@ -27,14 +27,10 @@ pub fn without_defaults(generics: &syn::Generics) -> syn::Generics { ty_params: generics .ty_params .iter() - .map( - |ty_param| { - syn::TyParam { - default: None, - ..ty_param.clone() - } - }, - ) + .map(|ty_param| syn::TyParam { + default: None, + ..ty_param.clone() + }) .collect(), ..generics.clone() } @@ -137,17 +133,15 @@ where relevant_ty_params: HashSet::new(), }; match cont.body { - Body::Enum(ref variants) => { - for variant in variants.iter() { - let relevant_fields = variant - .fields - .iter() - .filter(|field| filter(&field.attrs, Some(&variant.attrs))); - for field in relevant_fields { - visit::walk_ty(&mut visitor, field.ty); - } + Body::Enum(ref variants) => for variant in variants.iter() { + let relevant_fields = variant + .fields + .iter() + .filter(|field| filter(&field.attrs, Some(&variant.attrs))); + 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,27 +154,23 @@ where .iter() .map(|ty_param| ty_param.ident.clone()) .filter(|id| visitor.relevant_ty_params.contains(id)) - .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()), - // the bound e.g. Serialize - bounds: vec![ - syn::TyParamBound::Trait( - syn::PolyTraitRef { - bound_lifetimes: Vec::new(), - trait_ref: bound.clone(), - }, - syn::TraitBoundModifier::None, - ), - ], - }, - ) - }, - ); + .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()), + // the bound e.g. Serialize + bounds: vec![ + syn::TyParamBound::Trait( + syn::PolyTraitRef { + bound_lifetimes: Vec::new(), + trait_ref: bound.clone(), + }, + syn::TraitBoundModifier::None, + ), + ], + }) + }); let mut generics = generics.clone(); generics.where_clause.predicates.extend(new_predicates); @@ -196,25 +186,23 @@ pub fn with_self_bound( generics .where_clause .predicates - .push( - syn::WherePredicate::BoundPredicate( - syn::WhereBoundPredicate { - bound_lifetimes: Vec::new(), - // the type that is being bounded e.g. MyStruct<'a, T> - bounded_ty: type_of_item(cont), - // the bound e.g. Default - bounds: vec![ - syn::TyParamBound::Trait( - syn::PolyTraitRef { - bound_lifetimes: Vec::new(), - trait_ref: bound.clone(), - }, - syn::TraitBoundModifier::None, - ), - ], - }, - ), - ); + .push(syn::WherePredicate::BoundPredicate( + syn::WhereBoundPredicate { + bound_lifetimes: Vec::new(), + // the type that is being bounded e.g. MyStruct<'a, T> + bounded_ty: type_of_item(cont), + // the bound e.g. Default + bounds: vec![ + syn::TyParamBound::Trait( + syn::PolyTraitRef { + bound_lifetimes: Vec::new(), + trait_ref: bound.clone(), + }, + syn::TraitBoundModifier::None, + ), + ], + }, + )); 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 { - attrs: Vec::new(), - lifetime: syn::Lifetime::new(lifetime), - bounds: Vec::new(), - }, - ); + generics.lifetimes.push(syn::LifetimeDef { + attrs: Vec::new(), + lifetime: syn::Lifetime::new(lifetime), + bounds: Vec::new(), + }); generics } diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs index 1c985211..294d8168 100644 --- a/serde_derive/src/de.rs +++ b/serde_derive/src/de.rs @@ -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 { match *self { - BorrowedLifetimes::Borrowed(ref bounds) => { - Some(syn::LifetimeDef { - attrs: Vec::new(), - lifetime: syn::Lifetime::new("'de"), - bounds: bounds.iter().cloned().collect(), - }) - } + 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 Option { 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, ) -> Fragment { let this = ¶ms.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, ) -> Fragment { let this = ¶ms.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,42 +520,40 @@ 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)| { - if field.attrs.skip_deserializing() { - let default = Expr(expr_is_missing(&field, cattrs)); - quote! { - let #var = #default; - } - } else { - let visit = match field.attrs.deserialize_with() { - None => { - let field_ty = &field.ty; - 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); - quote!({ - #wrapper - _serde::export::Option::map( - try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)), - |__wrap| __wrap.value) - }) - } - }; - let assign = quote! { - let #var = match #visit { - _serde::export::Some(__value) => __value, - _serde::export::None => { - return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting)); - } - }; - }; - index_in_seq += 1; - assign + let let_values = vars.clone().zip(fields).map(|(var, field)| { + if field.attrs.skip_deserializing() { + let default = Expr(expr_is_missing(&field, cattrs)); + quote! { + let #var = #default; } - }); + } else { + let visit = match field.attrs.deserialize_with() { + None => { + let field_ty = &field.ty; + 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); + quote!({ + #wrapper + _serde::export::Option::map( + try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)), + |__wrap| __wrap.value) + }) + } + }; + let assign = quote! { + let #var = match #visit { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting)); + } + }; + }; + index_in_seq += 1; + assign + } + }); let mut result = if is_struct { let names = fields.iter().map(|f| &f.ident); @@ -584,20 +574,12 @@ fn deserialize_seq( } let let_default = match *cattrs.default() { - attr::Default::Default => { - Some( - quote!( - let __default: Self::Value = _serde::export::Default::default(); - ), - ) - } - attr::Default::Path(ref path) => { - Some( - quote!( - let __default: Self::Value = #path(); - ), - ) - } + attr::Default::Default => Some(quote!( + let __default: Self::Value = _serde::export::Default::default(); + )), + 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 = ¶ms.this; let (_, ty_generics, _) = params.generics.split_for_impl(); let let_default = match *cattrs.default() { - attr::Default::Default => { - Some( - quote!( - let __default: #this #ty_generics = _serde::export::Default::default(); - ), - ) - } - attr::Default::Path(ref path) => { - Some( - quote!( - let __default: #this #ty_generics = #path(); - ), - ) - } + attr::Default::Default => Some(quote!( + let __default: #this #ty_generics = _serde::export::Default::default(); + )), + 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 = ¶ms.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! { - #[inline] - fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result - where __A: _serde::de::SeqAccess<#delife> - { - #visit_seq - } - }) - } + Untagged::No => Some(quote! { + #[inline] + fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result + 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 = ¶ms.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! { - #[inline] - fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result - where __A: _serde::de::SeqAccess<#delife> - { - #visit_seq - } - }) - - } + Untagged::No => Some(quote! { + #[inline] + fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result + 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 = ¶ms.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)| { - let variant_name = field_i(i); + .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 - } - }, - ); + 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 = ¶ms.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)| { - let variant_index = field_i(i); + .map(|(i, variant)| { + let variant_index = field_i(i); - let block = Match( - deserialize_untagged_variant( - params, - variant, - cattrs, - quote!(__deserializer), - ), - ); + let block = Match(deserialize_untagged_variant( + params, + variant, + cattrs, + quote!(__deserializer), + )); - quote! { - __Field::#variant_index => #block - } - }, - ) + 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! { - _ => #missing_content - }, - ) + Some(quote! { + _ => #missing_content + }) }; let arms = variants .iter() .enumerate() - .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), - } - }, - ); + .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,29 +1266,27 @@ fn deserialize_adjacently_tagged_enum( let next_relevant_key = if deny_unknown_fields { next_key } else { - quote! { - { - let mut __rk : _serde::export::Option<_serde::private::de::TagOrContentField> = _serde::export::None; - while let _serde::export::Some(__k) = #next_key { - match __k { - _serde::private::de::TagContentOtherField::Other => { - try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); - continue; - }, - _serde::private::de::TagContentOtherField::Tag => { - __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Tag); - break; - } - _serde::private::de::TagContentOtherField::Content => { - __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Content); - break; - } + quote!({ + let mut __rk : _serde::export::Option<_serde::private::de::TagOrContentField> = _serde::export::None; + while let _serde::export::Some(__k) = #next_key { + match __k { + _serde::private::de::TagContentOtherField::Other => { + try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); + continue; + }, + _serde::private::de::TagContentOtherField::Tag => { + __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Tag); + break; + } + _serde::private::de::TagContentOtherField::Content => { + __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Content); + break; } } - - __rk } - } + + __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| { - Expr(deserialize_untagged_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( - variant_ident, - params, - &variant.fields[0], - deserializer, - ) - } - Style::Struct => { - deserialize_struct( - Some(variant_ident), - params, - &variant.fields, - cattrs, - Some(deserializer), - Untagged::No, - ) - } + Style::Newtype => deserialize_untagged_newtype_variant( + variant_ident, + params, + &variant.fields[0], + deserializer, + ), + 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( - variant_ident, - params, - &variant.fields[0], - deserializer, - ) - } - Style::Tuple => { - deserialize_tuple( - Some(variant_ident), - params, - &variant.fields, - cattrs, - Some(deserializer), - ) - } - Style::Struct => { - deserialize_struct( - Some(variant_ident), - params, - &variant.fields, - cattrs, - Some(deserializer), - Untagged::Yes, - ) - } + Style::Newtype => deserialize_untagged_newtype_variant( + variant_ident, + params, + &variant.fields[0], + deserializer, + ), + Style::Tuple => deserialize_tuple( + Some(variant_ident), + params, + &variant.fields, + cattrs, + Some(deserializer), + ), + 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 @@ -1841,9 +1827,9 @@ fn deserialize_identifier( let field_bytes = fields.iter().map(|&(ref name, _)| quote::ByteStr(name)); let constructors: &Vec<_> = &fields - .iter() - .map(|&(_, ref ident)| quote!(#this::#ident)) - .collect(); + .iter() + .map(|&(_, ref ident)| quote!(#this::#ident)) + .collect(); let expecting = if is_variant { "variant identifier" @@ -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)| { - let field_ty = &field.ty; - quote! { - let mut #name: _serde::export::Option<#field_ty> = _serde::export::None; - } - }, - ); + .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,51 +2026,34 @@ fn deserialize_map( let extract_values = fields_names .iter() .filter(|&&(field, _)| !field.attrs.skip_deserializing()) - .map( - |&(field, ref name)| { - let missing_expr = Match(expr_is_missing(&field, cattrs)); + .map(|&(field, ref name)| { + let missing_expr = Match(expr_is_missing(&field, cattrs)); - quote! { - let #name = match #name { - _serde::export::Some(#name) => #name, - _serde::export::None => #missing_expr - }; - } - }, - ); + quote! { + let #name = match #name { + _serde::export::Some(#name) => #name, + _serde::export::None => #missing_expr + }; + } + }); - 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 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!( - let __default: Self::Value = _serde::export::Default::default(); - ), - ) - } - attr::Default::Path(ref path) => { - Some( - quote!( - let __default: Self::Value = #path(); - ), - ) - } + attr::Default::Default => Some(quote!( + let __default: Self::Value = _serde::export::Default::default(); + )), + 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)| { - quote! { - let mut #name: bool = false; - } - }, - ); + .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,49 +2198,39 @@ fn deserialize_map_in_place( let check_flags = fields_names .iter() .filter(|&&(field, _)| !field.attrs.skip_deserializing()) - .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 - // more elegantly. - if missing_expr.as_ref().as_str().starts_with("return ") { - let missing_expr = Stmts(missing_expr); - quote! { - if !#name { - #missing_expr; - } - } - } else { - let field_name = &field.ident; - let missing_expr = Expr(missing_expr); - quote! { - if !#name { - self.place.#field_name = #missing_expr; - }; + .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 + // more elegantly. + if missing_expr.as_ref().as_str().starts_with("return ") { + let missing_expr = Stmts(missing_expr); + quote! { + if !#name { + #missing_expr; } } - }, - ); + } else { + let field_name = &field.ident; + let missing_expr = Expr(missing_expr); + quote! { + if !#name { + self.place.#field_name = #missing_expr; + }; + } + } + }); let this = ¶ms.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!( - let __default: #this #ty_generics = _serde::export::Default::default(); - ), - ) - } - attr::Default::Path(ref path) => { - Some( - quote!( - let __default: #this #ty_generics = #path(); - ), - ) - } + attr::Default::Default => Some(quote!( + let __default: #this #ty_generics = _serde::export::Default::default(); + )), + 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 = ¶ms.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! { - { - |__wrap| { - #this::#variant_ident { #(#field_idents: __wrap.value.#field_access),* } - } + 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! { - { - |__wrap| { - #this::#variant_ident(#(__wrap.value.#field_access),*) - } - } + Style::Tuple => quote!({ + |__wrap| { + #this::#variant_ident(#(__wrap.value.#field_access),*) } - } - Style::Newtype => { - quote! { - { - |__wrap| { - #this::#variant_ident(__wrap.value) - } - } + }), + Style::Newtype => quote!({ + |__wrap| { + #this::#variant_ident(__wrap.value) } - } - Style::Unit => { - quote! { - { - |__wrap| { #this::#variant_ident } - } - } - } + }), + 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(¶ms); let de_ty_generics = DeTyGenerics(¶ms); let (_, ty_generics, where_clause) = params.generics.split_for_impl(); diff --git a/serde_derive/src/fragment.rs b/serde_derive/src/fragment.rs index c882bcf9..d333cd5f 100644 --- a/serde_derive/src/fragment.rs +++ b/serde_derive/src/fragment.rs @@ -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. diff --git a/serde_derive/src/lib.rs b/serde_derive/src/lib.rs index b3e49c63..a73b374b 100644 --- a/serde_derive/src/lib.rs +++ b/serde_derive/src/lib.rs @@ -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; diff --git a/serde_derive/src/ser.rs b/serde_derive/src/ser.rs index aa489193..56be715d 100644 --- a/serde_derive/src/ser.rs +++ b/serde_derive/src/ser.rs @@ -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( - cont, - &generics, - needs_serialize_bound, - &path!(_serde::Serialize), - ) - } + 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() { - 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 }) - } - }, - ) + .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)| { - serialize_variant(params, variant, variant_index as u32, cattrs) - }, - ) + .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,34 +342,26 @@ 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() { - attr::EnumTag::External => { - serialize_externally_tagged_variant(params, variant, variant_index, cattrs) - } - attr::EnumTag::Internal { ref tag } => { - serialize_internally_tagged_variant(params, variant, cattrs, tag) - } - attr::EnumTag::Adjacent { - ref tag, - ref content, - } => serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content), - attr::EnumTag::None => serialize_untagged_variant(params, variant, cattrs), - }, - ); + let body = Match(match *cattrs.tag() { + attr::EnumTag::External => { + serialize_externally_tagged_variant(params, variant, variant_index, cattrs) + } + attr::EnumTag::Internal { ref tag } => { + serialize_internally_tagged_variant(params, variant, cattrs, tag) + } + attr::EnumTag::Adjacent { + ref tag, + ref content, + } => serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content), + attr::EnumTag::None => serialize_untagged_variant(params, variant, cattrs), + }); quote! { #case => #body @@ -441,28 +419,24 @@ fn serialize_externally_tagged_variant( ) } } - Style::Tuple => { - serialize_tuple_variant( - TupleVariant::ExternallyTagged { - type_name: type_name, - variant_index: variant_index, - variant_name: variant_name, - }, - params, - &variant.fields, - ) - } - Style::Struct => { - serialize_struct_variant( - StructVariant::ExternallyTagged { - variant_index: variant_index, - variant_name: variant_name, - }, - params, - &variant.fields, - &type_name, - ) - } + Style::Tuple => serialize_tuple_variant( + TupleVariant::ExternallyTagged { + type_name: type_name, + variant_index: variant_index, + variant_name: variant_name, + }, + params, + &variant.fields, + ), + Style::Struct => serialize_struct_variant( + StructVariant::ExternallyTagged { + variant_index: variant_index, + variant_name: variant_name, + }, + params, + &variant.fields, + &type_name, + ), } } @@ -520,17 +494,15 @@ fn serialize_internally_tagged_variant( ) } } - Style::Struct => { - serialize_struct_variant( - StructVariant::InternallyTagged { - tag: tag, - variant_name: variant_name, - }, - params, - &variant.fields, - &type_name, - ) - } + Style::Struct => serialize_struct_variant( + StructVariant::InternallyTagged { + tag: tag, + variant_name: variant_name, + }, + params, + &variant.fields, + &type_name, + ), Style::Tuple => unreachable!("checked in serde_derive_internals"), } } @@ -546,48 +518,44 @@ 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 ser = wrap_serialize_variant_with(params, path, &variant); - quote_expr! { - _serde::Serialize::serialize(#ser, __serializer) + 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) + } + } else { + match variant.style { + Style::Unit => { + return quote_block! { + let mut __struct = try!(_serde::Serializer::serialize_struct( + __serializer, #type_name, 1)); + try!(_serde::ser::SerializeStruct::serialize_field( + &mut __struct, #tag, #variant_name)); + _serde::ser::SerializeStruct::end(__struct) + }; } - } else { - match variant.style { - Style::Unit => { - return quote_block! { - let mut __struct = try!(_serde::Serializer::serialize_struct( - __serializer, #type_name, 1)); - try!(_serde::ser::SerializeStruct::serialize_field( - &mut __struct, #tag, #variant_name)); - _serde::ser::SerializeStruct::end(__struct) - }; + Style::Newtype => { + let field = &variant.fields[0]; + let mut field_expr = quote!(__field0); + if let Some(path) = field.attrs.serialize_with() { + field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); } - Style::Newtype => { - let field = &variant.fields[0]; - let mut field_expr = quote!(__field0); - if let Some(path) = field.attrs.serialize_with() { - field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); - } - quote_expr! { - _serde::Serialize::serialize(#field_expr, __serializer) - } - } - Style::Tuple => { - serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields) - } - Style::Struct => { - serialize_struct_variant( - StructVariant::Untagged, - params, - &variant.fields, - &variant_name, - ) + quote_expr! { + _serde::Serialize::serialize(#field_expr, __serializer) } } - }, - ); + Style::Tuple => { + serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields) + } + 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()) - .map(|i| Ident::new(format!("__field{}", i))) - .collect() - } - Style::Struct => { - variant - .fields - .iter() - .map( - |f| { - f.ident - .clone() - .expect("struct variant has unnamed fields") - }, - ) - .collect() - } + Style::Tuple => (0..variant.fields.len()) + .map(|i| Ident::new(format!("__field{}", i))) + .collect(), + Style::Struct => variant + .fields + .iter() + .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 { .. } => { - ( - quote!(_serde::ser::SerializeStructVariant::serialize_field), - quote!(_serde::ser::SerializeStructVariant::skip_field), - ) - } - StructVariant::InternallyTagged { .. } | - StructVariant::Untagged => { - ( - quote!(_serde::ser::SerializeStruct::serialize_field), - quote!(_serde::ser::SerializeStruct::skip_field), - ) - } + StructVariant::ExternallyTagged { .. } => ( + quote!(_serde::ser::SerializeStructVariant::serialize_field), + quote!(_serde::ser::SerializeStructVariant::skip_field), + ), + 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| { - let ident = field.ident.clone().expect("struct has unnamed fields"); + .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), - } - }, - ) + 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,34 +811,32 @@ fn serialize_tuple_struct_visitor( fields .iter() .enumerate() - .map( - |(i, field)| { - let mut field_expr = if is_enum { - let id = Ident::new(format!("__field{}", i)); - quote!(#id) - } else { - get_field(params, field, i) - }; + .map(|(i, field)| { + let mut field_expr = if is_enum { + let id = Ident::new(format!("__field{}", i)); + quote!(#id) + } else { + get_field(params, field, i) + }; - let skip = field - .attrs - .skip_serializing_if() - .map(|path| quote!(#path(#field_expr))); + let skip = field + .attrs + .skip_serializing_if() + .map(|path| quote!(#path(#field_expr))); - if let Some(path) = field.attrs.serialize_with() { - field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); - } + if let Some(path) = field.attrs.serialize_with() { + field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); + } - let ser = quote! { - try!(#func(&mut __serde_state, #field_expr)); - }; + let ser = quote! { + try!(#func(&mut __serde_state, #field_expr)); + }; - match skip { - None => ser, - Some(skip) => quote!(if !#skip { #ser }), - } - }, - ) + match skip { + None => ser, + Some(skip) => quote!(if !#skip { #ser }), + } + }) .collect() } @@ -898,44 +850,42 @@ fn serialize_struct_visitor( fields .iter() .filter(|&field| !field.attrs.skip_serializing()) - .map( - |field| { - let field_ident = field.ident.clone().expect("struct has unnamed field"); - let mut field_expr = if is_enum { - quote!(#field_ident) - } else { - get_field(params, field, field_ident) - }; + .map(|field| { + let field_ident = field.ident.clone().expect("struct has unnamed field"); + let mut field_expr = if is_enum { + quote!(#field_ident) + } else { + get_field(params, field, field_ident) + }; - let key_expr = field.attrs.name().serialize_name(); + let key_expr = field.attrs.name().serialize_name(); - let skip = field - .attrs - .skip_serializing_if() - .map(|path| quote!(#path(#field_expr))); + let skip = field + .attrs + .skip_serializing_if() + .map(|path| quote!(#path(#field_expr))); - if let Some(path) = field.attrs.serialize_with() { - field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); - } + if let Some(path) = field.attrs.serialize_with() { + field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr); + } - let ser = quote! { - try!(#func(&mut __serde_state, #key_expr, #field_expr)); - }; + let ser = quote! { + try!(#func(&mut __serde_state, #key_expr, #field_expr)); + }; - match skip { - None => ser, - Some(skip) => { - quote! { - if !#skip { - #ser - } else { - try!(#skip_func(&mut __serde_state, #key_expr)); - } + match skip { + None => ser, + Some(skip) => { + quote! { + if !#skip { + #ser + } else { + try!(#skip_func(&mut __serde_state, #key_expr)); } } } - }, - ) + } + }) .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 { - if is_mut { Some(quote!(mut)) } else { None } + if is_mut { + Some(quote!(mut)) + } else { + None + } } fn get_field(params: &Parameters, field: &Field, ident: I) -> Tokens diff --git a/serde_derive_internals/src/ast.rs b/serde_derive_internals/src/ast.rs index 83243bcb..698a175c 100644 --- a/serde_derive_internals/src/ast.rs +++ b/serde_derive_internals/src/ast.rs @@ -59,19 +59,15 @@ impl<'a> Container<'a> { }; match body { - 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::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 { - field.attrs.rename_by_rule(attrs.rename_all()); - } - } + }, + 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>) { 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 { - ident: field.ident.clone(), - attrs: attr::Field::from_ast(cx, i, field, attrs, container_default), - ty: &field.ty, - } - }, - ) + .map(|(i, field)| Field { + ident: field.ident.clone(), + attrs: attr::Field::from_ast(cx, i, field, attrs, container_default), + ty: &field.ty, + }) .collect() } diff --git a/serde_derive_internals/src/attr.rs b/serde_derive_internals/src/attr.rs index efe9dff8..ce0ed026 100644 --- a/serde_derive_internals/src/attr.rs +++ b/serde_derive_internals/src/attr.rs @@ -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 \ - = {:?})]", - s)) - } + Err(()) => cx.error(format!( + "unknown rename rule for #[serde(rename_all \ + = {:?})]", + s + )), } } } @@ -231,19 +231,15 @@ impl Container { } // Parse `#[serde(default)]` - MetaItem(Word(ref name)) if name == "default" => { - match item.body { - syn::Body::Struct(syn::VariantData::Struct(_)) => { - default.set(Default::Default); - } - _ => { - cx.error( - "#[serde(default)] can only be used on structs \ - with named fields", - ) - } + MetaItem(Word(ref name)) if name == "default" => match item.body { + syn::Body::Struct(syn::VariantData::Struct(_)) => { + default.set(Default::Default); } - } + _ => 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( - "#[serde(default = \"...\")] can only be used \ - on structs with named fields", - ) - } + _ => 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 { - syn::Body::Enum(_) => { - untagged.set_true(); - } - syn::Body::Struct(_) => { - cx.error("#[serde(untagged)] can only be used on enums") - } + 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( - "#[serde(content = \"...\")] can only be used on \ - enums", - ) - } + 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,13 +436,12 @@ 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( "#[serde(tag = \"...\")] cannot be used with tuple \ - variants", + variants", ); break; } @@ -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 { - tag: tag, - content: content, - } - } + (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 \ - = {:?})]", - s)) - } + Err(()) => cx.error(format!( + "unknown rename rule for #[serde(rename_all \ + = {:?})]", + 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 { - 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 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!( - "field `{}` does not have lifetime {}", - ident, - lifetime.ident - ), - ); + cx.error(format!( + "field `{}` does not have lifetime {}", + 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!( - "malformed {0} attribute, expected `{0}(serialize = ..., \ - deserialize = ...)`", - attr_name - ), - ); + 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!( - "expected serde {} attribute to be a string: `{} = \"...\"`", - attr_name, - meta_item_name - ), - ); + cx.error(format!( + "expected serde {} attribute to be a string: `{} = \"...\"`", + 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 { 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` 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) { 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) { out.extend(lifetime.iter().cloned()); collect_lifetimes(&elem.ty, out); } - syn::Ty::Tup(ref elems) => { - for elem in elems { - collect_lifetimes(elem, out); - } - } + 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::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(_) => {} } } diff --git a/serde_derive_internals/src/case.rs b/serde_derive_internals/src/case.rs index 75c38e48..0da478a1 100644 --- a/serde_derive_internals/src/case.rs +++ b/serde_derive_internals/src/case.rs @@ -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,13 +106,28 @@ 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"), - ("A", "a", "a", "a", "A", "a", "A"), - ("Z42", "z42", "z42", "z42", "Z42", "z42", "Z42"), - ] { + 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"), + ] { assert_eq!(None.apply_to_variant(original), original); assert_eq!(LowerCase.apply_to_variant(original), lower); assert_eq!(PascalCase.apply_to_variant(original), original); @@ -118,19 +135,35 @@ 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"), - ("a", "A", "a", "A", "a", "A"), - ("z42", "Z42", "z42", "Z42", "z42", "Z42"), - ] { + 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"), + ] { assert_eq!(None.apply_to_field(original), original); assert_eq!(PascalCase.apply_to_field(original), pascal); assert_eq!(CamelCase.apply_to_field(original), camel); diff --git a/serde_derive_internals/src/check.rs b/serde_derive_internals/src/check.rs index 5d6a76ff..2dae42f5 100644 --- a/serde_derive_internals/src/check.rs +++ b/serde_derive_internals/src/check.rs @@ -31,7 +31,7 @@ fn check_getter(cx: &Ctxt, cont: &Container) { if cont.body.has_getter() && cont.attrs.remote().is_none() { cx.error( "#[serde(getter = \"...\")] can only be used in structs \ - that have #[serde(remote = \"...\")]", + that have #[serde(remote = \"...\")]", ); } } @@ -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 \ - a field {} marked with #[serde(skip_serializing)]", - variant.ident, ident)); + cx.error(format!( + "variant `{}` cannot have both #[serde(serialize_with)] and \ + a field {} marked with #[serde(skip_serializing)]", + variant.ident, ident + )); } if field.attrs.skip_serializing_if().is_some() { - cx.error(format!("variant `{}` cannot have both #[serde(serialize_with)] and \ - a field {} marked with #[serde(skip_serializing_if)]", - variant.ident, ident)); + cx.error(format!( + "variant `{}` cannot have both #[serde(serialize_with)] and \ + a field {} marked with #[serde(skip_serializing_if)]", + 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)] \ - and a field {} marked with #[serde(skip_deserializing)]", - variant.ident, ident)); + cx.error(format!( + "variant `{}` cannot have both #[serde(deserialize_with)] \ + and a field {} marked with #[serde(skip_deserializing)]", + variant.ident, ident + )); } } } diff --git a/serde_derive_internals/src/ctxt.rs b/serde_derive_internals/src/ctxt.rs index fa8c57ad..0ce7916c 100644 --- a/serde_derive_internals/src/ctxt.rs +++ b/serde_derive_internals/src/ctxt.rs @@ -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(&self, msg: T) { diff --git a/serde_test/src/configure.rs b/serde_test/src/configure.rs index fed06224..6e2b406b 100644 --- a/serde_test/src/configure.rs +++ b/serde_test/src/configure.rs @@ -73,11 +73,17 @@ pub struct Compact(T); /// ``` pub trait Configure { /// Marks `self` as using `is_human_readable == true` - fn readable(self) -> Readable where Self: Sized { + fn readable(self) -> Readable + where + Self: Sized, + { Readable(self) } /// Marks `self` as using `is_human_readable == false` - fn compact(self) -> Compact where Self: Sized { + fn compact(self) -> Compact + 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 where D: Deserializer<'de> { diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs index 015eb97f..92d1494b 100644 --- a/serde_test/src/de.rs +++ b/serde_test/src/de.rs @@ -95,15 +95,11 @@ impl<'de> Deserializer<'de> { where V: Visitor<'de>, { - let value = try!( - visitor.visit_seq( - DeserializerSeqVisitor { - de: self, - len: len, - end: end, - }, - ) - ); + 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 { - de: self, - len: len, - end: end, - }, - ) - ); + 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(self, name: &'static str, visitor: V) -> Result + fn deserialize_newtype_struct( + self, + name: &'static str, + visitor: V, + ) -> Result 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(self, fields: &'static [&'static str], visitor: V) -> Result + fn struct_variant( + self, + fields: &'static [&'static str], + visitor: V, + ) -> Result 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), diff --git a/serde_test/src/error.rs b/serde_test/src/error.rs index 8c529121..ea4d4fa7 100644 --- a/serde_test/src/error.rs +++ b/serde_test/src/error.rs @@ -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(msg: T) -> Self { - Error { msg: msg.to_string() } + Error { + msg: msg.to_string(), + } } } impl de::Error for Error { fn custom(msg: T) -> Self { - Error { msg: msg.to_string() } + Error { + msg: msg.to_string(), + } } } diff --git a/serde_test/src/lib.rs b/serde_test/src/lib.rs index 606bdf2e..62b36304 100644 --- a/serde_test/src/lib.rs +++ b/serde_test/src/lib.rs @@ -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; diff --git a/serde_test/src/token.rs b/serde_test/src/token.rs index b8bdeb81..976bbe36 100644 --- a/serde_test/src/token.rs +++ b/serde_test/src/token.rs @@ -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, diff --git a/test_suite/tests/test_annotations.rs b/test_suite/tests/test_annotations.rs index a175cb70..738a4d00 100644 --- a/test_suite/tests/test_annotations.rs +++ b/test_suite/tests/test_annotations.rs @@ -12,12 +12,12 @@ extern crate serde_derive; extern crate serde; -use self::serde::{Serialize, Serializer, Deserialize, Deserializer}; +use self::serde::{Deserialize, Deserializer, Serialize, Serializer}; use self::serde::de::{self, Unexpected}; extern crate serde_test; -use self::serde_test::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens, - assert_de_tokens_error}; +use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_tokens, + Token}; trait MyDefault: Sized { fn my_default() -> Self; @@ -84,62 +84,56 @@ where E: MyDefault, { a1: A, - #[serde(default)] - a2: B, - #[serde(default="MyDefault::my_default")] - a3: C, - #[serde(skip_deserializing)] - a4: D, - #[serde(skip_deserializing, default="MyDefault::my_default")] - a5: E, + #[serde(default)] a2: B, + #[serde(default = "MyDefault::my_default")] a3: C, + #[serde(skip_deserializing)] a4: D, + #[serde(skip_deserializing, default = "MyDefault::my_default")] a5: E, } #[test] fn test_default_struct() { assert_de_tokens( &DefaultStruct { - a1: 1, - a2: 2, - a3: 3, - a4: 0, - a5: 123, - }, + a1: 1, + a2: 2, + a3: 3, + a4: 0, + a5: 123, + }, &[ - Token::Struct { name: "DefaultStruct", len: 3 }, - + Token::Struct { + name: "DefaultStruct", + len: 3, + }, Token::Str("a1"), Token::I32(1), - Token::Str("a2"), Token::I32(2), - Token::Str("a3"), Token::I32(3), - Token::Str("a4"), Token::I32(4), - Token::Str("a5"), Token::I32(5), - Token::StructEnd, ], ); assert_de_tokens( &DefaultStruct { - a1: 1, - a2: 0, - a3: 123, - a4: 0, - a5: 123, - }, + a1: 1, + a2: 0, + a3: 123, + a4: 0, + a5: 123, + }, &[ - Token::Struct { name: "DefaultStruct", len: 3 }, - + Token::Struct { + name: "DefaultStruct", + len: 3, + }, Token::Str("a1"), Token::I32(1), - Token::StructEnd, ], ); @@ -153,14 +147,10 @@ where { Struct { a1: A, - #[serde(default)] - a2: B, - #[serde(default="MyDefault::my_default")] - a3: C, - #[serde(skip_deserializing)] - a4: D, - #[serde(skip_deserializing, default="MyDefault::my_default")] - a5: E, + #[serde(default)] a2: B, + #[serde(default = "MyDefault::my_default")] a3: C, + #[serde(skip_deserializing)] a4: D, + #[serde(skip_deserializing, default = "MyDefault::my_default")] a5: E, }, } @@ -168,48 +158,48 @@ where fn test_default_enum() { assert_de_tokens( &DefaultEnum::Struct { - a1: 1, - a2: 2, - a3: 3, - a4: 0, - a5: 123, - }, + a1: 1, + a2: 2, + a3: 3, + a4: 0, + a5: 123, + }, &[ - Token::StructVariant { name: "DefaultEnum", variant: "Struct", len: 3 }, - + Token::StructVariant { + name: "DefaultEnum", + variant: "Struct", + len: 3, + }, Token::Str("a1"), Token::I32(1), - Token::Str("a2"), Token::I32(2), - Token::Str("a3"), Token::I32(3), - Token::Str("a4"), Token::I32(4), - Token::Str("a5"), Token::I32(5), - Token::StructVariantEnd, ], ); assert_de_tokens( &DefaultEnum::Struct { - a1: 1, - a2: 0, - a3: 123, - a4: 0, - a5: 123, - }, + a1: 1, + a2: 0, + a3: 123, + a4: 0, + a5: 123, + }, &[ - Token::StructVariant { name: "DefaultEnum", variant: "Struct", len: 3 }, - + Token::StructVariant { + name: "DefaultEnum", + variant: "Struct", + len: 3, + }, Token::Str("a1"), Token::I32(1), - Token::StructVariantEnd, ], ); @@ -227,8 +217,7 @@ impl MyDefault for NoStdDefault { #[derive(Debug, PartialEq, Deserialize)] struct ContainsNoStdDefault { - #[serde(default="MyDefault::my_default")] - a: A, + #[serde(default = "MyDefault::my_default")] a: A, } // Tests that a struct field does not need to implement std::default::Default if @@ -236,19 +225,30 @@ struct ContainsNoStdDefault { #[test] fn test_no_std_default() { assert_de_tokens( - &ContainsNoStdDefault { a: NoStdDefault(123) }, - &[Token::Struct { name: "ContainsNoStdDefault", len: 1 }, Token::StructEnd], + &ContainsNoStdDefault { + a: NoStdDefault(123), + }, + &[ + Token::Struct { + name: "ContainsNoStdDefault", + len: 1, + }, + Token::StructEnd, + ], ); assert_de_tokens( &ContainsNoStdDefault { a: NoStdDefault(8) }, &[ - Token::Struct { name: "ContainsNoStdDefault", len: 1 }, - + Token::Struct { + name: "ContainsNoStdDefault", + len: 1, + }, Token::Str("a"), - Token::NewtypeStruct { name: "NoStdDefault" }, + Token::NewtypeStruct { + name: "NoStdDefault", + }, Token::I8(8), - Token::StructEnd, ], ); @@ -287,14 +287,10 @@ impl MyDefault for NotDeserializeEnum { #[derive(Debug, PartialEq, Deserialize)] struct ContainsNotDeserialize { - #[serde(skip_deserializing)] - a: A, - #[serde(skip_deserializing, default)] - b: B, - #[serde(deserialize_with="DeserializeWith::deserialize_with", default)] - c: C, - #[serde(skip_deserializing, default="MyDefault::my_default")] - e: E, + #[serde(skip_deserializing)] a: A, + #[serde(skip_deserializing, default)] b: B, + #[serde(deserialize_with = "DeserializeWith::deserialize_with", default)] c: C, + #[serde(skip_deserializing, default = "MyDefault::my_default")] e: E, } // Tests that a struct field does not need to implement Deserialize if it is @@ -304,12 +300,18 @@ struct ContainsNotDeserialize { fn test_elt_not_deserialize() { assert_de_tokens( &ContainsNotDeserialize { - a: NotDeserializeStruct(123), - b: NotDeserializeStruct(123), - c: NotDeserializeStruct(123), - e: NotDeserializeEnum::Trouble, - }, - &[Token::Struct { name: "ContainsNotDeserialize", len: 1 }, Token::StructEnd], + a: NotDeserializeStruct(123), + b: NotDeserializeStruct(123), + c: NotDeserializeStruct(123), + e: NotDeserializeEnum::Trouble, + }, + &[ + Token::Struct { + name: "ContainsNotDeserialize", + len: 1, + }, + Token::StructEnd, + ], ); } @@ -324,46 +326,43 @@ fn test_ignore_unknown() { // 'Default' allows unknown. Basic smoke test of ignore... assert_de_tokens( &DefaultStruct { - a1: 1, - a2: 2, - a3: 3, - a4: 0, - a5: 123, - }, + a1: 1, + a2: 2, + a3: 3, + a4: 0, + a5: 123, + }, &[ - Token::Struct { name: "DefaultStruct", len: 3 }, - + Token::Struct { + name: "DefaultStruct", + len: 3, + }, Token::Str("whoops1"), Token::I32(2), - Token::Str("a1"), Token::I32(1), - Token::Str("whoops2"), Token::Seq { len: Some(1) }, Token::I32(2), Token::SeqEnd, - Token::Str("a2"), Token::I32(2), - Token::Str("whoops3"), Token::I32(2), - Token::Str("a3"), Token::I32(3), - Token::StructEnd, ], ); assert_de_tokens_error::( &[ - Token::Struct { name: "DenyUnknown", len: 1 }, - + Token::Struct { + name: "DenyUnknown", + len: 1, + }, Token::Str("a1"), Token::I32(1), - Token::Str("whoops"), ], "unknown field `whoops`, expected `a1`", @@ -371,19 +370,17 @@ fn test_ignore_unknown() { } #[derive(Debug, PartialEq, Serialize, Deserialize)] -#[serde(rename="Superhero")] +#[serde(rename = "Superhero")] struct RenameStruct { a1: i32, - #[serde(rename="a3")] - a2: i32, + #[serde(rename = "a3")] a2: i32, } #[derive(Debug, PartialEq, Serialize, Deserialize)] -#[serde(rename(serialize="SuperheroSer", deserialize="SuperheroDe"))] +#[serde(rename(serialize = "SuperheroSer", deserialize = "SuperheroDe"))] struct RenameStructSerializeDeserialize { a1: i32, - #[serde(rename(serialize="a4", deserialize="a5"))] - a2: i32, + #[serde(rename(serialize = "a4", deserialize = "a5"))] a2: i32, } #[test] @@ -391,14 +388,14 @@ fn test_rename_struct() { assert_tokens( &RenameStruct { a1: 1, a2: 2 }, &[ - Token::Struct { name: "Superhero", len: 2 }, - + Token::Struct { + name: "Superhero", + len: 2, + }, Token::Str("a1"), Token::I32(1), - Token::Str("a3"), Token::I32(2), - Token::StructEnd, ], ); @@ -406,14 +403,14 @@ fn test_rename_struct() { assert_ser_tokens( &RenameStructSerializeDeserialize { a1: 1, a2: 2 }, &[ - Token::Struct { name: "SuperheroSer", len: 2 }, - + Token::Struct { + name: "SuperheroSer", + len: 2, + }, Token::Str("a1"), Token::I32(1), - Token::Str("a4"), Token::I32(2), - Token::StructEnd, ], ); @@ -421,43 +418,36 @@ fn test_rename_struct() { assert_de_tokens( &RenameStructSerializeDeserialize { a1: 1, a2: 2 }, &[ - Token::Struct { name: "SuperheroDe", len: 2 }, - + Token::Struct { + name: "SuperheroDe", + len: 2, + }, Token::Str("a1"), Token::I32(1), - Token::Str("a5"), Token::I32(2), - Token::StructEnd, ], ); } #[derive(Debug, PartialEq, Serialize, Deserialize)] -#[serde(rename="Superhero")] +#[serde(rename = "Superhero")] enum RenameEnum { - #[serde(rename="bruce_wayne")] - Batman, - #[serde(rename="clark_kent")] - Superman(i8), - #[serde(rename="diana_prince")] - WonderWoman(i8, i8), - #[serde(rename="barry_allan")] - Flash { - #[serde(rename="b")] - a: i32, - }, + #[serde(rename = "bruce_wayne")] Batman, + #[serde(rename = "clark_kent")] Superman(i8), + #[serde(rename = "diana_prince")] WonderWoman(i8, i8), + #[serde(rename = "barry_allan")] Flash { #[serde(rename = "b")] a: i32 }, } #[derive(Debug, PartialEq, Deserialize, Serialize)] -#[serde(rename(serialize="SuperheroSer", deserialize="SuperheroDe"))] +#[serde(rename(serialize = "SuperheroSer", deserialize = "SuperheroDe"))] enum RenameEnumSerializeDeserialize { - #[serde(rename(serialize="dick_grayson", deserialize="jason_todd"))] + #[serde(rename(serialize = "dick_grayson", deserialize = "jason_todd"))] Robin { a: i8, - #[serde(rename(serialize="c"))] - #[serde(rename(deserialize="d"))] + #[serde(rename(serialize = "c"))] + #[serde(rename(deserialize = "d"))] b: A, }, } @@ -466,13 +456,21 @@ enum RenameEnumSerializeDeserialize { fn test_rename_enum() { assert_tokens( &RenameEnum::Batman, - &[Token::UnitVariant { name: "Superhero", variant: "bruce_wayne" }], + &[ + Token::UnitVariant { + name: "Superhero", + variant: "bruce_wayne", + }, + ], ); assert_tokens( &RenameEnum::Superman(0), &[ - Token::NewtypeVariant { name: "Superhero", variant: "clark_kent" }, + Token::NewtypeVariant { + name: "Superhero", + variant: "clark_kent", + }, Token::I8(0), ], ); @@ -480,7 +478,11 @@ fn test_rename_enum() { assert_tokens( &RenameEnum::WonderWoman(0, 1), &[ - Token::TupleVariant { name: "Superhero", variant: "diana_prince", len: 2 }, + Token::TupleVariant { + name: "Superhero", + variant: "diana_prince", + len: 2, + }, Token::I8(0), Token::I8(1), Token::TupleVariantEnd, @@ -490,47 +492,51 @@ fn test_rename_enum() { assert_tokens( &RenameEnum::Flash { a: 1 }, &[ - Token::StructVariant { name: "Superhero", variant: "barry_allan", len: 1 }, - + Token::StructVariant { + name: "Superhero", + variant: "barry_allan", + len: 1, + }, Token::Str("b"), Token::I32(1), - Token::StructVariantEnd, ], ); assert_ser_tokens( &RenameEnumSerializeDeserialize::Robin { - a: 0, - b: String::new(), - }, + a: 0, + b: String::new(), + }, &[ - Token::StructVariant { name: "SuperheroSer", variant: "dick_grayson", len: 2 }, - + Token::StructVariant { + name: "SuperheroSer", + variant: "dick_grayson", + len: 2, + }, Token::Str("a"), Token::I8(0), - Token::Str("c"), Token::Str(""), - Token::StructVariantEnd, ], ); assert_de_tokens( &RenameEnumSerializeDeserialize::Robin { - a: 0, - b: String::new(), - }, + a: 0, + b: String::new(), + }, &[ - Token::StructVariant { name: "SuperheroDe", variant: "jason_todd", len: 2 }, - + Token::StructVariant { + name: "SuperheroDe", + variant: "jason_todd", + len: 2, + }, Token::Str("a"), Token::I8(0), - Token::Str("d"), Token::Str(""), - Token::StructVariantEnd, ], ); @@ -542,10 +548,8 @@ where C: ShouldSkip, { a: &'a i8, - #[serde(skip_serializing)] - b: B, - #[serde(skip_serializing_if="ShouldSkip::should_skip")] - c: C, + #[serde(skip_serializing)] b: B, + #[serde(skip_serializing_if = "ShouldSkip::should_skip")] c: C, } #[test] @@ -554,41 +558,40 @@ fn test_skip_serializing_struct() { assert_ser_tokens( &SkipSerializingStruct { a: &a, b: 2, c: 3 }, &[ - Token::Struct { name: "SkipSerializingStruct", len: 2 }, - + Token::Struct { + name: "SkipSerializingStruct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("c"), Token::I32(3), - Token::StructEnd, ], ); assert_ser_tokens( &SkipSerializingStruct { - a: &a, - b: 2, - c: 123, - }, + a: &a, + b: 2, + c: 123, + }, &[ - Token::Struct { name: "SkipSerializingStruct", len: 1 }, - + Token::Struct { + name: "SkipSerializingStruct", + len: 1, + }, Token::Str("a"), Token::I8(1), - Token::StructEnd, ], ); } #[derive(Debug, PartialEq, Serialize, Deserialize)] -struct SkipStruct -{ +struct SkipStruct { a: i8, - #[serde(skip)] - b: B, + #[serde(skip)] b: B, } #[test] @@ -596,11 +599,12 @@ fn test_skip_struct() { assert_ser_tokens( &SkipStruct { a: 1, b: 2 }, &[ - Token::Struct { name: "SkipStruct", len: 1 }, - + Token::Struct { + name: "SkipStruct", + len: 1, + }, Token::Str("a"), Token::I8(1), - Token::StructEnd, ], ); @@ -608,11 +612,12 @@ fn test_skip_struct() { assert_de_tokens( &SkipStruct { a: 1, b: 0 }, &[ - Token::Struct { name: "SkipStruct", len: 1 }, - + Token::Struct { + name: "SkipStruct", + len: 1, + }, Token::Str("a"), Token::I8(1), - Token::StructEnd, ], ); @@ -625,10 +630,8 @@ where { Struct { a: &'a i8, - #[serde(skip_serializing)] - _b: B, - #[serde(skip_serializing_if="ShouldSkip::should_skip")] - c: C, + #[serde(skip_serializing)] _b: B, + #[serde(skip_serializing_if = "ShouldSkip::should_skip")] c: C, }, } @@ -638,30 +641,33 @@ fn test_skip_serializing_enum() { assert_ser_tokens( &SkipSerializingEnum::Struct { a: &a, _b: 2, c: 3 }, &[ - Token::StructVariant { name: "SkipSerializingEnum", variant: "Struct", len: 2 }, - + Token::StructVariant { + name: "SkipSerializingEnum", + variant: "Struct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("c"), Token::I32(3), - Token::StructVariantEnd, ], ); assert_ser_tokens( &SkipSerializingEnum::Struct { - a: &a, - _b: 2, - c: 123, - }, + a: &a, + _b: 2, + c: 123, + }, &[ - Token::StructVariant { name: "SkipSerializingEnum", variant: "Struct", len: 1 }, - + Token::StructVariant { + name: "SkipSerializingEnum", + variant: "Struct", + len: 1, + }, Token::Str("a"), Token::I8(1), - Token::StructVariantEnd, ], ); @@ -691,12 +697,9 @@ where D: SerializeWith, { a: &'a Option, - #[serde(skip_serializing)] - b: &'a B, - #[serde(skip_serializing)] - c: Option, - #[serde(serialize_with="SerializeWith::serialize_with")] - d: D, + #[serde(skip_serializing)] b: &'a B, + #[serde(skip_serializing)] c: Option, + #[serde(serialize_with = "SerializeWith::serialize_with")] d: D, } #[test] @@ -704,21 +707,21 @@ fn test_elt_not_serialize() { let a = 1; assert_ser_tokens( &ContainsNotSerialize { - a: &Some(a), - b: &NotSerializeStruct(2), - c: Some(NotSerializeEnum::Trouble), - d: NotSerializeEnum::Trouble, - }, + a: &Some(a), + b: &NotSerializeStruct(2), + c: Some(NotSerializeEnum::Trouble), + d: NotSerializeEnum::Trouble, + }, &[ - Token::Struct { name: "ContainsNotSerialize", len: 2 }, - + Token::Struct { + name: "ContainsNotSerialize", + len: 2, + }, Token::Str("a"), Token::Some, Token::I8(1), - Token::Str("d"), Token::Str("trouble"), - Token::StructEnd, ], ); @@ -730,8 +733,7 @@ where B: SerializeWith, { a: &'a i8, - #[serde(serialize_with="SerializeWith::serialize_with")] - b: B, + #[serde(serialize_with = "SerializeWith::serialize_with")] b: B, } #[test] @@ -740,14 +742,14 @@ fn test_serialize_with_struct() { assert_ser_tokens( &SerializeWithStruct { a: &a, b: 2 }, &[ - Token::Struct { name: "SerializeWithStruct", len: 2 }, - + Token::Struct { + name: "SerializeWithStruct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::Bool(false), - Token::StructEnd, ], ); @@ -755,14 +757,14 @@ fn test_serialize_with_struct() { assert_ser_tokens( &SerializeWithStruct { a: &a, b: 123 }, &[ - Token::Struct { name: "SerializeWithStruct", len: 2 }, - + Token::Struct { + name: "SerializeWithStruct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::Bool(true), - Token::StructEnd, ], ); @@ -775,8 +777,7 @@ where { Struct { a: &'a i8, - #[serde(serialize_with="SerializeWith::serialize_with")] - b: B, + #[serde(serialize_with = "SerializeWith::serialize_with")] b: B, }, } @@ -786,14 +787,15 @@ fn test_serialize_with_enum() { assert_ser_tokens( &SerializeWithEnum::Struct { a: &a, b: 2 }, &[ - Token::StructVariant { name: "SerializeWithEnum", variant: "Struct", len: 2 }, - + Token::StructVariant { + name: "SerializeWithEnum", + variant: "Struct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::Bool(false), - Token::StructVariantEnd, ], ); @@ -801,14 +803,15 @@ fn test_serialize_with_enum() { assert_ser_tokens( &SerializeWithEnum::Struct { a: &a, b: 123 }, &[ - Token::StructVariant { name: "SerializeWithEnum", variant: "Struct", len: 2 }, - + Token::StructVariant { + name: "SerializeWithEnum", + variant: "Struct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::Bool(true), - Token::StructVariantEnd, ], ); @@ -816,34 +819,33 @@ fn test_serialize_with_enum() { #[derive(Debug, PartialEq, Serialize, Deserialize)] enum WithVariant { - #[serde(serialize_with="serialize_unit_variant_as_i8")] - #[serde(deserialize_with="deserialize_i8_as_unit_variant")] + #[serde(serialize_with = "serialize_unit_variant_as_i8")] + #[serde(deserialize_with = "deserialize_i8_as_unit_variant")] Unit, - #[serde(serialize_with="SerializeWith::serialize_with")] - #[serde(deserialize_with="DeserializeWith::deserialize_with")] + #[serde(serialize_with = "SerializeWith::serialize_with")] + #[serde(deserialize_with = "DeserializeWith::deserialize_with")] Newtype(i32), - #[serde(serialize_with="serialize_variant_as_string")] - #[serde(deserialize_with="deserialize_string_as_variant")] + #[serde(serialize_with = "serialize_variant_as_string")] + #[serde(deserialize_with = "deserialize_string_as_variant")] Tuple(String, u8), - #[serde(serialize_with="serialize_variant_as_string")] - #[serde(deserialize_with="deserialize_string_as_variant")] - Struct { - f1: String, - f2: u8, - }, + #[serde(serialize_with = "serialize_variant_as_string")] + #[serde(deserialize_with = "deserialize_string_as_variant")] + Struct { f1: String, f2: u8 }, } fn serialize_unit_variant_as_i8(serializer: S) -> Result - where S: Serializer, +where + S: Serializer, { serializer.serialize_i8(0) } fn deserialize_i8_as_unit_variant<'de, D>(deserializer: D) -> Result<(), D::Error> - where D: Deserializer<'de>, +where + D: Deserializer<'de>, { let n = i8::deserialize(deserializer)?; match n { @@ -852,17 +854,16 @@ fn deserialize_i8_as_unit_variant<'de, D>(deserializer: D) -> Result<(), D::Erro } } -fn serialize_variant_as_string(f1: &str, - f2: &u8, - serializer: S) - -> Result - where S: Serializer, +fn serialize_variant_as_string(f1: &str, f2: &u8, serializer: S) -> Result +where + S: Serializer, { serializer.serialize_str(format!("{};{:?}", f1, f2).as_str()) } fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8), D::Error> - where D: Deserializer<'de>, +where + D: Deserializer<'de>, { let s = String::deserialize(deserializer)?; let mut pieces = s.split(';'); @@ -877,7 +878,10 @@ fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8) let f2 = match f2.parse() { Ok(n) => n, Err(_) => { - return Err(de::Error::invalid_value(Unexpected::Str(f2), &"an 8-bit signed integer")); + return Err(de::Error::invalid_value( + Unexpected::Str(f2), + &"an 8-bit signed integer", + )); } }; Ok((f1.into(), f2)) @@ -888,7 +892,10 @@ fn test_serialize_with_variant() { assert_ser_tokens( &WithVariant::Unit, &[ - Token::NewtypeVariant { name: "WithVariant", variant: "Unit" }, + Token::NewtypeVariant { + name: "WithVariant", + variant: "Unit", + }, Token::I8(0), ], ); @@ -896,7 +903,10 @@ fn test_serialize_with_variant() { assert_ser_tokens( &WithVariant::Newtype(123), &[ - Token::NewtypeVariant { name: "WithVariant", variant: "Newtype" }, + Token::NewtypeVariant { + name: "WithVariant", + variant: "Newtype", + }, Token::Bool(true), ], ); @@ -904,15 +914,24 @@ fn test_serialize_with_variant() { assert_ser_tokens( &WithVariant::Tuple("hello".into(), 0), &[ - Token::NewtypeVariant { name: "WithVariant", variant: "Tuple" }, + Token::NewtypeVariant { + name: "WithVariant", + variant: "Tuple", + }, Token::Str("hello;0"), ], ); assert_ser_tokens( - &WithVariant::Struct { f1: "world".into(), f2: 1 }, + &WithVariant::Struct { + f1: "world".into(), + f2: 1, + }, &[ - Token::NewtypeVariant { name: "WithVariant", variant: "Struct" }, + Token::NewtypeVariant { + name: "WithVariant", + variant: "Struct", + }, Token::Str("world;1"), ], ); @@ -923,7 +942,10 @@ fn test_deserialize_with_variant() { assert_de_tokens( &WithVariant::Unit, &[ - Token::NewtypeVariant { name: "WithVariant", variant: "Unit" }, + Token::NewtypeVariant { + name: "WithVariant", + variant: "Unit", + }, Token::I8(0), ], ); @@ -931,7 +953,10 @@ fn test_deserialize_with_variant() { assert_de_tokens( &WithVariant::Newtype(123), &[ - Token::NewtypeVariant { name: "WithVariant", variant: "Newtype" }, + Token::NewtypeVariant { + name: "WithVariant", + variant: "Newtype", + }, Token::Bool(true), ], ); @@ -939,15 +964,24 @@ fn test_deserialize_with_variant() { assert_de_tokens( &WithVariant::Tuple("hello".into(), 0), &[ - Token::NewtypeVariant { name: "WithVariant", variant: "Tuple" }, + Token::NewtypeVariant { + name: "WithVariant", + variant: "Tuple", + }, Token::Str("hello;0"), ], ); assert_de_tokens( - &WithVariant::Struct { f1: "world".into(), f2: 1 }, + &WithVariant::Struct { + f1: "world".into(), + f2: 1, + }, &[ - Token::NewtypeVariant { name: "WithVariant", variant: "Struct" }, + Token::NewtypeVariant { + name: "WithVariant", + variant: "Struct", + }, Token::Str("world;1"), ], ); @@ -959,8 +993,7 @@ where B: DeserializeWith, { a: i8, - #[serde(deserialize_with="DeserializeWith::deserialize_with")] - b: B, + #[serde(deserialize_with = "DeserializeWith::deserialize_with")] b: B, } #[test] @@ -968,14 +1001,14 @@ fn test_deserialize_with_struct() { assert_de_tokens( &DeserializeWithStruct { a: 1, b: 2 }, &[ - Token::Struct { name: "DeserializeWithStruct", len: 2 }, - + Token::Struct { + name: "DeserializeWithStruct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::Bool(false), - Token::StructEnd, ], ); @@ -983,14 +1016,14 @@ fn test_deserialize_with_struct() { assert_de_tokens( &DeserializeWithStruct { a: 1, b: 123 }, &[ - Token::Struct { name: "DeserializeWithStruct", len: 2 }, - + Token::Struct { + name: "DeserializeWithStruct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::Bool(true), - Token::StructEnd, ], ); @@ -1003,8 +1036,7 @@ where { Struct { a: i8, - #[serde(deserialize_with="DeserializeWith::deserialize_with")] - b: B, + #[serde(deserialize_with = "DeserializeWith::deserialize_with")] b: B, }, } @@ -1013,14 +1045,15 @@ fn test_deserialize_with_enum() { assert_de_tokens( &DeserializeWithEnum::Struct { a: 1, b: 2 }, &[ - Token::StructVariant { name: "DeserializeWithEnum", variant: "Struct", len: 2 }, - + Token::StructVariant { + name: "DeserializeWithEnum", + variant: "Struct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::Bool(false), - Token::StructVariantEnd, ], ); @@ -1028,14 +1061,15 @@ fn test_deserialize_with_enum() { assert_de_tokens( &DeserializeWithEnum::Struct { a: 1, b: 123 }, &[ - Token::StructVariant { name: "DeserializeWithEnum", variant: "Struct", len: 2 }, - + Token::StructVariant { + name: "DeserializeWithEnum", + variant: "Struct", + len: 2, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::Bool(true), - Token::StructVariantEnd, ], ); @@ -1045,11 +1079,12 @@ fn test_deserialize_with_enum() { fn test_missing_renamed_field_struct() { assert_de_tokens_error::( &[ - Token::Struct { name: "Superhero", len: 2 }, - + Token::Struct { + name: "Superhero", + len: 2, + }, Token::Str("a1"), Token::I32(1), - Token::StructEnd, ], "missing field `a3`", @@ -1057,11 +1092,12 @@ fn test_missing_renamed_field_struct() { assert_de_tokens_error::( &[ - Token::Struct { name: "SuperheroDe", len: 2 }, - + Token::Struct { + name: "SuperheroDe", + len: 2, + }, Token::Str("a1"), Token::I32(1), - Token::StructEnd, ], "missing field `a5`", @@ -1072,8 +1108,11 @@ fn test_missing_renamed_field_struct() { fn test_missing_renamed_field_enum() { assert_de_tokens_error::( &[ - Token::StructVariant { name: "Superhero", variant: "barry_allan", len: 1 }, - + Token::StructVariant { + name: "Superhero", + variant: "barry_allan", + len: 1, + }, Token::StructVariantEnd, ], "missing field `b`", @@ -1081,11 +1120,13 @@ fn test_missing_renamed_field_enum() { assert_de_tokens_error::>( &[ - Token::StructVariant { name: "SuperheroDe", variant: "jason_todd", len: 2 }, - + Token::StructVariant { + name: "SuperheroDe", + variant: "jason_todd", + len: 2, + }, Token::Str("a"), Token::I8(0), - Token::StructVariantEnd, ], "missing field `d`", @@ -1095,19 +1136,18 @@ fn test_missing_renamed_field_enum() { #[derive(Debug, PartialEq, Deserialize)] enum InvalidLengthEnum { A(i32, i32, i32), - B( - #[serde(skip_deserializing)] - i32, - i32, - i32 - ), + B(#[serde(skip_deserializing)] i32, i32, i32), } #[test] fn test_invalid_length_enum() { assert_de_tokens_error::( &[ - Token::TupleVariant { name: "InvalidLengthEnum", variant: "A", len: 3 }, + Token::TupleVariant { + name: "InvalidLengthEnum", + variant: "A", + len: 3, + }, Token::I32(1), Token::TupleVariantEnd, ], @@ -1115,7 +1155,11 @@ fn test_invalid_length_enum() { ); assert_de_tokens_error::( &[ - Token::TupleVariant { name: "InvalidLengthEnum", variant: "B", len: 3 }, + Token::TupleVariant { + name: "InvalidLengthEnum", + variant: "B", + len: 3, + }, Token::I32(1), Token::TupleVariantEnd, ], @@ -1124,7 +1168,7 @@ fn test_invalid_length_enum() { } #[derive(Clone, Serialize, Deserialize, PartialEq, Debug)] -#[serde(into="EnumToU32", from="EnumToU32")] +#[serde(into = "EnumToU32", from = "EnumToU32")] struct StructFromEnum(Option); impl Into for StructFromEnum { @@ -1142,7 +1186,7 @@ impl From for StructFromEnum { } #[derive(Clone, Serialize, Deserialize, PartialEq, Debug)] -#[serde(into="Option", from="Option")] +#[serde(into = "Option", from = "Option")] enum EnumToU32 { One, Two, diff --git a/test_suite/tests/test_borrow.rs b/test_suite/tests/test_borrow.rs index fdbff33a..6fe3f2ee 100644 --- a/test_suite/tests/test_borrow.rs +++ b/test_suite/tests/test_borrow.rs @@ -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; @@ -87,18 +87,18 @@ fn test_struct() { assert_de_tokens( &Borrowing { - bs: "str", - bb: b"bytes", - }, + bs: "str", + 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. diff --git a/test_suite/tests/test_de.rs b/test_suite/tests/test_de.rs index 58bcf464..c0983371 100644 --- a/test_suite/tests/test_de.rs +++ b/test_suite/tests/test_de.rs @@ -94,9 +94,7 @@ struct StructSkipDefaultGeneric { 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)] diff --git a/test_suite/tests/test_gen.rs b/test_suite/tests/test_gen.rs index 4a4cbc9f..6d1a5920 100644 --- a/test_suite/tests/test_gen.rs +++ b/test_suite/tests/test_gen.rs @@ -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, - #[serde(serialize_with="ser_x", deserialize_with="de_x")] - x: X, + #[serde(serialize_with = "ser_x", deserialize_with = "de_x")] x: X, } assert::>(); #[derive(Serialize, Deserialize)] struct WithTogether { t: T, - #[serde(with="both_x")] - x: X, + #[serde(with = "both_x")] x: X, } assert::>(); #[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::>(); @@ -93,19 +88,14 @@ fn test_gen() { #[derive(Serialize, Deserialize)] enum EnumWith { 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::>(); @@ -123,17 +113,13 @@ fn test_gen() { assert_ser::>(); #[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::(); #[derive(Serialize, Deserialize)] struct Tuple( T, - #[serde(serialize_with="ser_x", deserialize_with="de_x")] - X + #[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X, ); assert::>(); @@ -143,7 +129,9 @@ fn test_gen() { left: Box>, right: Box>, }, - Leaf { data: D }, + Leaf { + data: D, + }, } assert::>(); @@ -188,29 +176,28 @@ fn test_gen() { assert_ser::(); #[derive(Serialize, Deserialize)] - #[serde(bound="D: SerializeWith + DeserializeWith")] + #[serde(bound = "D: SerializeWith + DeserializeWith")] struct WithTraits1 { - #[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::>(); #[derive(Serialize, Deserialize)] - #[serde(bound(serialize="D: SerializeWith", - deserialize="D: DeserializeWith"))] + #[serde(bound(serialize = "D: SerializeWith", deserialize = "D: DeserializeWith"))] struct WithTraits2 { - #[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::>(); @@ -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 { - #[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, - #[serde(borrow, with = "StrDef")] - s: Str<'a>, + #[serde(with = "OrDef")] or: Or, + #[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::(); @@ -570,7 +531,7 @@ pub fn de_x<'de, D: Deserializer<'de>>(_: D) -> StdResult { } 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) -> StdResult - 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(_: &str, _: &u8, _: S) -> StdResult - 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 +} diff --git a/test_suite/tests/test_macros.rs b/test_suite/tests/test_macros.rs index 87e86a30..661bdc21 100644 --- a/test_suite/tests/test_macros.rs +++ b/test_suite/tests/test_macros.rs @@ -12,8 +12,8 @@ extern crate serde_derive; extern crate serde_test; -use self::serde_test::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens, - assert_de_tokens_error}; +use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_tokens, + Token}; use std::collections::BTreeMap; use std::marker::PhantomData; @@ -128,7 +128,10 @@ fn test_ser_named_tuple() { assert_ser_tokens( &SerNamedTuple(&a, &mut b, c), &[ - Token::TupleStruct { name: "SerNamedTuple", len: 3 }, + Token::TupleStruct { + name: "SerNamedTuple", + len: 3, + }, Token::I32(5), Token::I32(6), Token::I32(7), @@ -153,7 +156,10 @@ fn test_de_named_tuple() { assert_de_tokens( &DeNamedTuple(5, 6, 7), &[ - Token::TupleStruct { name: "DeNamedTuple", len: 3 }, + Token::TupleStruct { + name: "DeNamedTuple", + len: 3, + }, Token::I32(5), Token::I32(6), Token::I32(7), @@ -170,22 +176,21 @@ fn test_ser_named_map() { assert_ser_tokens( &SerNamedMap { - a: &a, - b: &mut b, - c: c, - }, + a: &a, + b: &mut b, + c: c, + }, &[ - Token::Struct { name: "SerNamedMap", len: 3 }, - + Token::Struct { + name: "SerNamedMap", + len: 3, + }, Token::Str("a"), Token::I32(5), - Token::Str("b"), Token::I32(6), - Token::Str("c"), Token::I32(7), - Token::StructEnd, ], ); @@ -196,17 +201,16 @@ fn test_de_named_map() { assert_de_tokens( &DeNamedMap { a: 5, b: 6, c: 7 }, &[ - Token::Struct { name: "DeNamedMap", len: 3 }, - + Token::Struct { + name: "DeNamedMap", + len: 3, + }, Token::Str("a"), Token::I32(5), - Token::Str("b"), Token::I32(6), - Token::Str("c"), Token::I32(7), - Token::StructEnd, ], ); @@ -216,7 +220,12 @@ fn test_de_named_map() { fn test_ser_enum_unit() { assert_ser_tokens( &SerEnum::Unit::, - &[Token::UnitVariant { name: "SerEnum", variant: "Unit" }], + &[ + Token::UnitVariant { + name: "SerEnum", + variant: "Unit", + }, + ], ); } @@ -230,7 +239,11 @@ fn test_ser_enum_seq() { assert_ser_tokens( &SerEnum::Seq(a, b, &c, &mut d), &[ - Token::TupleVariant { name: "SerEnum", variant: "Seq", len: 4 }, + Token::TupleVariant { + name: "SerEnum", + variant: "Seq", + len: 4, + }, Token::I8(1), Token::I32(2), Token::I32(3), @@ -249,26 +262,25 @@ fn test_ser_enum_map() { assert_ser_tokens( &SerEnum::Map { - a: a, - b: b, - c: &c, - d: &mut d, - }, + a: a, + b: b, + c: &c, + d: &mut d, + }, &[ - Token::StructVariant { name: "SerEnum", variant: "Map", len: 4 }, - + Token::StructVariant { + name: "SerEnum", + variant: "Map", + len: 4, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::I32(2), - Token::Str("c"), Token::I32(3), - Token::Str("d"), Token::I32(4), - Token::StructVariantEnd, ], ); @@ -278,7 +290,12 @@ fn test_ser_enum_map() { fn test_de_enum_unit() { assert_tokens( &DeEnum::Unit::, - &[Token::UnitVariant { name: "DeEnum", variant: "Unit" }], + &[ + Token::UnitVariant { + name: "DeEnum", + variant: "Unit", + }, + ], ); } @@ -292,7 +309,11 @@ fn test_de_enum_seq() { assert_tokens( &DeEnum::Seq(a, b, c, d), &[ - Token::TupleVariant { name: "DeEnum", variant: "Seq", len: 4 }, + Token::TupleVariant { + name: "DeEnum", + variant: "Seq", + len: 4, + }, Token::I8(1), Token::I32(2), Token::I32(3), @@ -311,26 +332,25 @@ fn test_de_enum_map() { assert_tokens( &DeEnum::Map { - a: a, - b: b, - c: c, - d: d, - }, + a: a, + b: b, + c: c, + d: d, + }, &[ - Token::StructVariant { name: "DeEnum", variant: "Map", len: 4 }, - + Token::StructVariant { + name: "DeEnum", + variant: "Map", + len: 4, + }, Token::Str("a"), Token::I8(1), - Token::Str("b"), Token::I32(2), - Token::Str("c"), Token::I32(3), - Token::Str("d"), Token::I32(4), - Token::StructVariantEnd, ], ); @@ -343,7 +363,10 @@ fn test_lifetimes() { assert_ser_tokens( &Lifetimes::LifetimeSeq(&value), &[ - Token::NewtypeVariant { name: "Lifetimes", variant: "LifetimeSeq" }, + Token::NewtypeVariant { + name: "Lifetimes", + variant: "LifetimeSeq", + }, Token::I32(5), ], ); @@ -351,7 +374,10 @@ fn test_lifetimes() { assert_ser_tokens( &Lifetimes::NoLifetimeSeq(5), &[ - Token::NewtypeVariant { name: "Lifetimes", variant: "NoLifetimeSeq" }, + Token::NewtypeVariant { + name: "Lifetimes", + variant: "NoLifetimeSeq", + }, Token::I32(5), ], ); @@ -359,11 +385,13 @@ fn test_lifetimes() { assert_ser_tokens( &Lifetimes::LifetimeMap { a: &value }, &[ - Token::StructVariant { name: "Lifetimes", variant: "LifetimeMap", len: 1 }, - + Token::StructVariant { + name: "Lifetimes", + variant: "LifetimeMap", + len: 1, + }, Token::Str("a"), Token::I32(5), - Token::StructVariantEnd, ], ); @@ -371,11 +399,13 @@ fn test_lifetimes() { assert_ser_tokens( &Lifetimes::NoLifetimeMap { a: 5 }, &[ - Token::StructVariant { name: "Lifetimes", variant: "NoLifetimeMap", len: 1 }, - + Token::StructVariant { + name: "Lifetimes", + variant: "NoLifetimeMap", + len: 1, + }, Token::Str("a"), Token::I32(5), - Token::StructVariantEnd, ], ); @@ -386,11 +416,12 @@ fn test_generic_struct() { assert_tokens( &GenericStruct { x: 5u32 }, &[ - Token::Struct { name: "GenericStruct", len: 1 }, - + Token::Struct { + name: "GenericStruct", + len: 1, + }, Token::Str("x"), Token::U32(5), - Token::StructEnd, ], ); @@ -400,7 +431,12 @@ fn test_generic_struct() { fn test_generic_newtype_struct() { assert_tokens( &GenericNewTypeStruct(5u32), - &[Token::NewtypeStruct { name: "GenericNewTypeStruct" }, Token::U32(5)], + &[ + Token::NewtypeStruct { + name: "GenericNewTypeStruct", + }, + Token::U32(5), + ], ); } @@ -409,7 +445,10 @@ fn test_generic_tuple_struct() { assert_tokens( &GenericTupleStruct(5u32, 6u32), &[ - Token::TupleStruct { name: "GenericTupleStruct", len: 2 }, + Token::TupleStruct { + name: "GenericTupleStruct", + len: 2, + }, Token::U32(5), Token::U32(6), Token::TupleStructEnd, @@ -421,7 +460,12 @@ fn test_generic_tuple_struct() { fn test_generic_enum_unit() { assert_tokens( &GenericEnum::Unit::, - &[Token::UnitVariant { name: "GenericEnum", variant: "Unit" }], + &[ + Token::UnitVariant { + name: "GenericEnum", + variant: "Unit", + }, + ], ); } @@ -430,7 +474,10 @@ fn test_generic_enum_newtype() { assert_tokens( &GenericEnum::NewType::(5), &[ - Token::NewtypeVariant { name: "GenericEnum", variant: "NewType" }, + Token::NewtypeVariant { + name: "GenericEnum", + variant: "NewType", + }, Token::U32(5), ], ); @@ -441,7 +488,11 @@ fn test_generic_enum_seq() { assert_tokens( &GenericEnum::Seq::(5, 6), &[ - Token::TupleVariant { name: "GenericEnum", variant: "Seq", len: 2 }, + Token::TupleVariant { + name: "GenericEnum", + variant: "Seq", + len: 2, + }, Token::U32(5), Token::U32(6), Token::TupleVariantEnd, @@ -454,14 +505,15 @@ fn test_generic_enum_map() { assert_tokens( &GenericEnum::Map:: { x: 5, y: 6 }, &[ - Token::StructVariant { name: "GenericEnum", variant: "Map", len: 2 }, - + Token::StructVariant { + name: "GenericEnum", + variant: "Map", + len: 2, + }, Token::Str("x"), Token::U32(5), - Token::Str("y"), Token::U32(6), - Token::StructVariantEnd, ], ); @@ -470,13 +522,18 @@ fn test_generic_enum_map() { #[test] fn test_default_ty_param() { assert_tokens( - &DefaultTyParam:: { phantom: PhantomData }, + &DefaultTyParam:: { + phantom: PhantomData, + }, &[ - Token::Struct { name: "DefaultTyParam", len: 1 }, - + Token::Struct { + name: "DefaultTyParam", + len: 1, + }, Token::Str("phantom"), - Token::UnitStruct { name: "PhantomData" }, - + Token::UnitStruct { + name: "PhantomData", + }, Token::StructEnd, ], ); @@ -491,18 +548,19 @@ fn test_enum_state_field() { assert_tokens( &SomeEnum::Key { - key: 'a', - state: true, - }, + key: 'a', + state: true, + }, &[ - Token::StructVariant { name: "SomeEnum", variant: "Key", len: 2 }, - + Token::StructVariant { + name: "SomeEnum", + variant: "Key", + len: 2, + }, Token::Str("key"), Token::Char('a'), - Token::Str("state"), Token::Bool(true), - Token::StructVariantEnd, ], ); @@ -524,11 +582,12 @@ fn test_untagged_enum() { assert_tokens( &Untagged::A { a: 1 }, &[ - Token::Struct { name: "Untagged", len: 1 }, - + Token::Struct { + name: "Untagged", + len: 1, + }, Token::Str("a"), Token::U8(1), - Token::StructEnd, ], ); @@ -536,11 +595,12 @@ fn test_untagged_enum() { assert_tokens( &Untagged::B { b: 2 }, &[ - Token::Struct { name: "Untagged", len: 1 }, - + Token::Struct { + name: "Untagged", + len: 1, + }, Token::Str("b"), Token::U8(2), - Token::StructEnd, ], ); @@ -552,7 +612,12 @@ fn test_untagged_enum() { assert_tokens( &Untagged::F(1, 2), - &[Token::Tuple { len: 2 }, Token::U8(1), Token::U8(2), Token::TupleEnd], + &[ + Token::Tuple { len: 2 }, + Token::U8(1), + Token::U8(2), + Token::TupleEnd, + ], ); assert_de_tokens_error::( @@ -600,14 +665,14 @@ fn test_internally_tagged_enum() { assert_tokens( &InternallyTagged::A { a: 1 }, &[ - Token::Struct { name: "InternallyTagged", len: 2 }, - + Token::Struct { + name: "InternallyTagged", + len: 2, + }, Token::Str("type"), Token::Str("A"), - Token::Str("a"), Token::U8(1), - Token::StructEnd, ], ); @@ -625,32 +690,27 @@ fn test_internally_tagged_enum() { assert_tokens( &InternallyTagged::B, &[ - Token::Struct { name: "InternallyTagged", len: 1 }, - + Token::Struct { + name: "InternallyTagged", + len: 1, + }, Token::Str("type"), Token::Str("B"), - Token::StructEnd, ], ); assert_de_tokens( &InternallyTagged::B, - &[ - Token::Seq { len: Some(1) }, - Token::Str("B"), - Token::SeqEnd, - ], + &[Token::Seq { len: Some(1) }, Token::Str("B"), Token::SeqEnd], ); assert_tokens( &InternallyTagged::C(BTreeMap::new()), &[ Token::Map { len: Some(1) }, - Token::Str("type"), Token::Str("C"), - Token::MapEnd, ], ); @@ -670,10 +730,8 @@ fn test_internally_tagged_enum() { &InternallyTagged::D(Newtype(BTreeMap::new())), &[ Token::Map { len: Some(1) }, - Token::Str("type"), Token::Str("D"), - Token::MapEnd, ], ); @@ -681,14 +739,14 @@ fn test_internally_tagged_enum() { assert_tokens( &InternallyTagged::E(Struct { f: 6 }), &[ - Token::Struct { name: "Struct", len: 2 }, - + Token::Struct { + name: "Struct", + len: 2, + }, Token::Str("type"), Token::Str("E"), - Token::Str("f"), Token::U8(6), - Token::StructEnd, ], ); @@ -711,10 +769,8 @@ fn test_internally_tagged_enum() { assert_de_tokens_error::( &[ Token::Map { len: Some(1) }, - Token::Str("type"), Token::Str("Z"), - Token::MapEnd, ], "unknown variant `Z`, expected one of `A`, `B`, `C`, `D`, `E`", @@ -737,14 +793,14 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() { assert_de_tokens( &Message::Log { level: Level::Info }, &[ - Token::Struct { name: "Message", len: 2 }, - + Token::Struct { + name: "Message", + len: 2, + }, Token::Str("action"), Token::Str("Log"), - Token::Str("level"), Token::BorrowedStr("Info"), - Token::StructEnd, ], ); @@ -761,14 +817,14 @@ fn test_internally_tagged_borrow() { assert_tokens( &Input::Package { name: "borrowed" }, &[ - Token::Struct { name: "Input", len: 2 }, - + Token::Struct { + name: "Input", + len: 2, + }, Token::BorrowedStr("type"), Token::BorrowedStr("Package"), - Token::BorrowedStr("name"), Token::BorrowedStr("borrowed"), - Token::StructEnd, ], ); @@ -789,11 +845,12 @@ fn test_adjacently_tagged_enum() { assert_ser_tokens( &AdjacentlyTagged::Unit::, &[ - Token::Struct { name: "AdjacentlyTagged", len: 1 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 1, + }, Token::Str("t"), Token::Str("Unit"), - Token::StructEnd, ], ); @@ -802,11 +859,12 @@ fn test_adjacently_tagged_enum() { assert_de_tokens( &AdjacentlyTagged::Unit::, &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("t"), Token::Str("Unit"), - Token::StructEnd, ], ); @@ -815,14 +873,14 @@ fn test_adjacently_tagged_enum() { assert_de_tokens( &AdjacentlyTagged::Unit::, &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("t"), Token::Str("Unit"), - Token::Str("c"), Token::Unit, - Token::StructEnd, ], ); @@ -831,14 +889,14 @@ fn test_adjacently_tagged_enum() { assert_de_tokens( &AdjacentlyTagged::Unit::, &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("c"), Token::Unit, - Token::Str("t"), Token::Str("Unit"), - Token::StructEnd, ], ); @@ -847,23 +905,20 @@ fn test_adjacently_tagged_enum() { assert_de_tokens( &AdjacentlyTagged::Unit::, &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("f"), Token::Unit, - Token::Str("t"), Token::Str("Unit"), - Token::Str("g"), Token::Unit, - Token::Str("c"), Token::Unit, - Token::Str("h"), Token::Unit, - Token::StructEnd, ], ); @@ -872,14 +927,14 @@ fn test_adjacently_tagged_enum() { assert_tokens( &AdjacentlyTagged::Newtype::(1), &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("t"), Token::Str("Newtype"), - Token::Str("c"), Token::U8(1), - Token::StructEnd, ], ); @@ -888,14 +943,14 @@ fn test_adjacently_tagged_enum() { assert_de_tokens( &AdjacentlyTagged::Newtype::(1), &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("c"), Token::U8(1), - Token::Str("t"), Token::Str("Newtype"), - Token::StructEnd, ], ); @@ -904,17 +959,17 @@ fn test_adjacently_tagged_enum() { assert_tokens( &AdjacentlyTagged::Tuple::(1, 1), &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("t"), Token::Str("Tuple"), - Token::Str("c"), Token::Tuple { len: 2 }, Token::U8(1), Token::U8(1), Token::TupleEnd, - Token::StructEnd, ], ); @@ -923,17 +978,17 @@ fn test_adjacently_tagged_enum() { assert_de_tokens( &AdjacentlyTagged::Tuple::(1, 1), &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("c"), Token::Tuple { len: 2 }, Token::U8(1), Token::U8(1), Token::TupleEnd, - Token::Str("t"), Token::Str("Tuple"), - Token::StructEnd, ], ); @@ -942,17 +997,20 @@ fn test_adjacently_tagged_enum() { assert_tokens( &AdjacentlyTagged::Struct:: { f: 1 }, &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("t"), Token::Str("Struct"), - Token::Str("c"), - Token::Struct { name: "Struct", len: 1 }, + Token::Struct { + name: "Struct", + len: 1, + }, Token::Str("f"), Token::U8(1), Token::StructEnd, - Token::StructEnd, ], ); @@ -961,17 +1019,20 @@ fn test_adjacently_tagged_enum() { assert_de_tokens( &AdjacentlyTagged::Struct:: { f: 1 }, &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("c"), - Token::Struct { name: "Struct", len: 1 }, + Token::Struct { + name: "Struct", + len: 1, + }, Token::Str("f"), Token::U8(1), Token::StructEnd, - Token::Str("t"), Token::Str("Struct"), - Token::StructEnd, ], ); @@ -988,52 +1049,55 @@ fn test_adjacently_tagged_enum_deny_unknown_fields() { assert_de_tokens( &AdjacentlyTagged::Unit, &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("t"), Token::Str("Unit"), - Token::Str("c"), Token::Unit, - Token::StructEnd, ], ); assert_de_tokens_error::( &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("t"), Token::Str("Unit"), - Token::Str("c"), Token::Unit, - Token::Str("h"), ], - r#"invalid value: string "h", expected "t" or "c""# + r#"invalid value: string "h", expected "t" or "c""#, ); assert_de_tokens_error::( &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("h"), ], - r#"invalid value: string "h", expected "t" or "c""# + r#"invalid value: string "h", expected "t" or "c""#, ); assert_de_tokens_error::( &[ - Token::Struct { name: "AdjacentlyTagged", len: 2 }, - + Token::Struct { + name: "AdjacentlyTagged", + len: 2, + }, Token::Str("c"), Token::Unit, - Token::Str("h"), ], - r#"invalid value: string "h", expected "t" or "c""# + r#"invalid value: string "h", expected "t" or "c""#, ); } @@ -1057,13 +1121,10 @@ fn test_enum_in_internally_tagged_enum() { &Outer::Inner(Inner::Unit), &[ Token::Map { len: Some(2) }, - Token::Str("type"), Token::Str("Inner"), - Token::Str("Unit"), Token::Unit, - Token::MapEnd, ], ); @@ -1072,13 +1133,10 @@ fn test_enum_in_internally_tagged_enum() { &Outer::Inner(Inner::Newtype(1)), &[ Token::Map { len: Some(2) }, - Token::Str("type"), Token::Str("Inner"), - Token::Str("Newtype"), Token::U8(1), - Token::MapEnd, ], ); @@ -1087,16 +1145,16 @@ fn test_enum_in_internally_tagged_enum() { &Outer::Inner(Inner::Tuple(1, 1)), &[ Token::Map { len: Some(2) }, - Token::Str("type"), Token::Str("Inner"), - Token::Str("Tuple"), - Token::TupleStruct { name: "Tuple", len: 2 }, + Token::TupleStruct { + name: "Tuple", + len: 2, + }, Token::U8(1), Token::U8(1), Token::TupleStructEnd, - Token::MapEnd, ], ); @@ -1105,16 +1163,16 @@ fn test_enum_in_internally_tagged_enum() { &Outer::Inner(Inner::Struct { f: 1 }), &[ Token::Map { len: Some(2) }, - Token::Str("type"), Token::Str("Inner"), - Token::Str("Struct"), - Token::Struct { name: "Struct", len: 1 }, + Token::Struct { + name: "Struct", + len: 1, + }, Token::Str("f"), Token::U8(1), Token::StructEnd, - Token::MapEnd, ], ); @@ -1138,18 +1196,33 @@ fn test_enum_in_untagged_enum() { assert_tokens( &Outer::Inner(Inner::Unit), - &[Token::UnitVariant { name: "Inner", variant: "Unit" }], + &[ + Token::UnitVariant { + name: "Inner", + variant: "Unit", + }, + ], ); assert_tokens( &Outer::Inner(Inner::Newtype(1)), - &[Token::NewtypeVariant { name: "Inner", variant: "Newtype" }, Token::U8(1)], + &[ + Token::NewtypeVariant { + name: "Inner", + variant: "Newtype", + }, + Token::U8(1), + ], ); assert_tokens( &Outer::Inner(Inner::Tuple(1, 1)), &[ - Token::TupleVariant { name: "Inner", variant: "Tuple", len: 2 }, + Token::TupleVariant { + name: "Inner", + variant: "Tuple", + len: 2, + }, Token::U8(1), Token::U8(1), Token::TupleVariantEnd, @@ -1159,11 +1232,13 @@ fn test_enum_in_untagged_enum() { assert_tokens( &Outer::Inner(Inner::Struct { f: 1 }), &[ - Token::StructVariant { name: "Inner", variant: "Struct", len: 1 }, - + Token::StructVariant { + name: "Inner", + variant: "Struct", + len: 1, + }, Token::Str("f"), Token::U8(1), - Token::StructVariantEnd, ], ); @@ -1188,7 +1263,7 @@ fn test_rename_all() { SerializeMap { serialize: bool, serialize_seq: bool, - } + }, } #[derive(Serialize, Deserialize, Debug, PartialEq)] @@ -1207,11 +1282,15 @@ fn test_rename_all() { assert_tokens( &E::Serialize { - serialize: true, - serialize_seq: true, - }, + serialize: true, + serialize_seq: true, + }, &[ - Token::StructVariant { name: "E", variant: "serialize", len: 2 }, + Token::StructVariant { + name: "E", + variant: "serialize", + len: 2, + }, Token::Str("serialize"), Token::Bool(true), Token::Str("serializeSeq"), @@ -1222,11 +1301,15 @@ fn test_rename_all() { assert_tokens( &E::SerializeSeq { - serialize: true, - serialize_seq: true, - }, + serialize: true, + serialize_seq: true, + }, &[ - Token::StructVariant { name: "E", variant: "serialize_seq", len: 2 }, + Token::StructVariant { + name: "E", + variant: "serialize_seq", + len: 2, + }, Token::Str("serialize"), Token::Bool(true), Token::Str("serialize-seq"), @@ -1237,11 +1320,15 @@ fn test_rename_all() { assert_tokens( &E::SerializeMap { - serialize: true, - serialize_seq: true, - }, + serialize: true, + serialize_seq: true, + }, &[ - Token::StructVariant { name: "E", variant: "serialize_map", len: 2 }, + Token::StructVariant { + name: "E", + variant: "serialize_map", + len: 2, + }, Token::Str("SERIALIZE"), Token::Bool(true), Token::Str("SERIALIZE_SEQ"), @@ -1252,9 +1339,9 @@ fn test_rename_all() { assert_tokens( &S { - serialize: true, - serialize_seq: true, - }, + serialize: true, + serialize_seq: true, + }, &[ Token::Struct { name: "S", len: 2 }, Token::Str("Serialize"), @@ -1267,17 +1354,20 @@ fn test_rename_all() { assert_tokens( &ScreamingKebab { - serialize: true, - serialize_seq: true, - }, + serialize: true, + serialize_seq: true, + }, &[ - Token::Struct { name: "ScreamingKebab", len: 2 }, + Token::Struct { + name: "ScreamingKebab", + len: 2, + }, Token::Str("SERIALIZE"), Token::Bool(true), Token::Str("SERIALIZE-SEQ"), Token::Bool(true), Token::StructEnd, - ] + ], ); } @@ -1295,10 +1385,7 @@ fn test_untagged_newtype_variant_containing_unit_struct_not_map() { assert_tokens( &Message::Map(BTreeMap::new()), - &[ - Token::Map { len: Some(0) }, - Token::MapEnd, - ], + &[Token::Map { len: Some(0) }, Token::MapEnd], ); } @@ -1317,10 +1404,8 @@ fn test_internally_tagged_newtype_variant_containing_unit_struct() { &Message::Info(Info), &[ Token::Map { len: Some(1) }, - Token::Str("topic"), Token::Str("Info"), - Token::MapEnd, ], ); diff --git a/test_suite/tests/test_remote.rs b/test_suite/tests/test_remote.rs index c0b2700e..baf4fb76 100644 --- a/test_suite/tests/test_remote.rs +++ b/test_suite/tests/test_remote.rs @@ -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")]