diff --git a/src/aster/generics.rs b/src/aster/generics.rs
index 8feb87c..caee562 100644
--- a/src/aster/generics.rs
+++ b/src/aster/generics.rs
@@ -169,9 +169,7 @@
     }
 
     pub fn strip_bounds(self) -> Self {
-        self.strip_lifetimes()
-            .strip_ty_params()
-            .strip_predicates()
+        self.strip_lifetimes().strip_ty_params().strip_predicates()
     }
 
     pub fn strip_lifetimes(mut self) -> Self {
@@ -195,10 +193,10 @@
 
     pub fn build(self) -> F::Result {
         self.callback.invoke(Generics {
-            lifetimes: self.lifetimes,
-            ty_params: self.ty_params,
-            where_clause: WhereClause { predicates: self.predicates },
-        })
+                                 lifetimes: self.lifetimes,
+                                 ty_params: self.ty_params,
+                                 where_clause: WhereClause { predicates: self.predicates },
+                             })
     }
 }
 
diff --git a/src/aster/lifetime.rs b/src/aster/lifetime.rs
index 49df4a0..3bdf372 100644
--- a/src/aster/lifetime.rs
+++ b/src/aster/lifetime.rs
@@ -95,9 +95,9 @@
 
     pub fn build(self) -> F::Result {
         self.callback.invoke(LifetimeDef {
-            attrs: vec![],
-            lifetime: self.lifetime,
-            bounds: self.bounds,
-        })
+                                 attrs: vec![],
+                                 lifetime: self.lifetime,
+                                 bounds: self.bounds,
+                             })
     }
 }
diff --git a/src/aster/path.rs b/src/aster/path.rs
index a0fb314..e53b142 100644
--- a/src/aster/path.rs
+++ b/src/aster/path.rs
@@ -139,9 +139,9 @@
 
     pub fn build(self) -> F::Result {
         self.callback.invoke(Path {
-            global: self.global,
-            segments: self.segments,
-        })
+                                 global: self.global,
+                                 segments: self.segments,
+                             })
     }
 }
 
@@ -181,16 +181,12 @@
 
     pub fn with_generics(self, generics: Generics) -> Self {
         // Strip off the bounds.
-        let lifetimes = generics.lifetimes
-            .iter()
-            .map(|lifetime_def| lifetime_def.lifetime.clone());
+        let lifetimes = generics.lifetimes.iter().map(|lifetime_def| lifetime_def.lifetime.clone());
 
-        let tys = generics.ty_params
-            .iter()
-            .map(|ty_param| TyBuilder::new().id(ty_param.ident.clone()));
+        let tys =
+            generics.ty_params.iter().map(|ty_param| TyBuilder::new().id(ty_param.ident.clone()));
 
-        self.with_lifetimes(lifetimes)
-            .with_tys(tys)
+        self.with_lifetimes(lifetimes).with_tys(tys)
     }
 
     pub fn with_lifetimes<I, L>(mut self, iter: I) -> Self
@@ -241,9 +237,9 @@
         where T: ToIdent
     {
         TyBuilder::with_callback(TypeBindingBuilder {
-            id: id.to_ident(),
-            builder: self,
-        })
+                                     id: id.to_ident(),
+                                     builder: self,
+                                 })
     }
 
     pub fn no_return(self) -> F::Result {
@@ -263,9 +259,9 @@
         let parameters = PathParameters::Parenthesized(data);
 
         self.callback.invoke(PathSegment {
-            ident: self.id,
-            parameters: parameters,
-        })
+                                 ident: self.id,
+                                 parameters: parameters,
+                             })
     }
 
     pub fn build(self) -> F::Result {
@@ -278,9 +274,9 @@
         let parameters = PathParameters::AngleBracketed(data);
 
         self.callback.invoke(PathSegment {
-            ident: self.id,
-            parameters: parameters,
-        })
+                                 ident: self.id,
+                                 parameters: parameters,
+                             })
     }
 }
 
@@ -310,9 +306,9 @@
         let id = self.id;
 
         self.builder.with_binding(TypeBinding {
-            ident: id,
-            ty: ty,
-        })
+                                      ident: id,
+                                      ty: ty,
+                                  })
     }
 }
 
diff --git a/src/aster/ty.rs b/src/aster/ty.rs
index 127b164..7dff3b4 100644
--- a/src/aster/ty.rs
+++ b/src/aster/ty.rs
@@ -410,9 +410,7 @@
     }
 
     pub fn with_generics(self, generics: Generics) -> Self {
-        self.with_lifetimes(generics.lifetimes
-            .into_iter()
-            .map(|def| def.lifetime))
+        self.with_lifetimes(generics.lifetimes.into_iter().map(|def| def.lifetime))
     }
 
     pub fn with_lifetimes<I, L>(mut self, lifetimes: I) -> Self
diff --git a/src/aster/ty_param.rs b/src/aster/ty_param.rs
index 2836203..d8d13d1 100644
--- a/src/aster/ty_param.rs
+++ b/src/aster/ty_param.rs
@@ -87,11 +87,11 @@
 
     pub fn build(self) -> F::Result {
         self.callback.invoke(TyParam {
-            attrs: vec![],
-            ident: self.id,
-            bounds: self.bounds,
-            default: self.default,
-        })
+                                 attrs: vec![],
+                                 ident: self.id,
+                                 bounds: self.bounds,
+                                 default: self.default,
+                             })
     }
 }
 
@@ -245,9 +245,9 @@
 
     pub fn build(self) -> F::Result {
         self.callback.invoke(PolyTraitRef {
-            bound_lifetimes: self.lifetimes,
-            trait_ref: self.trait_ref,
-        })
+                                 bound_lifetimes: self.lifetimes,
+                                 trait_ref: self.trait_ref,
+                             })
     }
 }
 
diff --git a/src/escape.rs b/src/escape.rs
index 80c3def..c17a158 100644
--- a/src/escape.rs
+++ b/src/escape.rs
@@ -281,12 +281,14 @@
 fn test_cooked_string() {
     let input = "\\x62 \\\n \\u{7} \\u{64} \\u{bf5} \\u{12ba} \\u{1F395} \\u{102345}\"";
     let expected = "\x62 \u{7} \u{64} \u{bf5} \u{12ba} \u{1F395} \u{102345}";
-    assert_eq!(cooked_string(input), IResult::Done("\"", expected.to_string()));
+    assert_eq!(cooked_string(input),
+               IResult::Done("\"", expected.to_string()));
 }
 
 #[test]
 fn test_cooked_byte_string() {
     let input = "\\x62 \\\n \\xEF\"";
     let expected = b"\x62 \xEF";
-    assert_eq!(cooked_byte_string(input), IResult::Done("\"", expected.to_vec()));
+    assert_eq!(cooked_byte_string(input),
+               IResult::Done("\"", expected.to_vec()));
 }
diff --git a/src/expr.rs b/src/expr.rs
index cde988e..69a3389 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -1406,9 +1406,9 @@
                     if qself.position > 0 {
                         tokens.append("as");
                         for (i, segment) in path.segments
-                            .iter()
-                            .take(qself.position)
-                            .enumerate() {
+                                .iter()
+                                .take(qself.position)
+                                .enumerate() {
                             if i > 0 || path.global {
                                 tokens.append("::");
                             }
@@ -1554,9 +1554,9 @@
                     if qself.position > 0 {
                         tokens.append("as");
                         for (i, segment) in path.segments
-                            .iter()
-                            .take(qself.position)
-                            .enumerate() {
+                                .iter()
+                                .take(qself.position)
+                                .enumerate() {
                             if i > 0 || path.global {
                                 tokens.append("::");
                             }
diff --git a/src/fold.rs b/src/fold.rs
index 374ff68..2874118 100644
--- a/src/fold.rs
+++ b/src/fold.rs
@@ -183,7 +183,7 @@
                                                       vis,
                                                       attrs,
                                                       generics,
-                                                      body }: DeriveInput) -> DeriveInput {
+body }: DeriveInput) -> DeriveInput{
     use Body::*;
     DeriveInput {
         ident: folder.fold_ident(ident),
@@ -206,18 +206,18 @@
             let mutable_type_ = *mutable_type;
             let MutTy { ty, mutability }: MutTy = mutable_type_;
             Ptr(Box::new(MutTy {
-                ty: folder.fold_ty(ty),
-                mutability: mutability,
-            }))
+                             ty: folder.fold_ty(ty),
+                             mutability: mutability,
+                         }))
         }
         Rptr(opt_lifetime, mutable_type) => {
             let mutable_type_ = *mutable_type;
             let MutTy { ty, mutability }: MutTy = mutable_type_;
             Rptr(opt_lifetime.map(|l| folder.fold_lifetime(l)),
                  Box::new(MutTy {
-                     ty: folder.fold_ty(ty),
-                     mutability: mutability,
-                 }))
+                              ty: folder.fold_ty(ty),
+                              mutability: mutability,
+                          }))
         }
         Never => Never,
         Infer => Infer,
@@ -226,18 +226,18 @@
             let bf_ = *bare_fn;
             let BareFnTy { unsafety, abi, lifetimes, inputs, output, variadic } = bf_;
             BareFn(Box::new(BareFnTy {
-                unsafety: unsafety,
-                abi: abi,
-                lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
-                inputs: inputs.lift(|v| {
-                    BareFnArg {
-                        name: v.name.map(|n| folder.fold_ident(n)),
-                        ty: folder.fold_ty(v.ty),
-                    }
-                }),
-                output: folder.fold_fn_ret_ty(output),
-                variadic: variadic,
-            }))
+                                unsafety: unsafety,
+                                abi: abi,
+                                lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
+                                inputs: inputs.lift(|v| {
+                BareFnArg {
+                    name: v.name.map(|n| folder.fold_ident(n)),
+                    ty: folder.fold_ty(v.ty),
+                }
+            }),
+                                output: folder.fold_fn_ret_ty(output),
+                                variadic: variadic,
+                            }))
         }
         Path(maybe_qself, path) => {
             Path(maybe_qself.map(|v| noop_fold_qself(folder, v)),
@@ -264,7 +264,7 @@
 
 pub fn noop_fold_generics<F: ?Sized + Folder>(folder: &mut F,
                                      Generics { lifetimes, ty_params, where_clause }: Generics)
-                                     -> Generics {
+-> Generics{
     use WherePredicate::*;
     Generics {
         lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
@@ -272,15 +272,13 @@
             TyParam {
                 attrs: ty.attrs.lift(|a| folder.fold_attribute(a)),
                 ident: folder.fold_ident(ty.ident),
-                bounds: ty.bounds
-                    .lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
+                bounds: ty.bounds.lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
                 default: ty.default.map(|v| folder.fold_ty(v)),
             }
         }),
         where_clause: WhereClause {
-            predicates: where_clause.predicates
-                .lift(|p| match p {
-                    BoundPredicate(bound_predicate) => {
+            predicates: where_clause.predicates.lift(|p| match p {
+                                                         BoundPredicate(bound_predicate) => {
                         BoundPredicate(WhereBoundPredicate {
                             bound_lifetimes: bound_predicate.bound_lifetimes
                                 .lift(|l| folder.fold_lifetime_def(l)),
@@ -289,20 +287,20 @@
                                 .lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
                         })
                     }
-                    RegionPredicate(region_predicate) => {
+                                                         RegionPredicate(region_predicate) => {
                         RegionPredicate(WhereRegionPredicate {
                             lifetime: folder.fold_lifetime(region_predicate.lifetime),
                             bounds: region_predicate.bounds
                                 .lift(|b| folder.fold_lifetime(b)),
                         })
                     }
-                    EqPredicate(eq_predicate) => {
+                                                         EqPredicate(eq_predicate) => {
                         EqPredicate(WhereEqPredicate {
                             lhs_ty: folder.fold_ty(eq_predicate.lhs_ty),
                             rhs_ty: folder.fold_ty(eq_predicate.rhs_ty),
                         })
                     }
-                }),
+                                                     }),
         },
     }
 }
@@ -321,8 +319,7 @@
                                                     trait_ref: PolyTraitRef)
                                                     -> PolyTraitRef {
     PolyTraitRef {
-        bound_lifetimes: trait_ref.bound_lifetimes
-            .lift(|bl| folder.fold_lifetime_def(bl)),
+        bound_lifetimes: trait_ref.bound_lifetimes.lift(|bl| folder.fold_lifetime_def(bl)),
         trait_ref: folder.fold_path(trait_ref.trait_ref),
     }
 }
@@ -349,7 +346,7 @@
 
 pub fn noop_fold_variant<F: ?Sized + Folder>(folder: &mut F,
                                     Variant { ident, attrs, data, discriminant }: Variant)
-                                    -> Variant {
+-> Variant{
     Variant {
         ident: folder.fold_ident(ident),
         attrs: attrs.lift(|v| folder.fold_attribute(v)),
@@ -364,7 +361,7 @@
 
 pub fn noop_fold_lifetime_def<F: ?Sized + Folder>(folder: &mut F,
                                          LifetimeDef { attrs, lifetime, bounds }: LifetimeDef)
-                                         -> LifetimeDef {
+-> LifetimeDef{
     LifetimeDef {
         attrs: attrs.lift(|x| folder.fold_attribute(x)),
         lifetime: folder.fold_lifetime(lifetime),
@@ -396,17 +393,19 @@
         AngleBracketed(d) => {
             let AngleBracketedParameterData { lifetimes, types, bindings } = d;
             AngleBracketed(AngleBracketedParameterData {
-                lifetimes: lifetimes.into_iter().map(|l| folder.fold_lifetime(l)).collect(),
-                types: types.lift(|ty| folder.fold_ty(ty)),
-                bindings: bindings.lift(|tb| folder.fold_assoc_type_binding(tb)),
-            })
+                               lifetimes: lifetimes.into_iter()
+                                   .map(|l| folder.fold_lifetime(l))
+                                   .collect(),
+                               types: types.lift(|ty| folder.fold_ty(ty)),
+                               bindings: bindings.lift(|tb| folder.fold_assoc_type_binding(tb)),
+                           })
         }
         Parenthesized(d) => {
             let ParenthesizedParameterData { inputs, output } = d;
             Parenthesized(ParenthesizedParameterData {
-                inputs: inputs.lift(|i| folder.fold_ty(i)),
-                output: output.map(|v| folder.fold_ty(v)),
-            })
+                              inputs: inputs.lift(|i| folder.fold_ty(i)),
+                              output: output.map(|v| folder.fold_ty(v)),
+                          })
         }
     }
 }
@@ -469,7 +468,9 @@
 }
 
 #[cfg(not(feature = "full"))]
-fn noop_fold_other_const_expr<F: ?Sized + Folder>(_: &mut F, e: constant::Other) -> constant::Other {
+fn noop_fold_other_const_expr<F: ?Sized + Folder>(_: &mut F,
+                                                  e: constant::Other)
+                                                  -> constant::Other {
     e
 }
 
@@ -483,17 +484,17 @@
     match tt {
         Token(token) => {
             Token(match token {
-                Literal(lit) => Literal(folder.fold_lit(lit)),
-                Ident(ident) => Ident(folder.fold_ident(ident)),
-                Lifetime(ident) => Lifetime(folder.fold_ident(ident)),
-                x => x,
-            })
+                      Literal(lit) => Literal(folder.fold_lit(lit)),
+                      Ident(ident) => Ident(folder.fold_ident(ident)),
+                      Lifetime(ident) => Lifetime(folder.fold_ident(ident)),
+                      x => x,
+                  })
         }
         Delimited(super::Delimited { delim, tts }) => {
             Delimited(super::Delimited {
-                delim: delim,
-                tts: tts.lift(|v| noop_fold_tt(folder, v)),
-            })
+                          delim: delim,
+                          tts: tts.lift(|v| noop_fold_tt(folder, v)),
+                      })
         }
     }
 }
@@ -564,9 +565,11 @@
             Mod(items) => Mod(items.map(|items| items.lift(|i| folder.fold_item(i)))),
             ForeignMod(super::ForeignMod { abi, items }) => {
                 ForeignMod(super::ForeignMod {
-                    abi: abi,
-                    items: items.lift(|foreign_item| folder.fold_foreign_item(foreign_item)),
-                })
+                               abi: abi,
+                               items: items.lift(|foreign_item| {
+                                                     folder.fold_foreign_item(foreign_item)
+                                                 }),
+                           })
             }
             Ty(ty, generics) => {
                 Ty(ty.lift(|ty| folder.fold_ty(ty)),
@@ -747,7 +750,7 @@
 #[cfg(feature = "full")]
 pub fn noop_fold_foreign_item<F: ?Sized + Folder>(folder: &mut F,
                                          ForeignItem { ident, attrs, node, vis }: ForeignItem)
-                                         -> ForeignItem {
+-> ForeignItem{
     ForeignItem {
         ident: folder.fold_ident(ident),
         attrs: attrs.into_iter().map(|a| folder.fold_attribute(a)).collect(),
@@ -861,7 +864,7 @@
 #[cfg(feature = "full")]
 pub fn noop_fold_impl_item<F: ?Sized + Folder>(folder: &mut F,
                                       ImplItem { ident, vis, defaultness, attrs, node }: ImplItem)
-                                      -> ImplItem {
+-> ImplItem{
     use ImplItemKind::*;
     ImplItem {
         ident: folder.fold_ident(ident),
@@ -878,7 +881,7 @@
 }
 
 #[cfg(feature = "full")]
-pub fn noop_fold_method_sig<F: ?Sized + Folder>(folder: &mut F, MethodSig{unsafety, constness, abi, decl, generics}:MethodSig) -> MethodSig {
+pub fn noop_fold_method_sig<F: ?Sized + Folder>(folder: &mut F, MethodSig{unsafety, constness, abi, decl, generics}:MethodSig) -> MethodSig{
     MethodSig {
         unsafety: unsafety,
         constness: constness,
@@ -899,8 +902,10 @@
         Semi(expr) => Semi(expr.lift(|v| folder.fold_expr(v))),
         Mac(mac_stmt) => {
             Mac(mac_stmt.lift(|(mac, style, attrs)| {
-                (folder.fold_mac(mac), style, attrs.lift(|a| folder.fold_attribute(a)))
-            }))
+                                  (folder.fold_mac(mac),
+                                   style,
+                                   attrs.lift(|a| folder.fold_attribute(a)))
+                              }))
         }
     }
 
@@ -927,11 +932,11 @@
         List(path, items) => {
             List(folder.fold_path(path),
                  items.lift(|PathListItem { name, rename }: PathListItem| {
-                     PathListItem {
-                         name: folder.fold_ident(name),
-                         rename: rename.map(|i| folder.fold_ident(i)),
-                     }
-                 }))
+                                PathListItem {
+                                    name: folder.fold_ident(name),
+                                    rename: rename.map(|i| folder.fold_ident(i)),
+                                }
+                            }))
         }
     }
 }
diff --git a/src/generics.rs b/src/generics.rs
index 46d7c43..276a7b0 100644
--- a/src/generics.rs
+++ b/src/generics.rs
@@ -337,7 +337,10 @@
                 tokens.append("<");
                 tokens.append_separated(&self.0.lifetimes, ",");
                 // Leave off the type parameter defaults
-                for (i, ty_param) in self.0.ty_params.iter().enumerate() {
+                for (i, ty_param) in self.0
+                        .ty_params
+                        .iter()
+                        .enumerate() {
                     if i > 0 || has_lifetimes {
                         tokens.append(",");
                     }
@@ -360,13 +363,19 @@
             if has_lifetimes || has_ty_params {
                 tokens.append("<");
                 // Leave off the lifetime bounds and attributes
-                let lifetimes = self.0.lifetimes.iter().map(|ld| &ld.lifetime);
+                let lifetimes = self.0
+                    .lifetimes
+                    .iter()
+                    .map(|ld| &ld.lifetime);
                 tokens.append_separated(lifetimes, ",");
                 if has_lifetimes && has_ty_params {
                     tokens.append(",");
                 }
                 // Leave off the type parameter bounds, defaults, and attributes
-                let ty_params = self.0.ty_params.iter().map(|tp| &tp.ident);
+                let ty_params = self.0
+                    .ty_params
+                    .iter()
+                    .map(|tp| &tp.ident);
                 tokens.append_separated(ty_params, ",");
                 tokens.append(">");
             }
diff --git a/src/ident.rs b/src/ident.rs
index 29fd7e8..5989aae 100644
--- a/src/ident.rs
+++ b/src/ident.rs
@@ -105,10 +105,10 @@
         for (i, ch) in input.char_indices() {
             if !UnicodeXID::is_xid_start(ch) && !UnicodeXID::is_xid_continue(ch) {
                 return if i == 0 {
-                    IResult::Error
-                } else {
-                    IResult::Done(&input[i..], input[..i].into())
-                };
+                           IResult::Error
+                       } else {
+                           IResult::Done(&input[i..], input[..i].into())
+                       };
             }
         }
 
diff --git a/src/lib.rs b/src/lib.rs
index 7ba96a4..180390c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -28,8 +28,8 @@
 #[cfg(feature = "full")]
 mod expr;
 #[cfg(feature = "full")]
-pub use expr::{Arm, BindingMode, Block, CaptureBy, Expr, ExprKind, FieldPat, FieldValue,
-               Local, MacStmtStyle, Pat, RangeLimits, Stmt};
+pub use expr::{Arm, BindingMode, Block, CaptureBy, Expr, ExprKind, FieldPat, FieldValue, Local,
+               MacStmtStyle, Pat, RangeLimits, Stmt};
 
 mod generics;
 pub use generics::{Generics, Lifetime, LifetimeDef, TraitBoundModifier, TyParam, TyParamBound,
@@ -138,7 +138,9 @@
     }
 
     pub fn parse_ty_param_bound(input: &str) -> Result<TyParamBound, String> {
-        unwrap("type parameter bound", generics::parsing::ty_param_bound, input)
+        unwrap("type parameter bound",
+               generics::parsing::ty_param_bound,
+               input)
     }
 
     pub fn parse_outer_attr(input: &str) -> Result<Attribute, String> {
diff --git a/src/lit.rs b/src/lit.rs
index 419ff74..81be285 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -291,8 +291,8 @@
                     }
                     chars.next();
                     if chars.peek()
-                        .map(|&ch| ch == '.' || UnicodeXID::is_xid_start(ch))
-                        .unwrap_or(false) {
+                           .map(|&ch| ch == '.' || UnicodeXID::is_xid_start(ch))
+                           .unwrap_or(false) {
                         return IResult::Error;
                     }
                     len += 1;
@@ -413,8 +413,8 @@
                 Lit::Str(ref s, StrStyle::Cooked) => s.to_tokens(tokens),
                 Lit::Str(ref s, StrStyle::Raw(n)) => {
                     tokens.append(&format!("r{delim}\"{string}\"{delim}",
-                        delim = iter::repeat("#").take(n).collect::<String>(),
-                        string = s));
+                                           delim = iter::repeat("#").take(n).collect::<String>(),
+                                           string = s));
                 }
                 Lit::ByteStr(ref v, StrStyle::Cooked) => {
                     let mut escaped = "b\"".to_string();
@@ -430,8 +430,8 @@
                 }
                 Lit::ByteStr(ref vec, StrStyle::Raw(n)) => {
                     tokens.append(&format!("br{delim}\"{string}\"{delim}",
-                        delim = iter::repeat("#").take(n).collect::<String>(),
-                        string = str::from_utf8(vec).unwrap()));
+                                           delim = iter::repeat("#").take(n).collect::<String>(),
+                                           string = str::from_utf8(vec).unwrap()));
                 }
                 Lit::Byte(b) => {
                     match b {
diff --git a/src/ty.rs b/src/ty.rs
index 6a84a2b..4055b6a 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -635,9 +635,9 @@
                     if qself.position > 0 {
                         tokens.append("as");
                         for (i, segment) in path.segments
-                            .iter()
-                            .take(qself.position)
-                            .enumerate() {
+                                .iter()
+                                .take(qself.position)
+                                .enumerate() {
                             if i > 0 || path.global {
                                 tokens.append("::");
                             }
diff --git a/src/visit.rs b/src/visit.rs
index 6c32fce..8c8645d 100644
--- a/src/visit.rs
+++ b/src/visit.rs
@@ -286,9 +286,7 @@
                 visitor.visit_lifetime(lifetime);
                 walk_list!(visitor, visit_lifetime, bounds);
             }
-            WherePredicate::EqPredicate(WhereEqPredicate { ref lhs_ty,
-                                                           ref rhs_ty,
-                                                           .. }) => {
+            WherePredicate::EqPredicate(WhereEqPredicate { ref lhs_ty, ref rhs_ty, .. }) => {
                 visitor.visit_ty(lhs_ty);
                 visitor.visit_ty(rhs_ty);
             }
@@ -420,9 +418,7 @@
             visitor.visit_ty(ty);
             walk_list!(visitor, visit_impl_item, impl_items);
         }
-        ItemKind::Mac(ref mac) => {
-            visitor.visit_mac(mac)
-        }
+        ItemKind::Mac(ref mac) => visitor.visit_mac(mac),
     }
 }
 
@@ -497,7 +493,7 @@
         }
         ExprKind::Match(ref expr, ref arms) => {
             visitor.visit_expr(expr);
-            for &Arm{ref attrs, ref pats, ref guard, ref body} in arms {
+            for &Arm { ref attrs, ref pats, ref guard, ref body } in arms {
                 walk_list!(visitor, visit_attribute, attrs);
                 walk_list!(visitor, visit_pat, pats);
                 if let Some(ref guard) = *guard {
@@ -563,7 +559,7 @@
         }
         ExprKind::Struct(ref path, ref fields, ref maybe_base) => {
             visitor.visit_path(path);
-            for &FieldValue{ref ident, ref expr, ..} in fields {
+            for &FieldValue { ref ident, ref expr, .. } in fields {
                 visitor.visit_ident(ident);
                 visitor.visit_expr(expr);
             }
@@ -611,7 +607,7 @@
         }
         Pat::Struct(ref path, ref field_pats, _) => {
             visitor.visit_path(path);
-            for &FieldPat{ref ident, ref pat, ..} in field_pats {
+            for &FieldPat { ref ident, ref pat, .. } in field_pats {
                 visitor.visit_ident(ident);
                 visitor.visit_pat(pat);
             }
@@ -657,7 +653,8 @@
 pub fn walk_fn_decl<V: Visitor>(visitor: &mut V, fn_decl: &FnDecl) {
     for input in &fn_decl.inputs {
         match *input {
-            FnArg::SelfRef(_, _) | FnArg::SelfValue(_) => {}
+            FnArg::SelfRef(_, _) |
+            FnArg::SelfValue(_) => {}
             FnArg::Captured(ref pat, ref ty) => {
                 visitor.visit_pat(pat);
                 visitor.visit_ty(ty);
@@ -772,7 +769,7 @@
         }
         ViewPath::List(ref path, ref items) => {
             visitor.visit_path(path);
-            for &PathListItem{ref name, ref rename} in items {
+            for &PathListItem { ref name, ref rename } in items {
                 visitor.visit_ident(name);
                 walk_opt_ident(visitor, rename);
             }