Convert over to where clauses

serde2/src/json/de.rs

@@ -81,9 +81,9 @@ impl<Iter: Iterator<Item=u8>> Deserializer<Iter> {
     }
 
     #[inline]
-    fn parse_value<
-        V: de::Visitor,
-    >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
+    fn parse_value<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
         self.parse_whitespace();
 
         if self.eof() {
@@ -140,9 +140,9 @@ impl<Iter: Iterator<Item=u8>> Deserializer<Iter> {
     }
 
     #[inline]
-    fn parse_number<
-        V: de::Visitor,
-    >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
+    fn parse_number<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
         let mut neg = 1;
 
         if self.ch_is(b'-') {
@@ -387,9 +387,9 @@ impl<Iter: Iterator<Item=u8>> de::Deserializer for Deserializer<Iter> {
     type Error = Error;
 
     #[inline]
-    fn visit<
-        V: de::Visitor,
-    >(&mut self, visitor: V) -> Result<V::Value, Error> {
+    fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
         self.parse_value(visitor)
     }
 }
@@ -402,9 +402,9 @@ struct SeqVisitor<'a, Iter: 'a> {
 impl<'a, Iter: Iterator<Item=u8>> de::SeqVisitor for SeqVisitor<'a, Iter> {
     type Error = Error;
 
-    fn visit<
-        T: de::Deserialize,
-    >(&mut self) -> Result<Option<T>, Error> {
+    fn visit<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize,
+    {
         self.de.parse_whitespace();
 
         if self.de.ch_is(b']') {
@@ -448,9 +448,9 @@ struct MapVisitor<'a, Iter: 'a> {
 impl<'a, Iter: Iterator<Item=u8>> de::MapVisitor for MapVisitor<'a, Iter> {
     type Error = Error;
 
-    fn visit_key<
-        K: de::Deserialize,
-    >(&mut self) -> Result<Option<K>, Error> {
+    fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
+        where K: de::Deserialize,
+    {
         self.de.parse_whitespace();
 
         if self.de.ch_is(b'}') {
@@ -482,9 +482,9 @@ impl<'a, Iter: Iterator<Item=u8>> de::MapVisitor for MapVisitor<'a, Iter> {
         Ok(Some(try!(de::Deserialize::deserialize(self.de))))
     }
 
-    fn visit_value<
-        V: de::Deserialize,
-    >(&mut self) -> Result<V, Error> {
+    fn visit_value<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
         self.de.parse_whitespace();
 
         if self.de.ch_is(b':') {

serde2/src/json/ser.rs

@@ -32,9 +32,9 @@ impl<W: io::Write> ser::Serializer for Serializer<W> {
     type Error = io::Error;
 
     #[inline]
-    fn visit<
-        T: ser::Serialize,
-    >(&mut self, value: &T) -> io::Result<()> {
+    fn visit<T>(&mut self, value: &T) -> io::Result<()>
+        where T: ser::Serialize,
+    {
         value.visit(&mut Visitor { writer: &mut self.writer })
     }
 }

serde2/src/json/value.rs

@@ -21,9 +21,9 @@ pub enum Value {
 
 impl ser::Serialize for Value {
     #[inline]
-    fn visit<
-        V: ser::Visitor,
-    >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
+    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
+        where V: ser::Visitor,
+    {
         match *self {
             Value::Null => visitor.visit_unit(),
             Value::Bool(v) => visitor.visit_bool(v),
@@ -91,9 +91,9 @@ impl ser::Serializer for Serializer {
     type Error = ();
 
     #[inline]
-    fn visit<
-        T: ser::Serialize,
-    >(&mut self, value: &T) -> Result<(), ()> {
+    fn visit<T>(&mut self, value: &T) -> Result<(), ()>
+        where T: ser::Serialize,
+    {
         try!(value.visit(self));
         Ok(())
     }
@@ -151,9 +151,9 @@ impl ser::Visitor for Serializer {
     }
 
     #[inline]
-    fn visit_some<
-        V: ser::Serialize,
-    >(&mut self, value: V) -> Result<(), ()> {
+    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
+        where V: ser::Serialize,
+    {
         value.visit(self)
     }
 
@@ -265,9 +265,9 @@ impl de::Deserializer for Deserializer {
     type Error = Error;
 
     #[inline]
-    fn visit<
-        V: de::Visitor,
-    >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
         let value = match self.value.take() {
             Some(value) => value,
             None => { return Err(de::Error::end_of_stream_error()); }
@@ -300,9 +300,9 @@ impl de::Deserializer for Deserializer {
     }
 
     #[inline]
-    fn visit_option<
-        V: de::Visitor,
-    >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
         match self.value {
             Some(Value::Null) => visitor.visit_none(),
             Some(_) => visitor.visit_some(self),