mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Prefer where clauses

Browse Source
This commit is contained in:
David Tolnay 2017-04-13 12:47:46 -07:00
parent 5bb6de80b2
commit c5854f19f7
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
7 changed files with 193 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
serde/src/de/impls.rs
View File

@ -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<T> {
impl<'de, T> Deserialize<'de> for Box<T>
where
T: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Box<T>, D::Error>
where
D: Deserializer<'de>,
@ -1115,7 +1118,10 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<T> {
}
#[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<D>(deserializer: D) -> Result<Box<[T]>, D::Error>
where
D: Deserializer<'de>,
@ -1137,7 +1143,10 @@ impl<'de> Deserialize<'de> for Box<str> {
}
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Arc<T> {
impl<'de, T> Deserialize<'de> for Arc<T>
where
T: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Arc<T>, D::Error>
where
D: Deserializer<'de>,
@ -1148,7 +1157,10 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Arc<T> {
}
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Rc<T> {
impl<'de, T> Deserialize<'de> for Rc<T>
where
T: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Rc<T>, 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<Idx> {
impl<'de, Idx> Deserialize<'de> for ops::Range<Idx>
where
Idx: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
@ -1375,7 +1390,10 @@ impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range<Idx> {
phantom: PhantomData<Idx>,
}
impl<'de, Idx: Deserialize<'de>> Visitor<'de> for RangeVisitor<Idx> {
impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
where
Idx: Deserialize<'de>,
{
type Value = ops::Range<Idx>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

4
serde/src/de/mod.rs
View File

@ -153,7 +153,9 @@ macro_rules! declare_error_trait {
/// }
/// }
/// ```
fn custom<T: Display>(msg: T) -> Self;
fn custom<T>(msg: T) -> Self
where
T: Display;
/// Raised when a `Deserialize` receives a type different from what it was
/// expecting.

10
serde/src/de/value.rs
View File

@ -19,12 +19,18 @@ type ErrorImpl = ();
impl de::Error for Error {
#[cfg(any(feature = "std", feature = "collections"))]
fn custom<T: Display>(msg: T) -> Self {
fn custom<T>(msg: T) -> Self
where
T: Display,
{
Error { err: msg.to_string().into_boxed_str() }
}
#[cfg(not(any(feature = "std", feature = "collections")))]
fn custom<T: Display>(_msg: T) -> Self {
fn custom<T>(_msg: T) -> Self
where
T: Display,
{
Error { err: () }
}
}

94
serde/src/private/ser.rs
View File

@ -338,7 +338,10 @@ where
pub struct Error;
impl ser::Error for Error {
fn custom<T: Display>(_: T) -> Self {
fn custom<T>(_: T) -> Self
where
T: Display,
{
unimplemented!()
}
}
@ -385,7 +388,10 @@ mod content {
type Ok = M::Ok;
type Error = M::Error;
fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), M::Error> {
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), M::Error>
where
T: Serialize,
{
let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push(value);
Ok(())
@ -420,11 +426,14 @@ mod content {
type Ok = M::Ok;
type Error = M::Error;
fn serialize_field<T: ?Sized + Serialize>(
fn serialize_field<T: ?Sized>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), M::Error> {
) -> Result<(), M::Error>
where
T: Serialize,
{
let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push((key, value));
Ok(())
@ -651,7 +660,10 @@ mod content {
Ok(Content::None)
}
fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Content, E> {
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Content, E>
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<T: ?Sized + Serialize>(
fn serialize_newtype_struct<T: ?Sized>(
self,
name: &'static str,
value: &T,
) -> Result<Content, E> {
) -> Result<Content, E>
where
T: Serialize,
{
Ok(Content::NewtypeStruct(name, Box::new(try!(value.serialize(self)))),)
}
fn serialize_newtype_variant<T: ?Sized + Serialize>(
fn serialize_newtype_variant<T: ?Sized>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
value: &T,
) -> Result<Content, E> {
) -> Result<Content, E>
where
T: Serialize,
{
Ok(
Content::NewtypeVariant(
name,
@ -814,7 +832,10 @@ mod content {
type Ok = Content;
type Error = E;
fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
where
T: Serialize,
{
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.elements.push(value);
Ok(())
@ -843,7 +864,10 @@ mod content {
type Ok = Content;
type Error = E;
fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
where
T: Serialize,
{
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.elements.push(value);
Ok(())
@ -867,7 +891,10 @@ mod content {
type Ok = Content;
type Error = E;
fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
where
T: Serialize,
{
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push(value);
Ok(())
@ -893,7 +920,10 @@ mod content {
type Ok = Content;
type Error = E;
fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
where
T: Serialize,
{
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push(value);
Ok(())
@ -917,13 +947,19 @@ mod content {
type Ok = Content;
type Error = E;
fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), E> {
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), E>
where
T: Serialize,
{
let key = try!(key.serialize(ContentSerializer::<E>::new()));
self.key = Some(key);
Ok(())
}
fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
fn serialize_value<T: ?Sized>(&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<K: ?Sized + Serialize, V: ?Sized + Serialize>(
&mut self,
key: &K,
value: &V,
) -> Result<(), E> {
fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), E>
where
K: Serialize,
V: Serialize,
{
let key = try!(key.serialize(ContentSerializer::<E>::new()));
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.entries.push((key, value));
@ -961,11 +997,10 @@ mod content {
type Ok = Content;
type Error = E;
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), E> {
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
where
T: Serialize,
{
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push((key, value));
Ok(())
@ -991,11 +1026,10 @@ mod content {
type Ok = Content;
type Error = E;
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), E> {
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
where
T: Serialize,
{
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push((key, value));
Ok(())

5
serde/src/ser/impls.rs
View File

@ -247,7 +247,10 @@ where
///////////////////////////////////////////////////////////////////////////////
#[cfg(feature = "std")]
impl<Idx: Serialize> Serialize for ops::Range<Idx> {
impl<Idx> Serialize for ops::Range<Idx>
where
Idx: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,

48
serde/src/ser/impossible.rs
View File

@ -76,7 +76,10 @@ where
type Ok = Ok;
type Error = Error;
fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Error> {
fn serialize_element<T: ?Sized>(&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<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Error> {
fn serialize_element<T: ?Sized>(&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<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Error> {
fn serialize_field<T: ?Sized>(&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<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Error> {
fn serialize_field<T: ?Sized>(&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<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Error> {
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error>
where
T: Serialize,
{
let _ = key;
match self.void {}
}
fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Error> {
fn serialize_value<T: ?Sized>(&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<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Error> {
fn serialize_field<T: ?Sized>(&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<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Error> {
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
where
T: Serialize,
{
let _ = key;
let _ = value;
match self.void {}

79
serde/src/ser/mod.rs
View File

@ -138,7 +138,9 @@ macro_rules! declare_error_trait {
/// }
/// }
/// ```
fn custom<T: Display>(msg: T) -> Self;
fn custom<T>(msg: T) -> Self
where
T: Display;
}
}
}
@ -404,7 +406,9 @@ pub trait Serializer: Sized {
fn serialize_none(self) -> Result<Self::Ok, Self::Error>;
/// Serialize a `Some(T)` value.
fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error>;
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
where
T: Serialize;
/// Serialize a `()` value.
fn serialize_unit(self) -> Result<Self::Ok, Self::Error>;
@ -465,11 +469,13 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_newtype_struct<T: ?Sized + Serialize>(
fn serialize_newtype_struct<T: ?Sized>(
self,
name: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>;
) -> Result<Self::Ok, Self::Error>
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<T: ?Sized + Serialize>(
fn serialize_newtype_variant<T: ?Sized>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>;
) -> Result<Self::Ok, Self::Error>
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<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize;
/// Finish serializing a sequence.
fn end(self) -> Result<Self::Ok, Self::Error>;
@ -1034,7 +1044,9 @@ pub trait SerializeTuple {
type Error: Error;
/// Serialize a tuple element.
fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize;
/// Finish serializing a tuple.
fn end(self) -> Result<Self::Ok, Self::Error>;
@ -1068,7 +1080,9 @@ pub trait SerializeTupleStruct {
type Error: Error;
/// Serialize a tuple struct field.
fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize;
/// Finish serializing a tuple struct.
fn end(self) -> Result<Self::Ok, Self::Error>;
@ -1115,7 +1129,9 @@ pub trait SerializeTupleVariant {
type Error: Error;
/// Serialize a tuple variant field.
fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: Serialize;
/// Finish serializing a tuple variant.
fn end(self) -> Result<Self::Ok, Self::Error>;
@ -1169,10 +1185,14 @@ pub trait SerializeMap {
type Error: Error;
/// Serialize a map key.
fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error>;
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
where
T: Serialize;
/// Serialize a map value.
fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
fn serialize_value<T: ?Sized>(&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<K: ?Sized + Serialize, V: ?Sized + Serialize>(
fn serialize_entry<K: ?Sized, V: ?Sized>(
&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<T: ?Sized + Serialize>(
fn serialize_field<T: ?Sized>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Self::Error>;
) -> Result<(), Self::Error>
where
T: Serialize;
/// Finish serializing a struct.
fn end(self) -> Result<Self::Ok, Self::Error>;
@ -1276,11 +1302,13 @@ pub trait SerializeStructVariant {
type Error: Error;
/// Serialize a struct variant field.
fn serialize_field<T: ?Sized + Serialize>(
fn serialize_field<T: ?Sized>(
&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<Self::Ok, Self::Error>;
@ -1290,7 +1318,10 @@ trait LenHint: Iterator {
fn len_hint(&self) -> Option<usize>;
}
impl<I: Iterator> LenHint for I {
impl<I> LenHint for I
where
I: Iterator,
{
#[cfg(not(feature = "unstable"))]
fn len_hint(&self) -> Option<usize> {
iterator_len_hint(self)
@ -1303,13 +1334,19 @@ impl<I: Iterator> LenHint for I {
}
#[cfg(feature = "unstable")]
impl<I: ExactSizeIterator> LenHint for I {
impl<I> LenHint for I
where
I: ExactSizeIterator,
{
fn len_hint(&self) -> Option<usize> {
Some(self.len())
}
}
fn iterator_len_hint<I: Iterator>(iter: &I) -> Option<usize> {
fn iterator_len_hint<I>(iter: &I) -> Option<usize>
where
I: Iterator,
{
match iter.size_hint() {
(lo, Some(hi)) if lo == hi => Some(lo),
_ => None,