diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs
index 12d2b96d..222df624 100644
--- a/serde/src/de/impls.rs
+++ b/serde/src/de/impls.rs
@@ -78,7 +78,8 @@ macro_rules! visit_integer_method {
     ($src_ty:ident, $method:ident, $from_method:ident, $group:ident, $group_ty:ident) => {
         #[inline]
         fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
-            where E: Error
+        where
+            E: Error,
         {
             match FromPrimitive::$from_method(v) {
                 Some(v) => Ok(v),
@@ -92,7 +93,8 @@ macro_rules! visit_float_method {
     ($src_ty:ident, $method:ident) => {
         #[inline]
         fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
-            where E: Error
+        where
+            E: Error,
         {
             Ok(v as Self::Value)
         }
@@ -104,7 +106,8 @@ macro_rules! impl_deserialize_num {
         impl<'de> Deserialize<'de> for $ty {
             #[inline]
             fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error>
-                where D: Deserializer<'de>,
+            where
+                D: Deserializer<'de>,
             {
                 struct PrimitiveVisitor;
 
@@ -510,8 +513,9 @@ macro_rules! seq_impl {
         }
 
         impl<'de, T $(, $typaram)*> Visitor<'de> for $visitor_ty<T $(, $typaram)*>
-            where T: Deserialize<'de>,
-                  $($($boundparam: $bound1 $(+ $bound2)*),*)*
+        where
+            T: Deserialize<'de>,
+            $($($boundparam: $bound1 $(+ $bound2)*),*)*
         {
             type Value = $ty<T $(, $typaram)*>;
 
@@ -521,7 +525,8 @@ macro_rules! seq_impl {
 
             #[inline]
             fn visit_seq<V>(self, mut $visitor: V) -> Result<Self::Value, V::Error>
-                where V: SeqVisitor<'de>,
+            where
+                V: SeqVisitor<'de>,
             {
                 let mut values = $with_capacity;
 
@@ -534,11 +539,13 @@ macro_rules! seq_impl {
         }
 
         impl<'de, T $(, $typaram)*> Deserialize<'de> for $ty<T $(, $typaram)*>
-            where T: Deserialize<'de>,
-                  $($($boundparam: $bound1 $(+ $bound2)*),*)*
+        where
+            T: Deserialize<'de>,
+            $($($boundparam: $bound1 $(+ $bound2)*),*)*
         {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where D: Deserializer<'de>,
+            where
+                D: Deserializer<'de>,
             {
                 deserializer.deserialize_seq($visitor_ty::new())
             }
@@ -643,7 +650,8 @@ macro_rules! array_impls {
     ($($len:expr => ($($n:tt $name:ident)+))+) => {
         $(
             impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]>
-                where T: Deserialize<'de>
+            where
+                T: Deserialize<'de>,
             {
                 type Value = [T; $len];
 
@@ -653,7 +661,8 @@ macro_rules! array_impls {
 
                 #[inline]
                 fn visit_seq<V>(self, mut visitor: V) -> Result<[T; $len], V::Error>
-                    where V: SeqVisitor<'de>,
+                where
+                    V: SeqVisitor<'de>,
                 {
                     $(
                         let $name = match try!(visitor.visit()) {
@@ -667,10 +676,12 @@ macro_rules! array_impls {
             }
 
             impl<'de, T> Deserialize<'de> for [T; $len]
-                where T: Deserialize<'de>,
+            where
+                T: Deserialize<'de>,
             {
                 fn deserialize<D>(deserializer: D) -> Result<[T; $len], D::Error>
-                    where D: Deserializer<'de>,
+                where
+                    D: Deserializer<'de>,
                 {
                     deserializer.deserialize_seq_fixed_size($len, ArrayVisitor::<[T; $len]>::new())
                 }
@@ -739,7 +750,8 @@ macro_rules! tuple_impls {
                 #[inline]
                 #[allow(non_snake_case)]
                 fn visit_seq<V>(self, mut visitor: V) -> Result<($($name,)+), V::Error>
-                    where V: SeqVisitor<'de>,
+                where
+                    V: SeqVisitor<'de>,
                 {
                     $(
                         let $name = match try!(visitor.visit()) {
@@ -755,7 +767,8 @@ macro_rules! tuple_impls {
             impl<'de, $($name: Deserialize<'de>),+> Deserialize<'de> for ($($name,)+) {
                 #[inline]
                 fn deserialize<D>(deserializer: D) -> Result<($($name,)+), D::Error>
-                    where D: Deserializer<'de>,
+                where
+                    D: Deserializer<'de>,
                 {
                     deserializer.deserialize_tuple($len, $visitor::new())
                 }
@@ -806,9 +819,10 @@ macro_rules! map_impl {
         }
 
         impl<'de, K, V $(, $typaram)*> Visitor<'de> for $visitor_ty<K, V $(, $typaram)*>
-            where K: Deserialize<'de>,
-                  V: Deserialize<'de>,
-                  $($boundparam: $bound1 $(+ $bound2)*),*
+        where
+            K: Deserialize<'de>,
+            V: Deserialize<'de>,
+            $($boundparam: $bound1 $(+ $bound2)*),*
         {
             type Value = $ty<K, V $(, $typaram)*>;
 
@@ -818,7 +832,8 @@ macro_rules! map_impl {
 
             #[inline]
             fn visit_map<Visitor>(self, mut $visitor: Visitor) -> Result<Self::Value, Visitor::Error>
-                where Visitor: MapVisitor<'de>,
+            where
+                Visitor: MapVisitor<'de>,
             {
                 let mut values = $with_capacity;
 
@@ -831,12 +846,14 @@ macro_rules! map_impl {
         }
 
         impl<'de, K, V $(, $typaram)*> Deserialize<'de> for $ty<K, V $(, $typaram)*>
-            where K: Deserialize<'de>,
-                  V: Deserialize<'de>,
-                  $($boundparam: $bound1 $(+ $bound2)*),*
+        where
+            K: Deserialize<'de>,
+            V: Deserialize<'de>,
+            $($boundparam: $bound1 $(+ $bound2)*),*
         {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where D: Deserializer<'de>,
+            where
+                D: Deserializer<'de>,
             {
                 deserializer.deserialize_map($visitor_ty::new())
             }
diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs
index 76b2ea84..2e611551 100644
--- a/serde/src/de/value.rs
+++ b/serde/src/de/value.rs
@@ -121,7 +121,8 @@ macro_rules! primitive_deserializer {
         }
 
         impl<'de, E> IntoDeserializer<'de, E> for $ty
-            where E: de::Error,
+        where
+            E: de::Error,
         {
             type Deserializer = $name<E>;
 
@@ -134,7 +135,8 @@ macro_rules! primitive_deserializer {
         }
 
         impl<'de, E> de::Deserializer<'de> for $name<E>
-            where E: de::Error,
+        where
+            E: de::Error,
         {
             type Error = E;
 
@@ -145,7 +147,8 @@ macro_rules! primitive_deserializer {
             }
 
             fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-                where V: de::Visitor<'de>,
+            where
+                V: de::Visitor<'de>,
             {
                 visitor.$method(self.value $($cast)*)
             }
@@ -700,16 +703,18 @@ where
 }
 
 impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E>
-    where I: Iterator,
-          I::Item: private::Pair,
-          First<I::Item>: IntoDeserializer<'de, E>,
-          Second<I::Item>: IntoDeserializer<'de, E>,
-          E: de::Error
+where
+    I: Iterator,
+    I::Item: private::Pair,
+    First<I::Item>: IntoDeserializer<'de, E>,
+    Second<I::Item>: IntoDeserializer<'de, E>,
+    E: de::Error,
 {
     type Error = E;
 
     fn deserialize<V_>(mut self, visitor: V_) -> Result<V_::Value, Self::Error>
-        where V_: de::Visitor<'de>
+    where
+        V_: de::Visitor<'de>,
     {
         let value = try!(visitor.visit_map(&mut self));
         try!(self.end());
@@ -717,7 +722,8 @@ impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E>
     }
 
     fn deserialize_seq<V_>(mut self, visitor: V_) -> Result<V_::Value, Self::Error>
-        where V_: de::Visitor<'de>
+    where
+        V_: de::Visitor<'de>,
     {
         let value = try!(visitor.visit_seq(&mut self));
         try!(self.end());
@@ -728,7 +734,8 @@ impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E>
                                       _len: usize,
                                       visitor: V_)
                                       -> Result<V_::Value, Self::Error>
-        where V_: de::Visitor<'de>
+    where
+        V_: de::Visitor<'de>,
     {
         self.deserialize_seq(visitor)
     }
@@ -741,16 +748,18 @@ impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E>
 }
 
 impl<'de, I, E> de::MapVisitor<'de> for MapDeserializer<'de, I, E>
-    where I: Iterator,
-          I::Item: private::Pair,
-          First<I::Item>: IntoDeserializer<'de, E>,
-          Second<I::Item>: IntoDeserializer<'de, E>,
-          E: de::Error
+where
+    I: Iterator,
+    I::Item: private::Pair,
+    First<I::Item>: IntoDeserializer<'de, E>,
+    Second<I::Item>: IntoDeserializer<'de, E>,
+    E: de::Error,
 {
     type Error = E;
 
     fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-        where T: de::DeserializeSeed<'de>
+    where
+        T: de::DeserializeSeed<'de>,
     {
         match self.next_pair() {
             Some((key, value)) => {
@@ -762,7 +771,8 @@ impl<'de, I, E> de::MapVisitor<'de> for MapDeserializer<'de, I, E>
     }
 
     fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-        where T: de::DeserializeSeed<'de>
+    where
+        T: de::DeserializeSeed<'de>,
     {
         let value = self.value.take();
         // Panic because this indicates a bug in the program rather than an
@@ -775,8 +785,9 @@ impl<'de, I, E> de::MapVisitor<'de> for MapDeserializer<'de, I, E>
                           kseed: TK,
                           vseed: TV)
                           -> Result<Option<(TK::Value, TV::Value)>, Self::Error>
-        where TK: de::DeserializeSeed<'de>,
-              TV: de::DeserializeSeed<'de>
+    where
+        TK: de::DeserializeSeed<'de>,
+        TV: de::DeserializeSeed<'de>,
     {
         match self.next_pair() {
             Some((key, value)) => {
@@ -794,16 +805,18 @@ impl<'de, I, E> de::MapVisitor<'de> for MapDeserializer<'de, I, E>
 }
 
 impl<'de, I, E> de::SeqVisitor<'de> for MapDeserializer<'de, I, E>
-    where I: Iterator,
-          I::Item: private::Pair,
-          First<I::Item>: IntoDeserializer<'de, E>,
-          Second<I::Item>: IntoDeserializer<'de, E>,
-          E: de::Error
+where
+    I: Iterator,
+    I::Item: private::Pair,
+    First<I::Item>: IntoDeserializer<'de, E>,
+    Second<I::Item>: IntoDeserializer<'de, E>,
+    E: de::Error,
 {
     type Error = E;
 
     fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-        where T: de::DeserializeSeed<'de>
+    where
+        T: de::DeserializeSeed<'de>,
     {
         match self.next_pair() {
             Some((k, v)) => {
@@ -823,11 +836,12 @@ impl<'de, I, E> de::SeqVisitor<'de> for MapDeserializer<'de, I, E>
 //
 //    <I::Item as private::Pair>::Second: Clone
 impl<'de, I, E> Clone for MapDeserializer<'de, I, E>
-    where I: Iterator + Clone,
-          I::Item: private::Pair,
-          First<I::Item>: IntoDeserializer<'de, E>,
-          Second<I::Item>: IntoDeserializer<'de, E> + Clone,
-          E: de::Error
+where
+    I: Iterator + Clone,
+    I::Item: private::Pair,
+    First<I::Item>: IntoDeserializer<'de, E>,
+    Second<I::Item>: IntoDeserializer<'de, E> + Clone,
+    E: de::Error,
 {
     fn clone(&self) -> Self {
         MapDeserializer {
@@ -844,11 +858,12 @@ impl<'de, I, E> Clone for MapDeserializer<'de, I, E>
 //
 //    <I::Item as private::Pair>::Second: Debug
 impl<'de, I, E> Debug for MapDeserializer<'de, I, E>
-    where I: Iterator + Debug,
-          I::Item: private::Pair,
-          First<I::Item>: IntoDeserializer<'de, E>,
-          Second<I::Item>: IntoDeserializer<'de, E> + Debug,
-          E: de::Error
+where
+    I: Iterator + Debug,
+    I::Item: private::Pair,
+    First<I::Item>: IntoDeserializer<'de, E>,
+    Second<I::Item>: IntoDeserializer<'de, E> + Debug,
+    E: de::Error,
 {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         formatter.debug_struct("MapDeserializer")
diff --git a/serde/src/macros.rs b/serde/src/macros.rs
index 2ff7ec37..f75eebf9 100644
--- a/serde/src/macros.rs
+++ b/serde/src/macros.rs
@@ -141,7 +141,8 @@ macro_rules! forward_to_deserialize_method {
     ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
         #[inline]
         fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::export::Result<$v::Value, Self::Error>
-            where $v: $crate::de::Visitor<$l>
+        where
+            $v: $crate::de::Visitor<$l>,
         {
             $(
                 let _ = $arg;
diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs
index a44da1ce..c10cbe52 100644
--- a/serde/src/ser/impls.rs
+++ b/serde/src/ser/impls.rs
@@ -137,10 +137,14 @@ impl<T> Serialize for [T; 0] {
 macro_rules! array_impls {
     ($($len:tt)+) => {
         $(
-            impl<T> Serialize for [T; $len] where T: Serialize {
+            impl<T> Serialize for [T; $len]
+            where
+                T: Serialize,
+            {
                 #[inline]
                 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                    where S: Serializer,
+                where
+                    S: Serializer,
                 {
                     let mut seq = try!(serializer.serialize_seq_fixed_size($len));
                     for e in self {
@@ -166,7 +170,8 @@ where
 {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: Serializer,
+    where
+        S: Serializer,
     {
         serializer.collect_seq(self)
     }
@@ -181,7 +186,8 @@ macro_rules! seq_impl {
         {
             #[inline]
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where S: Serializer,
+            where
+                S: Serializer,
             {
                 serializer.collect_seq(self)
             }
@@ -294,7 +300,8 @@ macro_rules! map_impl {
         {
             #[inline]
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where S: Serializer,
+            where
+                S: Serializer,
             {
                 serializer.collect_seq(self)
             }