From c5854f19f70b6534bcadb17f104f727f48fc7361 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 13 Apr 2017 12:47:46 -0700 Subject: [PATCH] Prefer where clauses --- serde/src/de/impls.rs | 30 +++++++++--- serde/src/de/mod.rs | 4 +- serde/src/de/value.rs | 10 +++- serde/src/private/ser.rs | 94 +++++++++++++++++++++++++------------ serde/src/ser/impls.rs | 5 +- serde/src/ser/impossible.rs | 48 ++++++++++++------- serde/src/ser/mod.rs | 79 ++++++++++++++++++++++--------- 7 files changed, 193 insertions(+), 77 deletions(-) diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs index da4a505a..fdba4b58 100644 --- a/serde/src/de/impls.rs +++ b/serde/src/de/impls.rs @@ -1104,7 +1104,10 @@ impl<'de> Deserialize<'de> for OsString { /////////////////////////////////////////////////////////////////////////////// #[cfg(any(feature = "std", feature = "alloc"))] -impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box { +impl<'de, T> Deserialize<'de> for Box +where + T: Deserialize<'de>, +{ fn deserialize(deserializer: D) -> Result, D::Error> where D: Deserializer<'de>, @@ -1115,7 +1118,10 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box { } #[cfg(any(feature = "std", feature = "collections"))] -impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<[T]> { +impl<'de, T> Deserialize<'de> for Box<[T]> +where + T: Deserialize<'de>, +{ fn deserialize(deserializer: D) -> Result, D::Error> where D: Deserializer<'de>, @@ -1137,7 +1143,10 @@ impl<'de> Deserialize<'de> for Box { } #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] -impl<'de, T: Deserialize<'de>> Deserialize<'de> for Arc { +impl<'de, T> Deserialize<'de> for Arc +where + T: Deserialize<'de>, +{ fn deserialize(deserializer: D) -> Result, D::Error> where D: Deserializer<'de>, @@ -1148,7 +1157,10 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Arc { } #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] -impl<'de, T: Deserialize<'de>> Deserialize<'de> for Rc { +impl<'de, T> Deserialize<'de> for Rc +where + T: Deserialize<'de>, +{ fn deserialize(deserializer: D) -> Result, D::Error> where D: Deserializer<'de>, @@ -1317,7 +1329,10 @@ impl<'de> Deserialize<'de> for Duration { // end: u32, // } #[cfg(feature = "std")] -impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range { +impl<'de, Idx> Deserialize<'de> for ops::Range +where + Idx: Deserialize<'de>, +{ fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, @@ -1375,7 +1390,10 @@ impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range { phantom: PhantomData, } - impl<'de, Idx: Deserialize<'de>> Visitor<'de> for RangeVisitor { + impl<'de, Idx> Visitor<'de> for RangeVisitor + where + Idx: Deserialize<'de>, + { type Value = ops::Range; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index 2da3d2d6..68de8c04 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -153,7 +153,9 @@ macro_rules! declare_error_trait { /// } /// } /// ``` - fn custom(msg: T) -> Self; + fn custom(msg: T) -> Self + where + T: Display; /// Raised when a `Deserialize` receives a type different from what it was /// expecting. diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index 1bdbefb9..73d65be4 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -19,12 +19,18 @@ type ErrorImpl = (); impl de::Error for Error { #[cfg(any(feature = "std", feature = "collections"))] - fn custom(msg: T) -> Self { + fn custom(msg: T) -> Self + where + T: Display, + { Error { err: msg.to_string().into_boxed_str() } } #[cfg(not(any(feature = "std", feature = "collections")))] - fn custom(_msg: T) -> Self { + fn custom(_msg: T) -> Self + where + T: Display, + { Error { err: () } } } diff --git a/serde/src/private/ser.rs b/serde/src/private/ser.rs index c4311562..ccf77723 100644 --- a/serde/src/private/ser.rs +++ b/serde/src/private/ser.rs @@ -338,7 +338,10 @@ where pub struct Error; impl ser::Error for Error { - fn custom(_: T) -> Self { + fn custom(_: T) -> Self + where + T: Display, + { unimplemented!() } } @@ -385,7 +388,10 @@ mod content { type Ok = M::Ok; type Error = M::Error; - fn serialize_field(&mut self, value: &T) -> Result<(), M::Error> { + fn serialize_field(&mut self, value: &T) -> Result<(), M::Error> + where + T: Serialize, + { let value = try!(value.serialize(ContentSerializer::::new())); self.fields.push(value); Ok(()) @@ -420,11 +426,14 @@ mod content { type Ok = M::Ok; type Error = M::Error; - fn serialize_field( + fn serialize_field( &mut self, key: &'static str, value: &T, - ) -> Result<(), M::Error> { + ) -> Result<(), M::Error> + where + T: Serialize, + { let value = try!(value.serialize(ContentSerializer::::new())); self.fields.push((key, value)); Ok(()) @@ -651,7 +660,10 @@ mod content { Ok(Content::None) } - fn serialize_some(self, value: &T) -> Result { + fn serialize_some(self, value: &T) -> Result + where + T: Serialize, + { Ok(Content::Some(Box::new(try!(value.serialize(self))))) } @@ -672,21 +684,27 @@ mod content { Ok(Content::UnitVariant(name, variant_index, variant)) } - fn serialize_newtype_struct( + fn serialize_newtype_struct( self, name: &'static str, value: &T, - ) -> Result { + ) -> Result + where + T: Serialize, + { Ok(Content::NewtypeStruct(name, Box::new(try!(value.serialize(self)))),) } - fn serialize_newtype_variant( + fn serialize_newtype_variant( self, name: &'static str, variant_index: u32, variant: &'static str, value: &T, - ) -> Result { + ) -> Result + where + T: Serialize, + { Ok( Content::NewtypeVariant( name, @@ -814,7 +832,10 @@ mod content { type Ok = Content; type Error = E; - fn serialize_element(&mut self, value: &T) -> Result<(), E> { + fn serialize_element(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { let value = try!(value.serialize(ContentSerializer::::new())); self.elements.push(value); Ok(()) @@ -843,7 +864,10 @@ mod content { type Ok = Content; type Error = E; - fn serialize_element(&mut self, value: &T) -> Result<(), E> { + fn serialize_element(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { let value = try!(value.serialize(ContentSerializer::::new())); self.elements.push(value); Ok(()) @@ -867,7 +891,10 @@ mod content { type Ok = Content; type Error = E; - fn serialize_field(&mut self, value: &T) -> Result<(), E> { + fn serialize_field(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { let value = try!(value.serialize(ContentSerializer::::new())); self.fields.push(value); Ok(()) @@ -893,7 +920,10 @@ mod content { type Ok = Content; type Error = E; - fn serialize_field(&mut self, value: &T) -> Result<(), E> { + fn serialize_field(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { let value = try!(value.serialize(ContentSerializer::::new())); self.fields.push(value); Ok(()) @@ -917,13 +947,19 @@ mod content { type Ok = Content; type Error = E; - fn serialize_key(&mut self, key: &T) -> Result<(), E> { + fn serialize_key(&mut self, key: &T) -> Result<(), E> + where + T: Serialize, + { let key = try!(key.serialize(ContentSerializer::::new())); self.key = Some(key); Ok(()) } - fn serialize_value(&mut self, value: &T) -> Result<(), E> { + fn serialize_value(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { let key = self.key .take() .expect("serialize_value called before serialize_key"); @@ -936,11 +972,11 @@ mod content { Ok(Content::Map(self.entries)) } - fn serialize_entry( - &mut self, - key: &K, - value: &V, - ) -> Result<(), E> { + fn serialize_entry(&mut self, key: &K, value: &V) -> Result<(), E> + where + K: Serialize, + V: Serialize, + { let key = try!(key.serialize(ContentSerializer::::new())); let value = try!(value.serialize(ContentSerializer::::new())); self.entries.push((key, value)); @@ -961,11 +997,10 @@ mod content { type Ok = Content; type Error = E; - fn serialize_field( - &mut self, - key: &'static str, - value: &T, - ) -> Result<(), E> { + fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), E> + where + T: Serialize, + { let value = try!(value.serialize(ContentSerializer::::new())); self.fields.push((key, value)); Ok(()) @@ -991,11 +1026,10 @@ mod content { type Ok = Content; type Error = E; - fn serialize_field( - &mut self, - key: &'static str, - value: &T, - ) -> Result<(), E> { + fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), E> + where + T: Serialize, + { let value = try!(value.serialize(ContentSerializer::::new())); self.fields.push((key, value)); Ok(()) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 16379e63..9d383976 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -247,7 +247,10 @@ where /////////////////////////////////////////////////////////////////////////////// #[cfg(feature = "std")] -impl Serialize for ops::Range { +impl Serialize for ops::Range +where + Idx: Serialize, +{ fn serialize(&self, serializer: S) -> Result where S: Serializer, diff --git a/serde/src/ser/impossible.rs b/serde/src/ser/impossible.rs index 84fe1d51..36fa421f 100644 --- a/serde/src/ser/impossible.rs +++ b/serde/src/ser/impossible.rs @@ -76,7 +76,10 @@ where type Ok = Ok; type Error = Error; - fn serialize_element(&mut self, value: &T) -> Result<(), Error> { + fn serialize_element(&mut self, value: &T) -> Result<(), Error> + where + T: Serialize, + { let _ = value; match self.void {} } @@ -93,7 +96,10 @@ where type Ok = Ok; type Error = Error; - fn serialize_element(&mut self, value: &T) -> Result<(), Error> { + fn serialize_element(&mut self, value: &T) -> Result<(), Error> + where + T: Serialize, + { let _ = value; match self.void {} } @@ -110,7 +116,10 @@ where type Ok = Ok; type Error = Error; - fn serialize_field(&mut self, value: &T) -> Result<(), Error> { + fn serialize_field(&mut self, value: &T) -> Result<(), Error> + where + T: Serialize, + { let _ = value; match self.void {} } @@ -127,7 +136,10 @@ where type Ok = Ok; type Error = Error; - fn serialize_field(&mut self, value: &T) -> Result<(), Error> { + fn serialize_field(&mut self, value: &T) -> Result<(), Error> + where + T: Serialize, + { let _ = value; match self.void {} } @@ -144,12 +156,18 @@ where type Ok = Ok; type Error = Error; - fn serialize_key(&mut self, key: &T) -> Result<(), Error> { + fn serialize_key(&mut self, key: &T) -> Result<(), Error> + where + T: Serialize, + { let _ = key; match self.void {} } - fn serialize_value(&mut self, value: &T) -> Result<(), Error> { + fn serialize_value(&mut self, value: &T) -> Result<(), Error> + where + T: Serialize, + { let _ = value; match self.void {} } @@ -166,11 +184,10 @@ where type Ok = Ok; type Error = Error; - fn serialize_field( - &mut self, - key: &'static str, - value: &T, - ) -> Result<(), Error> { + fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Error> + where + T: Serialize, + { let _ = key; let _ = value; match self.void {} @@ -188,11 +205,10 @@ where type Ok = Ok; type Error = Error; - fn serialize_field( - &mut self, - key: &'static str, - value: &T, - ) -> Result<(), Error> { + fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Error> + where + T: Serialize, + { let _ = key; let _ = value; match self.void {} diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 14262c29..cdc689c9 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -138,7 +138,9 @@ macro_rules! declare_error_trait { /// } /// } /// ``` - fn custom(msg: T) -> Self; + fn custom(msg: T) -> Self + where + T: Display; } } } @@ -404,7 +406,9 @@ pub trait Serializer: Sized { fn serialize_none(self) -> Result; /// Serialize a `Some(T)` value. - fn serialize_some(self, value: &T) -> Result; + fn serialize_some(self, value: &T) -> Result + where + T: Serialize; /// Serialize a `()` value. fn serialize_unit(self) -> Result; @@ -465,11 +469,13 @@ pub trait Serializer: Sized { /// } /// } /// ``` - fn serialize_newtype_struct( + fn serialize_newtype_struct( self, name: &'static str, value: &T, - ) -> Result; + ) -> Result + where + T: Serialize; /// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`. /// @@ -496,13 +502,15 @@ pub trait Serializer: Sized { /// } /// } /// ``` - fn serialize_newtype_variant( + fn serialize_newtype_variant( self, name: &'static str, variant_index: u32, variant: &'static str, value: &T, - ) -> Result; + ) -> Result + where + T: Serialize; /// Begin to serialize a dynamically sized sequence. This call must be /// followed by zero or more calls to `serialize_element`, then a call to @@ -990,7 +998,9 @@ pub trait SerializeSeq { type Error: Error; /// Serialize a sequence element. - fn serialize_element(&mut self, value: &T) -> Result<(), Self::Error>; + fn serialize_element(&mut self, value: &T) -> Result<(), Self::Error> + where + T: Serialize; /// Finish serializing a sequence. fn end(self) -> Result; @@ -1034,7 +1044,9 @@ pub trait SerializeTuple { type Error: Error; /// Serialize a tuple element. - fn serialize_element(&mut self, value: &T) -> Result<(), Self::Error>; + fn serialize_element(&mut self, value: &T) -> Result<(), Self::Error> + where + T: Serialize; /// Finish serializing a tuple. fn end(self) -> Result; @@ -1068,7 +1080,9 @@ pub trait SerializeTupleStruct { type Error: Error; /// Serialize a tuple struct field. - fn serialize_field(&mut self, value: &T) -> Result<(), Self::Error>; + fn serialize_field(&mut self, value: &T) -> Result<(), Self::Error> + where + T: Serialize; /// Finish serializing a tuple struct. fn end(self) -> Result; @@ -1115,7 +1129,9 @@ pub trait SerializeTupleVariant { type Error: Error; /// Serialize a tuple variant field. - fn serialize_field(&mut self, value: &T) -> Result<(), Self::Error>; + fn serialize_field(&mut self, value: &T) -> Result<(), Self::Error> + where + T: Serialize; /// Finish serializing a tuple variant. fn end(self) -> Result; @@ -1169,10 +1185,14 @@ pub trait SerializeMap { type Error: Error; /// Serialize a map key. - fn serialize_key(&mut self, key: &T) -> Result<(), Self::Error>; + fn serialize_key(&mut self, key: &T) -> Result<(), Self::Error> + where + T: Serialize; /// Serialize a map value. - fn serialize_value(&mut self, value: &T) -> Result<(), Self::Error>; + fn serialize_value(&mut self, value: &T) -> Result<(), Self::Error> + where + T: Serialize; /// Serialize a map entry consisting of a key and a value. /// @@ -1187,11 +1207,15 @@ pub trait SerializeMap { /// `serialize_value`. This is appropriate for serializers that do not care /// about performance or are not able to optimize `serialize_entry` any /// better than this. - fn serialize_entry( + fn serialize_entry( &mut self, key: &K, value: &V, - ) -> Result<(), Self::Error> { + ) -> Result<(), Self::Error> + where + K: Serialize, + V: Serialize, + { try!(self.serialize_key(key)); self.serialize_value(value) } @@ -1232,11 +1256,13 @@ pub trait SerializeStruct { type Error: Error; /// Serialize a struct field. - fn serialize_field( + fn serialize_field( &mut self, key: &'static str, value: &T, - ) -> Result<(), Self::Error>; + ) -> Result<(), Self::Error> + where + T: Serialize; /// Finish serializing a struct. fn end(self) -> Result; @@ -1276,11 +1302,13 @@ pub trait SerializeStructVariant { type Error: Error; /// Serialize a struct variant field. - fn serialize_field( + fn serialize_field( &mut self, key: &'static str, value: &T, - ) -> Result<(), Self::Error>; + ) -> Result<(), Self::Error> + where + T: Serialize; /// Finish serializing a struct variant. fn end(self) -> Result; @@ -1290,7 +1318,10 @@ trait LenHint: Iterator { fn len_hint(&self) -> Option; } -impl LenHint for I { +impl LenHint for I +where + I: Iterator, +{ #[cfg(not(feature = "unstable"))] fn len_hint(&self) -> Option { iterator_len_hint(self) @@ -1303,13 +1334,19 @@ impl LenHint for I { } #[cfg(feature = "unstable")] -impl LenHint for I { +impl LenHint for I +where + I: ExactSizeIterator, +{ fn len_hint(&self) -> Option { Some(self.len()) } } -fn iterator_len_hint(iter: &I) -> Option { +fn iterator_len_hint(iter: &I) -> Option +where + I: Iterator, +{ match iter.size_hint() { (lo, Some(hi)) if lo == hi => Some(lo), _ => None,