diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs
index dafca7188d5ad..65237a2b17c9e 100644
--- a/src/librustc_front/fold.rs
+++ b/src/librustc_front/fold.rs
@@ -431,14 +431,16 @@ pub fn noop_fold_foreign_mod<T: Folder>(ForeignMod { abi, items }: ForeignMod,
 }
 
 pub fn noop_fold_variant<T: Folder>(v: P<Variant>, fld: &mut T) -> P<Variant> {
-    v.map(|Spanned {node: Variant_ {name, attrs, data, disr_expr}, span}| Spanned {
-        node: Variant_ {
-            name: name,
-            attrs: fold_attrs(attrs, fld),
-            data: fld.fold_variant_data(data),
-            disr_expr: disr_expr.map(|e| fld.fold_expr(e)),
-        },
-        span: fld.new_span(span),
+    v.map(|Spanned { node: Variant_ { name, attrs, data, disr_expr }, span }| {
+        Spanned {
+            node: Variant_ {
+                name: name,
+                attrs: fold_attrs(attrs, fld),
+                data: fld.fold_variant_data(data),
+                disr_expr: disr_expr.map(|e| fld.fold_expr(e)),
+            },
+            span: fld.new_span(span),
+        }
     })
 }
 
@@ -697,12 +699,14 @@ pub fn noop_fold_struct_def<T: Folder>(struct_def: P<VariantData>, fld: &mut T)
     struct_def.map(|vdata| {
         match vdata {
             VariantData::Struct(fields, id) => {
-                VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
+                VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)),
+                                    fld.new_id(id))
             }
             VariantData::Tuple(fields, id) => {
-                VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
+                VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)),
+                                   fld.new_id(id))
             }
-            VariantData::Unit(id) => VariantData::Unit(fld.new_id(id))
+            VariantData::Unit(id) => VariantData::Unit(fld.new_id(id)),
         }
     })
 }
@@ -742,8 +746,7 @@ pub fn noop_fold_struct_field<T: Folder>(f: StructField, fld: &mut T) -> StructF
 
 pub fn noop_fold_field<T: Folder>(Field { name, expr, span }: Field, folder: &mut T) -> Field {
     Field {
-        name: respan(folder.new_span(name.span),
-                     folder.fold_name(name.node)),
+        name: respan(folder.new_span(name.span), folder.fold_name(name.node)),
         expr: folder.fold_expr(expr),
         span: folder.new_span(span),
     }
@@ -814,8 +817,7 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
             ItemStruct(struct_def, folder.fold_generics(generics))
         }
         ItemDefaultImpl(unsafety, ref trait_ref) => {
-            ItemDefaultImpl(unsafety,
-                            folder.fold_trait_ref((*trait_ref).clone()))
+            ItemDefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
         }
         ItemImpl(unsafety, polarity, generics, ifce, ty, impl_items) => {
             let new_impl_items = impl_items.into_iter()
@@ -856,8 +858,7 @@ pub fn noop_fold_trait_item<T: Folder>(i: P<TraitItem>,
             attrs: fold_attrs(attrs, folder),
             node: match node {
                 ConstTraitItem(ty, default) => {
-                    ConstTraitItem(folder.fold_ty(ty),
-                                   default.map(|x| folder.fold_expr(x)))
+                    ConstTraitItem(folder.fold_ty(ty), default.map(|x| folder.fold_expr(x)))
                 }
                 MethodTraitItem(sig, body) => {
                     MethodTraitItem(noop_fold_method_sig(sig, folder),
@@ -885,8 +886,7 @@ pub fn noop_fold_impl_item<T: Folder>(i: P<ImplItem>, folder: &mut T) -> SmallVe
                     ConstImplItem(folder.fold_ty(ty), folder.fold_expr(expr))
                 }
                 MethodImplItem(sig, body) => {
-                    MethodImplItem(noop_fold_method_sig(sig, folder),
-                                   folder.fold_block(body))
+                    MethodImplItem(noop_fold_method_sig(sig, folder), folder.fold_block(body))
                 }
                 TypeImplItem(ty) => TypeImplItem(folder.fold_ty(ty)),
             },
@@ -983,8 +983,7 @@ pub fn noop_fold_foreign_item<T: Folder>(ni: P<ForeignItem>, folder: &mut T) ->
             attrs: fold_attrs(attrs, folder),
             node: match node {
                 ForeignItemFn(fdec, generics) => {
-                    ForeignItemFn(folder.fold_fn_decl(fdec),
-                                  folder.fold_generics(generics))
+                    ForeignItemFn(folder.fold_fn_decl(fdec), folder.fold_generics(generics))
                 }
                 ForeignItemStatic(t, m) => {
                     ForeignItemStatic(folder.fold_ty(t), m)
@@ -1076,12 +1075,10 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span }: Expr, folder: &mut T)
             }
             ExprTup(elts) => ExprTup(elts.move_map(|x| folder.fold_expr(x))),
             ExprCall(f, args) => {
-                ExprCall(folder.fold_expr(f),
-                         args.move_map(|x| folder.fold_expr(x)))
+                ExprCall(folder.fold_expr(f), args.move_map(|x| folder.fold_expr(x)))
             }
             ExprMethodCall(name, tps, args) => {
-                ExprMethodCall(respan(folder.new_span(name.span),
-                                      folder.fold_name(name.node)),
+                ExprMethodCall(respan(folder.new_span(name.span), folder.fold_name(name.node)),
                                tps.move_map(|x| folder.fold_ty(x)),
                                args.move_map(|x| folder.fold_expr(x)))
             }
@@ -1129,13 +1126,11 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span }: Expr, folder: &mut T)
             }
             ExprField(el, name) => {
                 ExprField(folder.fold_expr(el),
-                          respan(folder.new_span(name.span),
-                                 folder.fold_name(name.node)))
+                          respan(folder.new_span(name.span), folder.fold_name(name.node)))
             }
             ExprTupField(el, index) => {
                 ExprTupField(folder.fold_expr(el),
-                             respan(folder.new_span(index.span),
-                                    folder.fold_usize(index.node)))
+                             respan(folder.new_span(index.span), folder.fold_usize(index.node)))
             }
             ExprIndex(el, er) => {
                 ExprIndex(folder.fold_expr(el), folder.fold_expr(er))
@@ -1154,12 +1149,10 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span }: Expr, folder: &mut T)
                 ExprPath(qself, folder.fold_path(path))
             }
             ExprBreak(opt_ident) => ExprBreak(opt_ident.map(|label| {
-                respan(folder.new_span(label.span),
-                       folder.fold_ident(label.node))
+                respan(folder.new_span(label.span), folder.fold_ident(label.node))
             })),
             ExprAgain(opt_ident) => ExprAgain(opt_ident.map(|label| {
-                respan(folder.new_span(label.span),
-                       folder.fold_ident(label.node))
+                respan(folder.new_span(label.span), folder.fold_ident(label.node))
             })),
             ExprRet(e) => ExprRet(e.map(|x| folder.fold_expr(x))),
             ExprInlineAsm(InlineAsm {
diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs
index e62eadaa4387d..790129bcb44e4 100644
--- a/src/librustc_front/hir.rs
+++ b/src/librustc_front/hir.rs
@@ -1073,7 +1073,6 @@ pub type ViewPath = Spanned<ViewPath_>;
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub enum ViewPath_ {
-
     /// `foo::bar::baz as quux`
     ///
     /// or just
@@ -1185,32 +1184,48 @@ pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
 
 impl VariantData {
     pub fn fields(&self) -> FieldIter {
-        fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> { v.iter() }
+        fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> {
+            v.iter()
+        }
         match *self {
             VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => Some(fields),
             _ => None,
-        }.into_iter().flat_map(vec_iter)
+        }
+            .into_iter()
+            .flat_map(vec_iter)
     }
     pub fn id(&self) -> NodeId {
         match *self {
-            VariantData::Struct(_, id) | VariantData::Tuple(_, id) | VariantData::Unit(id) => id
+            VariantData::Struct(_, id) | VariantData::Tuple(_, id) | VariantData::Unit(id) => id,
         }
     }
     pub fn is_struct(&self) -> bool {
-        if let VariantData::Struct(..) = *self { true } else { false }
+        if let VariantData::Struct(..) = *self {
+            true
+        } else {
+            false
+        }
     }
     pub fn is_tuple(&self) -> bool {
-        if let VariantData::Tuple(..) = *self { true } else { false }
+        if let VariantData::Tuple(..) = *self {
+            true
+        } else {
+            false
+        }
     }
     pub fn is_unit(&self) -> bool {
-        if let VariantData::Unit(..) = *self { true } else { false }
+        if let VariantData::Unit(..) = *self {
+            true
+        } else {
+            false
+        }
     }
 }
 
-/*
-  FIXME (#3300): Should allow items to be anonymous. Right now
-  we just use dummy names for anon items.
- */
+//
+// FIXME (#3300): Should allow items to be anonymous. Right now
+// we just use dummy names for anon items.
+//
 /// An item
 ///
 /// The name might be a dummy name in case of anonymous items
@@ -1253,7 +1268,7 @@ pub enum Item_ {
     ItemTrait(Unsafety, Generics, TyParamBounds, Vec<P<TraitItem>>),
 
     // Default trait implementations
-    ///
+    //
     // `impl Trait for .. {}`
     ItemDefaultImpl(Unsafety, TraitRef),
     /// An implementation, eg `impl<A> Trait for Foo { .. }`
diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs
index aeadc763a32d4..dbd05521ec7cd 100644
--- a/src/librustc_front/lowering.rs
+++ b/src/librustc_front/lowering.rs
@@ -114,7 +114,7 @@ impl<'a, 'hir> LoweringContext<'a> {
     fn next_id(&self) -> NodeId {
         let cached = self.cached_id.get();
         if cached == 0 {
-            return self.id_assigner.next_node_id()
+            return self.id_assigner.next_node_id();
         }
 
         self.cached_id.set(cached + 1);
@@ -158,7 +158,7 @@ pub fn lower_view_path(_lctx: &LoweringContext, view_path: &ViewPath) -> P<hir::
                                                                   id: id,
                                                                   name: name.name,
                                                                   rename: rename.map(|x| x.name),
-                                                              },
+                                                              }
                                                               PathListMod { id, rename } =>
                                                                   hir::PathListMod {
                                                                   id: id,
@@ -214,8 +214,7 @@ pub fn lower_ty(_lctx: &LoweringContext, t: &Ty) -> P<hir::Ty> {
             TyVec(ref ty) => hir::TyVec(lower_ty(_lctx, ty)),
             TyPtr(ref mt) => hir::TyPtr(lower_mt(_lctx, mt)),
             TyRptr(ref region, ref mt) => {
-                hir::TyRptr(lower_opt_lifetime(_lctx, region),
-                            lower_mt(_lctx, mt))
+                hir::TyRptr(lower_opt_lifetime(_lctx, region), lower_mt(_lctx, mt))
             }
             TyBareFn(ref f) => {
                 hir::TyBareFn(P(hir::BareFnTy {
@@ -502,13 +501,17 @@ pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P<hir::Var
     P(match *sd {
         VariantData::Struct(ref fields, id) => {
             hir::VariantData::Struct(fields.iter()
-                                           .map(|f| lower_struct_field(_lctx, f)).collect(), id)
+                                           .map(|f| lower_struct_field(_lctx, f))
+                                           .collect(),
+                                     id)
         }
         VariantData::Tuple(ref fields, id) => {
             hir::VariantData::Tuple(fields.iter()
-                                          .map(|f| lower_struct_field(_lctx, f)).collect(), id)
+                                          .map(|f| lower_struct_field(_lctx, f))
+                                          .collect(),
+                                    id)
         }
-        VariantData::Unit(id) => hir::VariantData::Unit(id)
+        VariantData::Unit(id) => hir::VariantData::Unit(id),
     })
 }
 
@@ -676,8 +679,7 @@ pub fn lower_impl_item(_lctx: &LoweringContext, i: &ImplItem) -> P<hir::ImplItem
                 hir::ConstImplItem(lower_ty(_lctx, ty), lower_expr(_lctx, expr))
             }
             MethodImplItem(ref sig, ref body) => {
-                hir::MethodImplItem(lower_method_sig(_lctx, sig),
-                                    lower_block(_lctx, body))
+                hir::MethodImplItem(lower_method_sig(_lctx, sig), lower_block(_lctx, body))
             }
             TypeImplItem(ref ty) => hir::TypeImplItem(lower_ty(_lctx, ty)),
             MacImplItem(..) => panic!("Shouldn't exist any more"),
@@ -743,8 +745,7 @@ pub fn lower_foreign_item(_lctx: &LoweringContext, i: &ForeignItem) -> P<hir::Fo
         attrs: i.attrs.clone(),
         node: match i.node {
             ForeignItemFn(ref fdec, ref generics) => {
-                hir::ForeignItemFn(lower_fn_decl(_lctx, fdec),
-                                   lower_generics(_lctx, generics))
+                hir::ForeignItemFn(lower_fn_decl(_lctx, fdec), lower_generics(_lctx, generics))
             }
             ForeignItemStatic(ref t, m) => {
                 hir::ForeignItemStatic(lower_ty(_lctx, t), m)
@@ -855,8 +856,8 @@ pub fn lower_pat(_lctx: &LoweringContext, p: &Pat) -> P<hir::Pat> {
             }
             PatTup(ref elts) => hir::PatTup(elts.iter().map(|x| lower_pat(_lctx, x)).collect()),
             PatBox(ref inner) => hir::PatBox(lower_pat(_lctx, inner)),
-            PatRegion(ref inner, mutbl) => hir::PatRegion(lower_pat(_lctx, inner),
-                                                          lower_mutability(_lctx, mutbl)),
+            PatRegion(ref inner, mutbl) =>
+                hir::PatRegion(lower_pat(_lctx, inner), lower_mutability(_lctx, mutbl)),
             PatRange(ref e1, ref e2) => {
                 hir::PatRange(lower_expr(_lctx, e1), lower_expr(_lctx, e2))
             }
@@ -1021,11 +1022,12 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
                 //     InPlace::finalize(place)
                 // })
                 let expr = {
-                    let call_move_val_init = hir::StmtSemi(make_call(lctx,
-                                                    &move_val_init,
-                                                    vec![expr_ident(lctx, e.span, p_ptr_ident),
-                                                         pop_unsafe_expr]),
-                                                           lctx.next_id());
+                    let call_move_val_init =
+                        hir::StmtSemi(make_call(lctx,
+                                                &move_val_init,
+                                                vec![expr_ident(lctx, e.span, p_ptr_ident),
+                                                     pop_unsafe_expr]),
+                                      lctx.next_id());
                     let call_move_val_init = respan(e.span, call_move_val_init);
 
                     let call = make_call(lctx,
@@ -1100,14 +1102,10 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
                     }
                 });
 
-                hir::ExprIf(lower_expr(lctx, cond),
-                            lower_block(lctx, blk),
-                            else_opt)
+                hir::ExprIf(lower_expr(lctx, cond), lower_block(lctx, blk), else_opt)
             }
             ExprWhile(ref cond, ref body, opt_ident) => {
-                hir::ExprWhile(lower_expr(lctx, cond),
-                               lower_block(lctx, body),
-                               opt_ident)
+                hir::ExprWhile(lower_expr(lctx, cond), lower_block(lctx, body), opt_ident)
             }
             ExprLoop(ref body, opt_ident) => {
                 hir::ExprLoop(lower_block(lctx, body), opt_ident)
@@ -1132,8 +1130,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
                                   lower_expr(lctx, er))
             }
             ExprField(ref el, ident) => {
-                hir::ExprField(lower_expr(lctx, el),
-                               respan(ident.span, ident.node.name))
+                hir::ExprField(lower_expr(lctx, el), respan(ident.span, ident.node.name))
             }
             ExprTupField(ref el, ident) => {
                 hir::ExprTupField(lower_expr(lctx, el), ident)
@@ -1406,10 +1403,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
                         path_global(e.span, strs)
                     };
 
-                    expr_call(lctx,
-                              e.span,
-                              expr_path(lctx, into_iter_path),
-                              vec![head])
+                    expr_call(lctx, e.span, expr_path(lctx, into_iter_path), vec![head])
                 };
 
                 let match_expr = expr_match(lctx,
@@ -1428,7 +1422,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
                                                           false,
                                                           result_ident,
                                                           match_expr)],
-                                            Some(expr_ident(lctx, e.span, result_ident))))
+                                            Some(expr_ident(lctx, e.span, result_ident))));
             }
 
             ExprMac(_) => panic!("Shouldn't exist here"),
@@ -1532,7 +1526,7 @@ pub fn lower_trait_bound_modifier(_lctx: &LoweringContext,
 
 fn arm(pats: Vec<P<hir::Pat>>, expr: P<hir::Expr>) -> hir::Arm {
     hir::Arm {
-        attrs: vec!(),
+        attrs: vec![],
         pats: pats,
         guard: None,
         body: expr,
@@ -1569,9 +1563,7 @@ fn expr_match(lctx: &LoweringContext,
               arms: Vec<hir::Arm>,
               source: hir::MatchSource)
               -> P<hir::Expr> {
-    expr(lctx,
-         span,
-         hir::ExprMatch(arg, arms, source))
+    expr(lctx, span, hir::ExprMatch(arg, arms, source))
 }
 
 fn expr_block(lctx: &LoweringContext, b: P<hir::Block>) -> P<hir::Expr> {
@@ -1633,7 +1625,7 @@ fn block_all(lctx: &LoweringContext,
 fn pat_some(lctx: &LoweringContext, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
     let some = std_path(lctx, &["option", "Option", "Some"]);
     let path = path_global(span, some);
-    pat_enum(lctx, span, path, vec!(pat))
+    pat_enum(lctx, span, path, vec![pat])
 }
 
 fn pat_none(lctx: &LoweringContext, span: Span) -> P<hir::Pat> {
@@ -1682,7 +1674,7 @@ fn pat(lctx: &LoweringContext, span: Span, pat: hir::Pat_) -> P<hir::Pat> {
 }
 
 fn path_ident(span: Span, id: Ident) -> hir::Path {
-    path(span, vec!(id))
+    path(span, vec![id])
 }
 
 fn path(span: Span, strs: Vec<Ident>) -> hir::Path {
@@ -1730,7 +1722,7 @@ fn std_path(lctx: &LoweringContext, components: &[&str]) -> Vec<Ident> {
         v.push(str_to_ident(s));
     }
     v.extend(components.iter().map(|s| str_to_ident(s)));
-    return v
+    return v;
 }
 
 // Given suffix ["b","c","d"], returns path `::std::b::c::d` when
@@ -1772,9 +1764,7 @@ mod test {
 
     impl MockAssigner {
         fn new() -> MockAssigner {
-            MockAssigner {
-                next_id: Cell::new(0),
-            }
+            MockAssigner { next_id: Cell::new(0) }
         }
     }
 
@@ -1794,14 +1784,18 @@ mod test {
                 expn_id: codemap::NO_EXPANSION,
             }
         }
-        fn cfg(&self) -> ast::CrateConfig { Vec::new() }
+        fn cfg(&self) -> ast::CrateConfig {
+            Vec::new()
+        }
         fn ident_of(&self, st: &str) -> ast::Ident {
             parse::token::str_to_ident(st)
         }
         fn name_of(&self, st: &str) -> ast::Name {
             parse::token::intern(st)
         }
-        fn parse_sess(&self) -> &parse::ParseSess { self }
+        fn parse_sess(&self) -> &parse::ParseSess {
+            self
+        }
     }
 
     impl NodeIdAssigner for MockAssigner {
@@ -1828,11 +1822,20 @@ mod test {
         let cx = parse::ParseSess::new();
         let mut assigner = MockAssigner::new();
 
-        let ast_if_let = quote_expr!(&cx, if let Some(foo) = baz { bar(foo); });
+        let ast_if_let = quote_expr!(&cx,
+                                     if let Some(foo) = baz {
+                                         bar(foo);
+                                     });
         let ast_if_let = assigner.fold_expr(ast_if_let);
-        let ast_while_let = quote_expr!(&cx, while let Some(foo) = baz { bar(foo); });
+        let ast_while_let = quote_expr!(&cx,
+                                        while let Some(foo) = baz {
+                                            bar(foo);
+                                        });
         let ast_while_let = assigner.fold_expr(ast_while_let);
-        let ast_for = quote_expr!(&cx, for i in 0..10 { foo(i); });
+        let ast_for = quote_expr!(&cx,
+                                  for i in 0..10 {
+                                      foo(i);
+                                  });
         let ast_for = assigner.fold_expr(ast_for);
         let ast_in = quote_expr!(&cx, in HEAP { foo() });
         let ast_in = assigner.fold_expr(ast_in);
diff --git a/src/librustc_front/print/pprust.rs b/src/librustc_front/print/pprust.rs
index 5e78aa5fbc1f8..d4950184b0f34 100644
--- a/src/librustc_front/print/pprust.rs
+++ b/src/librustc_front/print/pprust.rs
@@ -750,11 +750,11 @@ impl<'a> State<'a> {
                 try!(self.bclose(item.span));
             }
             hir::ItemImpl(unsafety,
-                          polarity,
-                          ref generics,
-                          ref opt_trait,
-                          ref ty,
-                          ref impl_items) => {
+                         polarity,
+                         ref generics,
+                         ref opt_trait,
+                         ref ty,
+                         ref impl_items) => {
                 try!(self.head(""));
                 try!(self.print_visibility(item.vis));
                 try!(self.print_unsafety(unsafety));
@@ -899,18 +899,16 @@ impl<'a> State<'a> {
         if !struct_def.is_struct() {
             if struct_def.is_tuple() {
                 try!(self.popen());
-                try!(self.commasep_iter(Inconsistent,
-                                   struct_def.fields(),
-                                   |s, field| {
-                                       match field.node.kind {
-                                           hir::NamedField(..) => panic!("unexpected named field"),
-                                           hir::UnnamedField(vis) => {
-                                               try!(s.print_visibility(vis));
-                                               try!(s.maybe_print_comment(field.span.lo));
-                                               s.print_type(&*field.node.ty)
-                                           }
-                                       }
-                                   }));
+                try!(self.commasep_iter(Inconsistent, struct_def.fields(), |s, field| {
+                    match field.node.kind {
+                        hir::NamedField(..) => panic!("unexpected named field"),
+                        hir::UnnamedField(vis) => {
+                            try!(s.print_visibility(vis));
+                            try!(s.maybe_print_comment(field.span.lo));
+                            s.print_type(&*field.node.ty)
+                        }
+                    }
+                }));
                 try!(self.pclose());
             }
             try!(self.print_where_clause(&generics.where_clause));
@@ -1489,44 +1487,37 @@ impl<'a> State<'a> {
                 try!(self.print_string(&a.asm, a.asm_str_style));
                 try!(self.word_space(":"));
 
-                try!(self.commasep(Inconsistent,
-                                   &a.outputs,
-                                   |s, &(ref co, ref o, is_rw)| {
-                                       match co.slice_shift_char() {
-                                           Some(('=', operand)) if is_rw => {
-                                               try!(s.print_string(&format!("+{}", operand),
-                                                                   ast::CookedStr))
-                                           }
-                                           _ => try!(s.print_string(&co, ast::CookedStr)),
-                                       }
-                                       try!(s.popen());
-                                       try!(s.print_expr(&**o));
-                                       try!(s.pclose());
-                                       Ok(())
-                                   }));
+                try!(self.commasep(Inconsistent, &a.outputs, |s, &(ref co, ref o, is_rw)| {
+                    match co.slice_shift_char() {
+                        Some(('=', operand)) if is_rw => {
+                            try!(s.print_string(&format!("+{}", operand), ast::CookedStr))
+                        }
+                        _ => try!(s.print_string(&co, ast::CookedStr)),
+                    }
+                    try!(s.popen());
+                    try!(s.print_expr(&**o));
+                    try!(s.pclose());
+                    Ok(())
+                }));
                 try!(space(&mut self.s));
                 try!(self.word_space(":"));
 
-                try!(self.commasep(Inconsistent,
-                                   &a.inputs,
-                                   |s, &(ref co, ref o)| {
-                                       try!(s.print_string(&co, ast::CookedStr));
-                                       try!(s.popen());
-                                       try!(s.print_expr(&**o));
-                                       try!(s.pclose());
-                                       Ok(())
-                                   }));
+                try!(self.commasep(Inconsistent, &a.inputs, |s, &(ref co, ref o)| {
+                    try!(s.print_string(&co, ast::CookedStr));
+                    try!(s.popen());
+                    try!(s.print_expr(&**o));
+                    try!(s.pclose());
+                    Ok(())
+                }));
                 try!(space(&mut self.s));
                 try!(self.word_space(":"));
 
-                try!(self.commasep(Inconsistent,
-                                   &a.clobbers,
-                                   |s, co| {
-                                       try!(s.print_string(&co, ast::CookedStr));
-                                       Ok(())
-                                   }));
+                try!(self.commasep(Inconsistent, &a.clobbers, |s, co| {
+                    try!(s.print_string(&co, ast::CookedStr));
+                    Ok(())
+                }));
 
-                let mut options = vec!();
+                let mut options = vec![];
                 if a.volatile {
                     options.push("volatile");
                 }
@@ -1540,12 +1531,10 @@ impl<'a> State<'a> {
                 if !options.is_empty() {
                     try!(space(&mut self.s));
                     try!(self.word_space(":"));
-                    try!(self.commasep(Inconsistent,
-                                       &*options,
-                                       |s, &co| {
-                                           try!(s.print_string(co, ast::CookedStr));
-                                           Ok(())
-                                       }));
+                    try!(self.commasep(Inconsistent, &*options, |s, &co| {
+                        try!(s.print_string(co, ast::CookedStr));
+                        Ok(())
+                    }));
                 }
 
                 try!(self.pclose());
@@ -1610,7 +1599,7 @@ impl<'a> State<'a> {
         try!(self.maybe_print_comment(path.span.lo));
 
         let mut first = !path.global;
-        for segment in &path.segments[..path.segments.len()-depth] {
+        for segment in &path.segments[..path.segments.len() - depth] {
             if first {
                 first = false
             } else {
@@ -1694,9 +1683,7 @@ impl<'a> State<'a> {
 
             hir::ParenthesizedParameters(ref data) => {
                 try!(word(&mut self.s, "("));
-                try!(self.commasep(Inconsistent,
-                                   &data.inputs,
-                                   |s, ty| s.print_type(&**ty)));
+                try!(self.commasep(Inconsistent, &data.inputs, |s, ty| s.print_type(&**ty)));
                 try!(word(&mut self.s, ")"));
 
                 match data.output {
@@ -1716,8 +1703,8 @@ impl<'a> State<'a> {
     pub fn print_pat(&mut self, pat: &hir::Pat) -> io::Result<()> {
         try!(self.maybe_print_comment(pat.span.lo));
         try!(self.ann.pre(self, NodePat(pat)));
-        /* Pat isn't normalized, but the beauty of it
-         is that it doesn't matter */
+        // Pat isn't normalized, but the beauty of it
+        // is that it doesn't matter
         match pat.node {
             hir::PatWild(hir::PatWildSingle) => try!(word(&mut self.s, "_")),
             hir::PatWild(hir::PatWildMulti) => try!(word(&mut self.s, "..")),
@@ -2070,18 +2057,16 @@ impl<'a> State<'a> {
             ints.push(i);
         }
 
-        try!(self.commasep(Inconsistent,
-                           &ints[..],
-                           |s, &idx| {
-                               if idx < generics.lifetimes.len() {
-                                   let lifetime = &generics.lifetimes[idx];
-                                   s.print_lifetime_def(lifetime)
-                               } else {
-                                   let idx = idx - generics.lifetimes.len();
-                                   let param = &generics.ty_params[idx];
-                                   s.print_ty_param(param)
-                               }
-                           }));
+        try!(self.commasep(Inconsistent, &ints[..], |s, &idx| {
+            if idx < generics.lifetimes.len() {
+                let lifetime = &generics.lifetimes[idx];
+                s.print_lifetime_def(lifetime)
+            } else {
+                let idx = idx - generics.lifetimes.len();
+                let param = &generics.ty_params[idx];
+                s.print_ty_param(param)
+            }
+        }));
 
         try!(word(&mut self.s, ">"));
         Ok(())
@@ -2102,7 +2087,7 @@ impl<'a> State<'a> {
 
     pub fn print_where_clause(&mut self, where_clause: &hir::WhereClause) -> io::Result<()> {
         if where_clause.predicates.is_empty() {
-            return Ok(())
+            return Ok(());
         }
 
         try!(space(&mut self.s));
@@ -2174,18 +2159,16 @@ impl<'a> State<'a> {
                     try!(self.print_path(path, false, 0));
                     try!(word(&mut self.s, "::{"));
                 }
-                try!(self.commasep(Inconsistent,
-                                   &segments[..],
-                                   |s, w| {
-                                       match w.node {
-                                           hir::PathListIdent { name, .. } => {
-                                               s.print_name(name)
-                                           }
-                                           hir::PathListMod { .. } => {
-                                               word(&mut s.s, "self")
-                                           }
-                                       }
-                                   }));
+                try!(self.commasep(Inconsistent, &segments[..], |s, w| {
+                    match w.node {
+                        hir::PathListIdent { name, .. } => {
+                            s.print_name(name)
+                        }
+                        hir::PathListMod { .. } => {
+                            word(&mut s.s, "self")
+                        }
+                    }
+                }));
                 word(&mut self.s, "}")
             }
         }
@@ -2290,7 +2273,7 @@ impl<'a> State<'a> {
         match self.next_comment() {
             Some(ref cmnt) => {
                 if (*cmnt).style != comments::Trailing {
-                    return Ok(())
+                    return Ok(());
                 }
                 let span_line = cm.lookup_char_pos(span.hi);
                 let comment_line = cm.lookup_char_pos((*cmnt).pos);
diff --git a/src/librustc_front/util.rs b/src/librustc_front/util.rs
index 5d8973ead47db..c679456d469ed 100644
--- a/src/librustc_front/util.rs
+++ b/src/librustc_front/util.rs
@@ -175,7 +175,7 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O>
     fn visit_item(&mut self, item: &Item) {
         if !self.pass_through_items {
             if self.visited_outermost {
-                return
+                return;
             } else {
                 self.visited_outermost = true
             }
@@ -282,11 +282,11 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O>
     }
 
     fn visit_variant_data(&mut self,
-                        struct_def: &VariantData,
-                        _: Name,
-                        _: &hir::Generics,
-                        _: NodeId,
-                        _: Span) {
+                          struct_def: &VariantData,
+                          _: Name,
+                          _: &hir::Generics,
+                          _: NodeId,
+                          _: Span) {
         self.operation.visit_id(struct_def.id());
         visit::walk_struct_def(self, struct_def);
     }
diff --git a/src/librustc_front/visit.rs b/src/librustc_front/visit.rs
index 547651bef8670..aaa8e09f499f0 100644
--- a/src/librustc_front/visit.rs
+++ b/src/librustc_front/visit.rs
@@ -112,15 +112,22 @@ pub trait Visitor<'v> : Sized {
     fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef, m: &'v TraitBoundModifier) {
         walk_poly_trait_ref(self, t, m)
     }
-    fn visit_variant_data(&mut self, s: &'v VariantData, _: Name,
-                        _: &'v Generics, _: NodeId, _: Span) {
+    fn visit_variant_data(&mut self,
+                          s: &'v VariantData,
+                          _: Name,
+                          _: &'v Generics,
+                          _: NodeId,
+                          _: Span) {
         walk_struct_def(self, s)
     }
     fn visit_struct_field(&mut self, s: &'v StructField) {
         walk_struct_field(self, s)
     }
-    fn visit_enum_def(&mut self, enum_definition: &'v EnumDef,
-                      generics: &'v Generics, item_id: NodeId, _: Span) {
+    fn visit_enum_def(&mut self,
+                      enum_definition: &'v EnumDef,
+                      generics: &'v Generics,
+                      item_id: NodeId,
+                      _: Span) {
         walk_enum_def(self, enum_definition, generics, item_id)
     }
     fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics, item_id: NodeId) {
@@ -226,9 +233,7 @@ pub fn walk_poly_trait_ref<'v, V>(visitor: &mut V,
                                   _modifier: &'v TraitBoundModifier)
     where V: Visitor<'v>
 {
-    walk_list!(visitor,
-               visit_lifetime_def,
-               &trait_ref.bound_lifetimes);
+    walk_list!(visitor, visit_lifetime_def, &trait_ref.bound_lifetimes);
     visitor.visit_trait_ref(&trait_ref.trait_ref);
 }
 
@@ -298,11 +303,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
         ItemDefaultImpl(_, ref trait_ref) => {
             visitor.visit_trait_ref(trait_ref)
         }
-        ItemImpl(_, _,
-                 ref type_parameters,
-                 ref opt_trait_reference,
-                 ref typ,
-                 ref impl_items) => {
+        ItemImpl(_, _, ref type_parameters, ref opt_trait_reference, ref typ, ref impl_items) => {
             visitor.visit_generics(type_parameters);
             walk_list!(visitor, visit_trait_ref, opt_trait_reference);
             visitor.visit_ty(typ);
@@ -310,8 +311,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
         }
         ItemStruct(ref struct_definition, ref generics) => {
             visitor.visit_generics(generics);
-            visitor.visit_variant_data(struct_definition, item.name,
-                                     generics, item.id, item.span);
+            visitor.visit_variant_data(struct_definition, item.name, generics, item.id, item.span);
         }
         ItemTrait(_, ref generics, ref bounds, ref methods) => {
             visitor.visit_generics(generics);
@@ -326,7 +326,11 @@ pub fn walk_enum_def<'v, V: Visitor<'v>>(visitor: &mut V,
                                          enum_definition: &'v EnumDef,
                                          generics: &'v Generics,
                                          item_id: NodeId) {
-    walk_list!(visitor, visit_variant, &enum_definition.variants, generics, item_id);
+    walk_list!(visitor,
+               visit_variant,
+               &enum_definition.variants,
+               generics,
+               item_id);
 }
 
 pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V,
@@ -334,8 +338,11 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V,
                                         generics: &'v Generics,
                                         item_id: NodeId) {
     visitor.visit_name(variant.span, variant.node.name);
-    visitor.visit_variant_data(&variant.node.data, variant.node.name,
-                             generics, item_id, variant.span);
+    visitor.visit_variant_data(&variant.node.data,
+                               variant.node.name,
+                               generics,
+                               item_id,
+                               variant.span);
     walk_list!(visitor, visit_expr, &variant.node.disr_expr);
     walk_list!(visitor, visit_attribute, &variant.node.attrs);
 }
@@ -357,9 +364,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
         }
         TyBareFn(ref function_declaration) => {
             walk_fn_decl(visitor, &function_declaration.decl);
-            walk_list!(visitor,
-                       visit_lifetime_def,
-                       &function_declaration.lifetimes);
+            walk_list!(visitor, visit_lifetime_def, &function_declaration.lifetimes);
         }
         TyPath(ref maybe_qself, ref path) => {
             if let Some(ref qself) = *maybe_qself {