diff --git a/.travis.yml b/.travis.yml
index 052a543bfd57..3c226c879f26 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -24,8 +24,9 @@ install:
 script:
  - remark -f README.md > /dev/null
  - python util/update_lints.py -c
- - PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff
  - set -e
+ - PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff
+ - cd clippy_lints && PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff && cd ..
  - cargo build --features debugging
  - cargo test --features debugging
  - mkdir -p ~/rust/cargo/bin
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 3ccb5f6ef2a0..7131e609715b 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -85,7 +85,9 @@ fn check_known_consts(cx: &LateContext, e: &Expr, s: &symbol::Symbol, module: &s
                           APPROX_CONSTANT,
                           e.span,
                           &format!("approximate value of `{}::consts::{}` found. \
-                                    Consider using it directly", module, &name));
+                                    Consider using it directly",
+                                   module,
+                                   &name));
                 return;
             }
         }
diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs
index 5020295e20c9..109f045b619b 100644
--- a/clippy_lints/src/arithmetic.rs
+++ b/clippy_lints/src/arithmetic.rs
@@ -67,7 +67,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
                     span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
                     self.span = Some(expr.span);
                 }
-            }
+            },
             hir::ExprUnary(hir::UnOp::UnNeg, ref arg) => {
                 let ty = cx.tcx.tables().expr_ty(arg);
                 if ty.is_integral() {
@@ -77,7 +77,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
                     span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
                     self.span = Some(expr.span);
                 }
-            }
+            },
             _ => (),
         }
     }
diff --git a/clippy_lints/src/array_indexing.rs b/clippy_lints/src/array_indexing.rs
index 399f93d08c7c..de13c0264e50 100644
--- a/clippy_lints/src/array_indexing.rs
+++ b/clippy_lints/src/array_indexing.rs
@@ -107,9 +107,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing {
 }
 
 /// Returns an option containing a tuple with the start and end (exclusive) of the range.
-fn to_const_range(start: Option<Option<ConstVal>>, end: Option<Option<ConstVal>>, limits: RangeLimits,
-                  array_size: ConstInt)
-                  -> Option<(ConstInt, ConstInt)> {
+fn to_const_range(
+    start: Option<Option<ConstVal>>,
+    end: Option<Option<ConstVal>>,
+    limits: RangeLimits,
+    array_size: ConstInt
+) -> Option<(ConstInt, ConstInt)> {
     let start = match start {
         Some(Some(ConstVal::Integral(x))) => x,
         Some(_) => return None,
@@ -123,7 +126,7 @@ fn to_const_range(start: Option<Option<ConstVal>>, end: Option<Option<ConstVal>>
             } else {
                 x
             }
-        }
+        },
         Some(_) => return None,
         None => array_size,
     };
diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 5f5cddc64714..122a600d7d38 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -95,13 +95,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                                                expr.span,
                                                "variable appears on both sides of an assignment operation",
                                                |db| {
-                                                   if let (Some(snip_a), Some(snip_r)) = (snippet_opt(cx, assignee.span),
-                                                                                          snippet_opt(cx, rhs.span)) {
-                                                       db.span_suggestion(expr.span,
-                                                                          "replace it with",
-                                                                          format!("{} {}= {}", snip_a, op.node.as_str(), snip_r));
-                                                   }
-                                               });
+                                if let (Some(snip_a), Some(snip_r)) =
+                                    (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span)) {
+                                    db.span_suggestion(expr.span,
+                                                       "replace it with",
+                                                       format!("{} {}= {}", snip_a, op.node.as_str(), snip_r));
+                                }
+                            });
                         };
                         // lhs op= l op r
                         if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs, l) {
@@ -113,7 +113,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                         }
                     }
                 }
-            }
+            },
             hir::ExprAssign(ref assignee, ref e) => {
                 if let hir::ExprBinary(op, ref l, ref r) = e.node {
                     let lint = |assignee: &hir::Expr, rhs: &hir::Expr| {
@@ -126,7 +126,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                             return; // implements_trait does not work with generics
                         }
                         macro_rules! ops {
-                            ($op:expr, $cx:expr, $ty:expr, $rty:expr, $($trait_name:ident:$full_trait_name:ident),+) => {
+                            ($op:expr,
+                             $cx:expr,
+                             $ty:expr,
+                             $rty:expr,
+                             $($trait_name:ident:$full_trait_name:ident),+) => {
                                 match $op {
                                     $(hir::$full_trait_name => {
                                         let [krate, module] = ::utils::paths::OPS_MODULE;
@@ -140,15 +144,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                                         let parent_fn = cx.tcx.map.get_parent(e.id);
                                         let parent_impl = cx.tcx.map.get_parent(parent_fn);
                                         // the crate node is the only one that is not in the map
-                                        if parent_impl != ast::CRATE_NODE_ID {
-                                            if let hir::map::Node::NodeItem(item) = cx.tcx.map.get(parent_impl) {
-                                                if let hir::Item_::ItemImpl(_, _, _, Some(ref trait_ref), _, _) = item.node {
-                                                    if trait_ref.path.def.def_id() == trait_id {
-                                                        return;
-                                                    }
-                                                }
-                                            }
-                                        }
+                                        if_let_chain!{[
+                                            parent_impl != ast::CRATE_NODE_ID,
+                                            let hir::map::Node::NodeItem(item) = cx.tcx.map.get(parent_impl),
+                                            let hir::Item_::ItemImpl(_, _, _, Some(ref trait_ref), _, _) = item.node,
+                                            trait_ref.path.def.def_id() == trait_id
+                                        ], { return; }}
                                         implements_trait($cx, $ty, trait_id, vec![$rty])
                                     },)*
                                     _ => false,
@@ -176,13 +177,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                                                expr.span,
                                                "manual implementation of an assign operation",
                                                |db| {
-                                                   if let (Some(snip_a), Some(snip_r)) = (snippet_opt(cx, assignee.span),
-                                                                                          snippet_opt(cx, rhs.span)) {
-                                                       db.span_suggestion(expr.span,
-                                                                          "replace it with",
-                                                                          format!("{} {}= {}", snip_a, op.node.as_str(), snip_r));
-                                                   }
-                                               });
+                                if let (Some(snip_a), Some(snip_r)) =
+                                    (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span)) {
+                                    db.span_suggestion(expr.span,
+                                                       "replace it with",
+                                                       format!("{} {}= {}", snip_a, op.node.as_str(), snip_r));
+                                }
+                            });
                         }
                     };
                     // a = a op b
@@ -195,13 +196,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                             hir::BiAdd | hir::BiMul | hir::BiAnd | hir::BiOr | hir::BiBitXor | hir::BiBitAnd |
                             hir::BiBitOr => {
                                 lint(assignee, l);
-                            }
-                            _ => {}
+                            },
+                            _ => {},
                         }
                     }
                 }
-            }
-            _ => {}
+            },
+            _ => {},
         }
     }
 }
@@ -209,23 +210,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
 fn is_commutative(op: hir::BinOp_) -> bool {
     use rustc::hir::BinOp_::*;
     match op {
-        BiAdd |
-        BiMul |
-        BiAnd |
-        BiOr |
-        BiBitXor |
-        BiBitAnd |
-        BiBitOr |
-        BiEq |
-        BiNe => true,
-        BiSub |
-        BiDiv |
-        BiRem |
-        BiShl |
-        BiShr |
-        BiLt |
-        BiLe |
-        BiGe |
-        BiGt => false,
+        BiAdd | BiMul | BiAnd | BiOr | BiBitXor | BiBitAnd | BiBitOr | BiEq | BiNe => true,
+        BiSub | BiDiv | BiRem | BiShl | BiShr | BiLt | BiLe | BiGe | BiGt => false,
     }
 }
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index a37b08363957..24fd5a1483da 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -36,9 +36,11 @@ declare_lint! {
 
 /// **What it does:** Checks for `extern crate` and `use` items annotated with lint attributes
 ///
-/// **Why is this bad?** Lint attributes have no effect on crate imports. Most likely a `!` was forgotten
+/// **Why is this bad?** Lint attributes have no effect on crate imports. Most likely a `!` was
+/// forgotten
 ///
-/// **Known problems:** Technically one might allow `unused_import` on a `use` item, but it's easier to remove the unused item.
+/// **Known problems:** Technically one might allow `unused_import` on a `use` item,
+/// but it's easier to remove the unused item.
 ///
 /// **Example:**
 /// ```rust
@@ -120,7 +122,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass {
                                 }
                                 if let Some(mut sugg) = snippet_opt(cx, attr.span) {
                                     if sugg.len() > 1 {
-                                        span_lint_and_then(cx, USELESS_ATTRIBUTE, attr.span,
+                                        span_lint_and_then(cx,
+                                                           USELESS_ATTRIBUTE,
+                                                           attr.span,
                                                            "useless lint attribute",
                                                            |db| {
                                             sugg.insert(1, '!');
@@ -181,7 +185,7 @@ fn is_relevant_block(cx: &LateContext, block: &Block) -> bool {
             StmtExpr(ref expr, _) |
             StmtSemi(ref expr, _) => {
                 return is_relevant_expr(cx, expr);
-            }
+            },
         }
     }
     block.expr.as_ref().map_or(false, |e| is_relevant_expr(cx, e))
@@ -191,7 +195,8 @@ fn is_relevant_expr(cx: &LateContext, expr: &Expr) -> bool {
     match expr.node {
         ExprBlock(ref block) => is_relevant_block(cx, block),
         ExprRet(Some(ref e)) => is_relevant_expr(cx, e),
-        ExprRet(None) | ExprBreak(_, None) => false,
+        ExprRet(None) |
+        ExprBreak(_, None) => false,
         ExprCall(ref path_expr, _) => {
             if let ExprPath(ref qpath) = path_expr.node {
                 let fun_id = resolve_node(cx, qpath, path_expr.id).def_id();
@@ -199,7 +204,7 @@ fn is_relevant_expr(cx: &LateContext, expr: &Expr) -> bool {
             } else {
                 true
             }
-        }
+        },
         _ => true,
     }
 }
diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index 0e569bc76f7b..5b860d8cedc7 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -134,7 +134,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value:
                     } else if mask_value == 0 {
                         span_lint(cx, BAD_BIT_MASK, *span, "&-masking with zero");
                     }
-                }
+                },
                 BiBitOr => {
                     if mask_value | cmp_value != cmp_value {
                         span_lint(cx,
@@ -144,10 +144,10 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value:
                                            mask_value,
                                            cmp_value));
                     }
-                }
+                },
                 _ => (),
             }
-        }
+        },
         BiLt | BiGe => {
             match bit_op {
                 BiBitAnd => {
@@ -161,7 +161,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value:
                     } else if mask_value == 0 {
                         span_lint(cx, BAD_BIT_MASK, *span, "&-masking with zero");
                     }
-                }
+                },
                 BiBitOr => {
                     if mask_value >= cmp_value {
                         span_lint(cx,
@@ -173,11 +173,11 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value:
                     } else {
                         check_ineffective_lt(cx, *span, mask_value, cmp_value, "|");
                     }
-                }
+                },
                 BiBitXor => check_ineffective_lt(cx, *span, mask_value, cmp_value, "^"),
                 _ => (),
             }
-        }
+        },
         BiLe | BiGt => {
             match bit_op {
                 BiBitAnd => {
@@ -191,7 +191,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value:
                     } else if mask_value == 0 {
                         span_lint(cx, BAD_BIT_MASK, *span, "&-masking with zero");
                     }
-                }
+                },
                 BiBitOr => {
                     if mask_value > cmp_value {
                         span_lint(cx,
@@ -203,11 +203,11 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value:
                     } else {
                         check_ineffective_gt(cx, *span, mask_value, cmp_value, "|");
                     }
-                }
+                },
                 BiBitXor => check_ineffective_gt(cx, *span, mask_value, cmp_value, "^"),
                 _ => (),
             }
-        }
+        },
         _ => (),
     }
 }
@@ -244,7 +244,7 @@ fn fetch_int_literal(cx: &LateContext, lit: &Expr) -> Option<u64> {
             } else {
                 None
             }
-        }
+        },
         ExprPath(ref qpath) => {
             let def = cx.tcx.tables().qpath_def(qpath, lit.id);
             if let Def::Const(def_id) = def {
@@ -252,7 +252,7 @@ fn fetch_int_literal(cx: &LateContext, lit: &Expr) -> Option<u64> {
             } else {
                 None
             }
-        }
+        },
         _ => None,
     }
 }
diff --git a/clippy_lints/src/block_in_if_condition.rs b/clippy_lints/src/block_in_if_condition.rs
index de004afa1a6c..2f9a6b161585 100644
--- a/clippy_lints/src/block_in_if_condition.rs
+++ b/clippy_lints/src/block_in_if_condition.rs
@@ -110,7 +110,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition {
                     }
                 }
             } else {
-                let mut visitor = ExVisitor { found_block: None, cx: cx };
+                let mut visitor = ExVisitor {
+                    found_block: None,
+                    cx: cx,
+                };
                 walk_expr(&mut visitor, check);
                 if let Some(block) = visitor.found_block {
                     span_lint(cx, BLOCK_IN_IF_CONDITION_STMT, block.span, COMPLEX_BLOCK_MESSAGE);
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index bd5657483112..979b62f8ce7e 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -94,14 +94,14 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
                         BiAnd => return Ok(Bool::And(self.extract(BiAnd, &[lhs, rhs], Vec::new())?)),
                         _ => (),
                     }
-                }
+                },
                 ExprLit(ref lit) => {
                     match lit.node {
                         LitKind::Bool(true) => return Ok(Bool::True),
                         LitKind::Bool(false) => return Ok(Bool::False),
                         _ => (),
                     }
-                }
+                },
                 _ => (),
             }
         }
@@ -129,7 +129,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
                         BiLe => mk_expr(BiGt),
                         _ => continue,
                     }
-                }
+                },
                 _ => continue,
             };
             if SpanlessEq::new(self.cx).ignore_fn().eq_expr(&negated, expr) {
@@ -156,17 +156,17 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String {
             True => {
                 s.push_str("true");
                 s
-            }
+            },
             False => {
                 s.push_str("false");
                 s
-            }
+            },
             Not(ref inner) => {
                 match **inner {
                     And(_) | Or(_) => {
                         s.push('!');
                         recurse(true, cx, inner, terminals, s)
-                    }
+                    },
                     Term(n) => {
                         if let ExprBinary(binop, ref lhs, ref rhs) = terminals[n as usize].node {
                             let op = match binop.node {
@@ -179,7 +179,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String {
                                 _ => {
                                     s.push('!');
                                     return recurse(true, cx, inner, terminals, s);
-                                }
+                                },
                             };
                             s.push_str(&snip(lhs));
                             s.push_str(op);
@@ -189,13 +189,13 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String {
                             s.push('!');
                             recurse(false, cx, inner, terminals, s)
                         }
-                    }
+                    },
                     _ => {
                         s.push('!');
                         recurse(false, cx, inner, terminals, s)
-                    }
+                    },
                 }
-            }
+            },
             And(ref v) => {
                 if brackets {
                     s.push('(');
@@ -217,7 +217,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String {
                     s.push(')');
                 }
                 s
-            }
+            },
             Or(ref v) => {
                 if brackets {
                     s.push('(');
@@ -231,7 +231,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String {
                     s.push(')');
                 }
                 s
-            }
+            },
             Term(n) => {
                 if brackets {
                     if let ExprBinary(..) = terminals[n as usize].node {
@@ -245,7 +245,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String {
                     }
                 }
                 s
-            }
+            },
         }
     }
     recurse(false, cx, suggestion, terminals, String::new())
@@ -262,13 +262,13 @@ fn simple_negate(b: Bool) -> Bool {
                 *el = simple_negate(::std::mem::replace(el, True));
             }
             Or(v)
-        }
+        },
         Or(mut v) => {
             for el in &mut v {
                 *el = simple_negate(::std::mem::replace(el, True));
             }
             And(v)
-        }
+        },
         Not(inner) => *inner,
     }
 }
@@ -290,13 +290,13 @@ fn terminal_stats(b: &Bool) -> Stats {
                     _ => stats.negations += 1,
                 }
                 recurse(inner, stats);
-            }
+            },
             And(ref v) | Or(ref v) => {
                 stats.ops += v.len() - 1;
                 for inner in v {
                     recurse(inner, stats);
                 }
-            }
+            },
             Term(n) => stats.terminals[n as usize] += 1,
         }
     }
@@ -325,7 +325,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
             let mut simplified = expr.simplify();
             for simple in Bool::Not(Box::new(expr.clone())).simplify() {
                 match simple {
-                    Bool::Not(_) | Bool::True | Bool::False => {}
+                    Bool::Not(_) | Bool::True | Bool::False => {},
                     _ => simplified.push(Bool::Not(Box::new(simple.clone()))),
                 }
                 let simple_negated = simple_negate(simple);
@@ -399,7 +399,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
                 } else {
                     walk_expr(self, e);
                 }
-            }
+            },
             _ => walk_expr(self, e),
         }
     }
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 9d23d32c81ae..85bd419df732 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -2,7 +2,7 @@
 //!
 //! For example, the lint would catch:
 //!
-//! ```rust
+//! ```rust,ignore
 //! if x {
 //!     if y {
 //!         println!("Hello world");
@@ -28,7 +28,7 @@ use utils::sugg::Sugg;
 /// **Known problems:** None.
 ///
 /// **Example:**
-/// ```rust
+/// ```rust,ignore
 /// if x {
 ///     if y {
 ///         …
@@ -48,7 +48,7 @@ use utils::sugg::Sugg;
 ///
 /// Should be written:
 ///
-/// ```rust
+/// ```rust.ignore
 /// if x && y {
 ///     …
 /// }
@@ -92,10 +92,10 @@ fn check_if(cx: &EarlyContext, expr: &ast::Expr) {
             } else {
                 check_collapsible_no_if_let(cx, expr, check, then);
             }
-        }
+        },
         ast::ExprKind::IfLet(_, _, _, Some(ref else_)) => {
             check_collapsible_maybe_if_let(cx, else_);
-        }
+        },
         _ => (),
     }
 }
@@ -120,12 +120,7 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext, else_: &ast::Expr) {
     }}
 }
 
-fn check_collapsible_no_if_let(
-    cx: &EarlyContext,
-    expr: &ast::Expr,
-    check: &ast::Expr,
-    then: &ast::Block,
-) {
+fn check_collapsible_no_if_let(cx: &EarlyContext, expr: &ast::Expr, check: &ast::Expr, then: &ast::Block) {
     if_let_chain! {[
         let Some(inner) = expr_block(then),
         let ast::ExprKind::If(ref check_inner, ref content, None) = inner.node,
@@ -145,13 +140,14 @@ fn check_collapsible_no_if_let(
     }}
 }
 
-/// If the block contains only one expression, returns it.
+/// If the block contains only one expression, return it.
 fn expr_block(block: &ast::Block) -> Option<&ast::Expr> {
     let mut it = block.stmts.iter();
 
     if let (Some(stmt), None) = (it.next(), it.next()) {
         match stmt.node {
-            ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => Some(expr),
+            ast::StmtKind::Expr(ref expr) |
+            ast::StmtKind::Semi(ref expr) => Some(expr),
             _ => None,
         }
     } else {
diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
index afbf9666b10a..44288e7d7fcd 100644
--- a/clippy_lints/src/consts.rs
+++ b/clippy_lints/src/consts.rs
@@ -75,18 +75,16 @@ impl PartialEq for Constant {
             (&Constant::Char(l), &Constant::Char(r)) => l == r,
             (&Constant::Int(l), &Constant::Int(r)) => {
                 l.is_negative() == r.is_negative() && l.to_u64_unchecked() == r.to_u64_unchecked()
-            }
+            },
             (&Constant::Float(ref ls, _), &Constant::Float(ref rs, _)) => {
                 // we want `Fw32 == FwAny` and `FwAny == Fw64`, by transitivity we must have
                 // `Fw32 == Fw64` so don’t compare them
                 match (ls.parse::<f64>(), rs.parse::<f64>()) {
                     // mem::transmute is required to catch non-matching 0.0, -0.0, and NaNs
-                    (Ok(l), Ok(r)) => unsafe {
-                        mem::transmute::<f64, u64>(l) == mem::transmute::<f64, u64>(r)
-                    },
+                    (Ok(l), Ok(r)) => unsafe { mem::transmute::<f64, u64>(l) == mem::transmute::<f64, u64>(r) },
                     _ => false,
                 }
-            }
+            },
             (&Constant::Bool(l), &Constant::Bool(r)) => l == r,
             (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l == r,
             (&Constant::Repeat(ref lv, ref ls), &Constant::Repeat(ref rv, ref rs)) => ls == rs && lv == rv,
@@ -104,34 +102,34 @@ impl Hash for Constant {
             Constant::Str(ref s, ref k) => {
                 s.hash(state);
                 k.hash(state);
-            }
+            },
             Constant::Binary(ref b) => {
                 b.hash(state);
-            }
+            },
             Constant::Char(c) => {
                 c.hash(state);
-            }
+            },
             Constant::Int(i) => {
                 i.to_u64_unchecked().hash(state);
                 i.is_negative().hash(state);
-            }
+            },
             Constant::Float(ref f, _) => {
                 // don’t use the width here because of PartialEq implementation
                 if let Ok(f) = f.parse::<f64>() {
                     unsafe { mem::transmute::<f64, u64>(f) }.hash(state);
                 }
-            }
+            },
             Constant::Bool(b) => {
                 b.hash(state);
-            }
+            },
             Constant::Vec(ref v) |
             Constant::Tuple(ref v) => {
                 v.hash(state);
-            }
+            },
             Constant::Repeat(ref c, l) => {
                 c.hash(state);
                 l.hash(state);
-            }
+            },
         }
     }
 }
@@ -145,19 +143,21 @@ impl PartialOrd for Constant {
                 } else {
                     None
                 }
-            }
+            },
             (&Constant::Char(ref l), &Constant::Char(ref r)) => Some(l.cmp(r)),
             (&Constant::Int(l), &Constant::Int(r)) => Some(l.cmp(&r)),
             (&Constant::Float(ref ls, _), &Constant::Float(ref rs, _)) => {
                 match (ls.parse::<f64>(), rs.parse::<f64>()) {
-                    (Ok(ref l), Ok(ref r)) => match (l.partial_cmp(r), l.is_sign_positive() == r.is_sign_positive()) {
-                        // Check for comparison of -0.0 and 0.0
-                        (Some(Ordering::Equal), false) => None,
-                        (x, _) => x
+                    (Ok(ref l), Ok(ref r)) => {
+                        match (l.partial_cmp(r), l.is_sign_positive() == r.is_sign_positive()) {
+                            // Check for comparison of -0.0 and 0.0
+                            (Some(Ordering::Equal), false) => None,
+                            (x, _) => x,
+                        }
                     },
                     _ => None,
                 }
-            }
+            },
             (&Constant::Bool(ref l), &Constant::Bool(ref r)) => Some(l.cmp(r)),
             (&Constant::Tuple(ref l), &Constant::Tuple(ref r)) |
             (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l.partial_cmp(r),
@@ -166,7 +166,7 @@ impl PartialOrd for Constant {
                     Some(Equal) => Some(ls.cmp(rs)),
                     x => x,
                 }
-            }
+            },
             _ => None, //TODO: Are there any useful inter-type orderings?
         }
     }
@@ -187,14 +187,14 @@ pub fn lit_to_constant(lit: &LitKind) -> Constant {
         LitKind::Int(value, LitIntType::Unsigned(UintTy::U64)) => Constant::Int(ConstInt::U64(value as u64)),
         LitKind::Int(value, LitIntType::Unsigned(UintTy::Us)) => {
             Constant::Int(ConstInt::Usize(ConstUsize::Us32(value as u32)))
-        }
+        },
         LitKind::Int(value, LitIntType::Signed(IntTy::I8)) => Constant::Int(ConstInt::I8(value as i8)),
         LitKind::Int(value, LitIntType::Signed(IntTy::I16)) => Constant::Int(ConstInt::I16(value as i16)),
         LitKind::Int(value, LitIntType::Signed(IntTy::I32)) => Constant::Int(ConstInt::I32(value as i32)),
         LitKind::Int(value, LitIntType::Signed(IntTy::I64)) => Constant::Int(ConstInt::I64(value as i64)),
         LitKind::Int(value, LitIntType::Signed(IntTy::Is)) => {
             Constant::Int(ConstInt::Isize(ConstIsize::Is32(value as i32)))
-        }
+        },
         LitKind::Float(ref is, ty) => Constant::Float(is.to_string(), ty.into()),
         LitKind::FloatUnsuffixed(ref is) => Constant::Float(is.to_string(), FloatWidth::Any),
         LitKind::Bool(b) => Constant::Bool(b),
@@ -260,7 +260,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
             ExprTup(ref tup) => self.multi(tup).map(Constant::Tuple),
             ExprRepeat(ref value, ref number) => {
                 self.binop_apply(value, number, |v, n| Some(Constant::Repeat(Box::new(v), n.as_u64() as usize)))
-            }
+            },
             ExprUnary(op, ref operand) => {
                 self.expr(operand).and_then(|o| {
                     match op {
@@ -269,7 +269,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
                         UnDeref => Some(o),
                     }
                 })
-            }
+            },
             ExprBinary(op, ref left, ref right) => self.binop(op, left, right),
             // TODO: add other expressions
             _ => None,
@@ -280,8 +280,8 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
     /// non-constant part
     fn multi(&mut self, vec: &[Expr]) -> Option<Vec<Constant>> {
         vec.iter()
-           .map(|elem| self.expr(elem))
-           .collect::<Option<_>>()
+            .map(|elem| self.expr(elem))
+            .collect::<Option<_>>()
     }
 
     /// lookup a possibly constant expression from a ExprPath
@@ -289,8 +289,11 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
         if let Some(lcx) = self.lcx {
             let def = lcx.tcx.tables().qpath_def(qpath, id);
             match def {
-                Def::Const(def_id) | Def::AssociatedConst(def_id) => {
-                    let substs = Some(lcx.tcx.tables().node_id_item_substs(id)
+                Def::Const(def_id) |
+                Def::AssociatedConst(def_id) => {
+                    let substs = Some(lcx.tcx
+                        .tables()
+                        .node_id_item_substs(id)
                         .unwrap_or_else(|| lcx.tcx.intern_substs(&[])));
                     if let Some((const_expr, _ty)) = lookup_const_by_id(lcx.tcx, def_id, substs) {
                         let ret = self.expr(const_expr);
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 9fa38ad02b3e..11b85edba3e6 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -204,8 +204,11 @@ fn lint_match_arms(cx: &LateContext, expr: &Expr) {
 
                     if let PatKind::Wild = j.pats[0].node {
                         // if the last arm is _, then i could be integrated into _
-                        // note that i.pats[0] cannot be _, because that would mean that we're hiding all the subsequent arms, and rust won't compile
-                        db.span_note(i.body.span, &format!("`{}` has the same arm body as the `_` wildcard, consider removing it`", lhs));
+                        // note that i.pats[0] cannot be _, because that would mean that we're
+                        // hiding all the subsequent arms, and rust won't compile
+                        db.span_note(i.body.span,
+                                     &format!("`{}` has the same arm body as the `_` wildcard, consider removing it`",
+                                              lhs));
                     } else {
                         db.span_note(i.body.span, &format!("consider refactoring into `{} | {}`", lhs, rhs));
                     }
@@ -245,7 +248,11 @@ fn if_sequence(mut expr: &Expr) -> (SmallVector<&Expr>, SmallVector<&Block>) {
 
 /// Return the list of bindings in a pattern.
 fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<InternedString, ty::Ty<'tcx>> {
-    fn bindings_impl<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat, map: &mut HashMap<InternedString, ty::Ty<'tcx>>) {
+    fn bindings_impl<'a, 'tcx>(
+        cx: &LateContext<'a, 'tcx>,
+        pat: &Pat,
+        map: &mut HashMap<InternedString, ty::Ty<'tcx>>
+    ) {
         match pat.node {
             PatKind::Box(ref pat) |
             PatKind::Ref(ref pat, _) => bindings_impl(cx, pat, map),
@@ -253,7 +260,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned
                 for pat in pats {
                     bindings_impl(cx, pat, map);
                 }
-            }
+            },
             PatKind::Binding(_, _, ref ident, ref as_pat) => {
                 if let Entry::Vacant(v) = map.entry(ident.node.as_str()) {
                     v.insert(cx.tcx.tables().pat_ty(pat));
@@ -261,17 +268,17 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned
                 if let Some(ref as_pat) = *as_pat {
                     bindings_impl(cx, as_pat, map);
                 }
-            }
+            },
             PatKind::Struct(_, ref fields, _) => {
                 for pat in fields {
                     bindings_impl(cx, &pat.node.pat, map);
                 }
-            }
+            },
             PatKind::Tuple(ref fields, _) => {
                 for pat in fields {
                     bindings_impl(cx, pat, map);
                 }
-            }
+            },
             PatKind::Slice(ref lhs, ref mid, ref rhs) => {
                 for pat in lhs {
                     bindings_impl(cx, pat, map);
@@ -282,7 +289,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned
                 for pat in rhs {
                     bindings_impl(cx, pat, map);
                 }
-            }
+            },
             PatKind::Lit(..) |
             PatKind::Range(..) |
             PatKind::Wild |
@@ -320,10 +327,10 @@ fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Option<(&T, &T)>
                         return Some((o, expr));
                     }
                 }
-            }
+            },
             Entry::Vacant(v) => {
                 v.insert(vec![expr]);
-            }
+            },
         }
     }
 
diff --git a/clippy_lints/src/cyclomatic_complexity.rs b/clippy_lints/src/cyclomatic_complexity.rs
index fc9e25c7707e..897a578f19a7 100644
--- a/clippy_lints/src/cyclomatic_complexity.rs
+++ b/clippy_lints/src/cyclomatic_complexity.rs
@@ -136,7 +136,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> {
                 if arms_n > 1 {
                     self.match_arms += arms_n - 2;
                 }
-            }
+            },
             ExprCall(ref callee, _) => {
                 walk_expr(self, e);
                 let ty = self.cx.tcx.tables().node_id_to_type(callee.id);
@@ -144,10 +144,10 @@ impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> {
                     ty::TyFnDef(_, _, ty) |
                     ty::TyFnPtr(ty) if ty.sig.skip_binder().output().sty == ty::TyNever => {
                         self.divergence += 1;
-                    }
+                    },
                     _ => (),
                 }
-            }
+            },
             ExprClosure(..) => (),
             ExprBinary(op, _, _) => {
                 walk_expr(self, e);
@@ -155,7 +155,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> {
                     BiAnd | BiOr => self.short_circuits += 1,
                     _ => (),
                 }
-            }
+            },
             ExprRet(_) => self.returns += 1,
             _ => walk_expr(self, e),
         }
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 449227c97679..cda82f46434e 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -86,8 +86,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Derive {
 }
 
 /// Implementation of the `DERIVE_HASH_XOR_EQ` lint.
-fn check_hash_peq<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, span: Span, trait_ref: &TraitRef, ty: ty::Ty<'tcx>,
-                                hash_is_automatically_derived: bool) {
+fn check_hash_peq<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    span: Span,
+    trait_ref: &TraitRef,
+    ty: ty::Ty<'tcx>,
+    hash_is_automatically_derived: bool
+) {
     if_let_chain! {[
         match_path_old(&trait_ref.path, &paths::HASH),
         let Some(peq_trait_def_id) = cx.tcx.lang_items.eq_trait()
@@ -149,18 +154,18 @@ fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, item: &Item, trait_ref
                         match field.ty(cx.tcx, substs).sty {
                             TypeVariants::TyArray(_, size) if size > 32 => {
                                 return;
-                            }
+                            },
                             TypeVariants::TyFnPtr(..) => {
                                 return;
-                            }
+                            },
                             TypeVariants::TyTuple(tys) if tys.len() > 12 => {
                                 return;
-                            }
+                            },
                             _ => (),
                         }
                     }
                 }
-            }
+            },
             _ => (),
         }
 
@@ -169,7 +174,7 @@ fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, item: &Item, trait_ref
                            item.span,
                            "you are implementing `Clone` explicitly on a `Copy` type",
                            |db| {
-                               db.span_note(item.span, "consider deriving `Clone` or removing `Copy`");
-                           });
+            db.span_note(item.span, "consider deriving `Clone` or removing `Copy`");
+        });
     }
 }
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 4183632543b7..20c82ee46607 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -64,26 +64,21 @@ pub fn strip_doc_comment_decoration((comment, span): (String, Span)) -> Vec<(Str
     const ONELINERS: &'static [&'static str] = &["///!", "///", "//!", "//"];
     for prefix in ONELINERS {
         if comment.starts_with(*prefix) {
-            return vec![(
-                comment[prefix.len()..].to_owned(),
-                Span { lo: span.lo + BytePos(prefix.len() as u32), ..span }
-            )];
+            return vec![(comment[prefix.len()..].to_owned(),
+                         Span { lo: span.lo + BytePos(prefix.len() as u32), ..span })];
         }
     }
 
     if comment.starts_with("/*") {
-        return comment[3..comment.len() - 2].lines().map(|line| {
-            let offset = line.as_ptr() as usize - comment.as_ptr() as usize;
-            debug_assert_eq!(offset as u32 as usize, offset);
+        return comment[3..comment.len() - 2]
+            .lines()
+            .map(|line| {
+                let offset = line.as_ptr() as usize - comment.as_ptr() as usize;
+                debug_assert_eq!(offset as u32 as usize, offset);
 
-            (
-                line.to_owned(),
-                Span {
-                    lo: span.lo + BytePos(offset as u32),
-                    ..span
-                }
-            )
-        }).collect();
+                (line.to_owned(), Span { lo: span.lo + BytePos(offset as u32), ..span })
+            })
+            .collect();
     }
 
     panic!("not a doc-comment: {}", comment);
@@ -273,7 +268,9 @@ fn check_doc(cx: &EarlyContext, valid_idents: &[String], docs: &[(String, Span)]
                             }
 
                             lookup_parser = parser.clone();
-                            if let (Some((false, $c)), Some((false, $c))) = (lookup_parser.next(), lookup_parser.next()) {
+                            let a = lookup_parser.next();
+                            let b = lookup_parser.next();
+                            if let (Some((false, $c)), Some((false, $c))) = (a, b) {
                                 let mut close_count = 3;
                                 while let Some((false, $c)) = lookup_parser.next() {
                                     close_count += 1;
@@ -299,16 +296,17 @@ fn check_doc(cx: &EarlyContext, valid_idents: &[String], docs: &[(String, Span)]
         match parser.next() {
             Some((new_line, c)) => {
                 match c {
-                    '#' if new_line => { // don’t warn on titles
+                    '#' if new_line => {
+                        // don’t warn on titles
                         parser.next_line();
-                    }
+                    },
                     '`' => {
                         if try!(check_block!(parser, '`', new_line)) {
                             continue;
                         }
 
                         try!(parser.jump_to('`')); // not a code block, just inline code
-                    }
+                    },
                     '~' => {
                         if try!(check_block!(parser, '~', new_line)) {
                             continue;
@@ -317,7 +315,7 @@ fn check_doc(cx: &EarlyContext, valid_idents: &[String], docs: &[(String, Span)]
                         // ~ does not introduce inline code, but two of them introduce
                         // strikethrough. Too bad for the consistency but we don't care about
                         // strikethrough.
-                    }
+                    },
                     '[' => {
                         // Check for a reference definition `[foo]:` at the beginning of a line
                         let mut link = true;
@@ -335,24 +333,24 @@ fn check_doc(cx: &EarlyContext, valid_idents: &[String], docs: &[(String, Span)]
 
                         parser.advance_begin();
                         parser.link = link;
-                    }
+                    },
                     ']' if parser.link => {
                         parser.link = false;
 
                         match parser.peek() {
                             Some('(') => {
                                 try!(parser.jump_to(')'));
-                            }
+                            },
                             Some('[') => {
                                 try!(parser.jump_to(']'));
-                            }
+                            },
                             Some(_) => continue,
                             None => return Err(()),
                         }
-                    }
+                    },
                     c if !is_path_char(c) => {
                         parser.advance_begin();
-                    }
+                    },
                     _ => {
                         if let Some((_, c)) = parser.find(|&(_, c)| !is_path_char(c)) {
                             parser.put_back(c);
@@ -361,10 +359,10 @@ fn check_doc(cx: &EarlyContext, valid_idents: &[String], docs: &[(String, Span)]
                         let (word, span) = parser.word();
                         check_word(cx, valid_idents, word, span);
                         parser.advance_begin();
-                    }
+                    },
                 }
 
-            }
+            },
             None => break,
         }
     }
@@ -386,8 +384,7 @@ fn check_word(cx: &EarlyContext, valid_idents: &[String], word: &str, span: Span
             s
         };
 
-        s.chars().all(char::is_alphanumeric) &&
-        s.chars().filter(|&c| c.is_uppercase()).take(2).count() > 1 &&
+        s.chars().all(char::is_alphanumeric) && s.chars().filter(|&c| c.is_uppercase()).take(2).count() > 1 &&
         s.chars().filter(|&c| c.is_lowercase()).take(1).count() > 0
     }
 
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 00a41c2e986c..2fe53d8cacf4 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -78,7 +78,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for HashMapLint {
     }
 }
 
-fn check_cond<'a, 'tcx, 'b>(cx: &'a LateContext<'a, 'tcx>, check: &'b Expr) -> Option<(&'static str, &'b Expr, &'b Expr)> {
+fn check_cond<'a, 'tcx, 'b>(
+    cx: &'a LateContext<'a, 'tcx>,
+    check: &'b Expr
+) -> Option<(&'static str, &'b Expr, &'b Expr)> {
     if_let_chain! {[
         let ExprMethodCall(ref name, _, ref params) = check.node,
         params.len() >= 2,
diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs
index 4dafcf365a6c..0bd1740c5459 100644
--- a/clippy_lints/src/enum_glob_use.rs
+++ b/clippy_lints/src/enum_glob_use.rs
@@ -49,7 +49,7 @@ impl EnumGlobUse {
         if let ItemUse(ref path, UseKind::Glob) = item.node {
             // FIXME: ask jseyfried why the qpath.def for `use std::cmp::Ordering::*;`
             // extracted through `ItemUse(ref qpath, UseKind::Glob)` is a `Mod` and not an `Enum`
-            //if let Def::Enum(_) = path.def {
+            // if let Def::Enum(_) = path.def {
             if path.segments.last().and_then(|seg| seg.name.as_str().chars().next()).map_or(false, char::is_uppercase) {
                 span_lint(cx, ENUM_GLOB_USE, item.span, "don't use glob imports for enum variants");
             }
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 74611d491c7f..5ae3fcbb2a1e 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -49,10 +49,13 @@ declare_lint! {
 
 /// **What it does:** Checks for modules that have the same name as their parent module
 ///
-/// **Why is this bad?** A typical beginner mistake is to have `mod foo;` and again `mod foo { .. }` in `foo.rs`.
-///                      The expectation is that items inside the inner `mod foo { .. }` are then available
+/// **Why is this bad?** A typical beginner mistake is to have `mod foo;` and again `mod foo { ..
+/// }` in `foo.rs`.
+/// The expectation is that items inside the inner `mod foo { .. }` are then
+/// available
 ///                      through `foo::x`, but they are only available through `foo::foo::x`.
-///                      If this is done on purpose, it would be better to choose a more representative module name.
+/// If this is done on purpose, it would be better to choose a more
+/// representative module name.
 ///
 /// **Known problems:** None.
 ///
@@ -78,7 +81,10 @@ pub struct EnumVariantNames {
 
 impl EnumVariantNames {
     pub fn new(threshold: u64) -> EnumVariantNames {
-        EnumVariantNames { modules: Vec::new(), threshold: threshold }
+        EnumVariantNames {
+            modules: Vec::new(),
+            threshold: threshold,
+        }
     }
 }
 
@@ -108,8 +114,14 @@ fn partial_rmatch(post: &str, name: &str) -> usize {
 
 // FIXME: #600
 #[allow(while_let_on_iterator)]
-fn check_variant(cx: &EarlyContext, threshold: u64, def: &EnumDef, item_name: &str,
-                 item_name_chars: usize, span: Span) {
+fn check_variant(
+    cx: &EarlyContext,
+    threshold: u64,
+    def: &EnumDef,
+    item_name: &str,
+    item_name_chars: usize,
+    span: Span
+) {
     if (def.variants.len() as u64) < threshold {
         return;
     }
@@ -200,7 +212,10 @@ impl EarlyLintPass for EnumVariantNames {
                 if !mod_camel.is_empty() {
                     if mod_name == &item_name {
                         if let ItemKind::Mod(..) = item.node {
-                            span_lint(cx, MODULE_INCEPTION, item.span, "module has the same name as its containing module");
+                            span_lint(cx,
+                                      MODULE_INCEPTION,
+                                      item.span,
+                                      "module has the same name as its containing module");
                         }
                     }
                     if item.vis == Visibility::Public {
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index c43dfe6e27ca..bfc16a504570 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -48,19 +48,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
 
 fn is_valid_operator(op: &BinOp) -> bool {
     match op.node {
-        BiSub |
-        BiDiv |
-        BiEq |
-        BiLt |
-        BiLe |
-        BiGt |
-        BiGe |
-        BiNe |
-        BiAnd |
-        BiOr |
-        BiBitXor |
-        BiBitAnd |
-        BiBitOr => true,
+        BiSub | BiDiv | BiEq | BiLt | BiLe | BiGt | BiGe | BiNe | BiAnd | BiOr | BiBitXor | BiBitAnd | BiBitOr => true,
         _ => false,
     }
 }
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 0ca1f143b164..ee415b363824 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -46,7 +46,7 @@ fn is_non_trait_box(ty: ty::Ty) -> bool {
     }
 }
 
-struct EscapeDelegate<'a, 'tcx: 'a+'gcx, 'gcx: 'a> {
+struct EscapeDelegate<'a, 'tcx: 'a + 'gcx, 'gcx: 'a> {
     tcx: ty::TyCtxt<'a, 'tcx, 'tcx>,
     set: NodeSet,
     infcx: &'a InferCtxt<'a, 'gcx, 'gcx>,
@@ -68,7 +68,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
         decl: &'tcx FnDecl,
         body: &'tcx Expr,
         _: Span,
-        id: NodeId,
+        id: NodeId
     ) {
         let param_env = ty::ParameterEnvironment::for_item(cx.tcx, id);
 
@@ -98,7 +98,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     }
 }
 
-impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'gcx> {
+impl<'a, 'tcx: 'a + 'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'gcx> {
     fn consume(&mut self, _: NodeId, _: Span, cmt: cmt<'tcx>, mode: ConsumeMode) {
         if let Categorization::Local(lid) = cmt.cat {
             if self.set.contains(&lid) {
@@ -151,18 +151,26 @@ impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'g
         }
 
     }
-    fn borrow(&mut self, borrow_id: NodeId, _: Span, cmt: cmt<'tcx>, _: &ty::Region, _: ty::BorrowKind,
-              loan_cause: LoanCause) {
+    fn borrow(
+        &mut self,
+        borrow_id: NodeId,
+        _: Span,
+        cmt: cmt<'tcx>,
+        _: &ty::Region,
+        _: ty::BorrowKind,
+        loan_cause: LoanCause
+    ) {
         use rustc::ty::adjustment::Adjust;
 
         if let Categorization::Local(lid) = cmt.cat {
             if self.set.contains(&lid) {
-                if let Some(&Adjust::DerefRef { autoderefs, .. }) = self.tcx
-                                                                        .tables
-                                                                        .borrow()
-                                                                        .adjustments
-                                                                        .get(&borrow_id)
-                                                                        .map(|a| &a.kind) {
+                if let Some(&Adjust::DerefRef { autoderefs, .. }) =
+                    self.tcx
+                        .tables
+                        .borrow()
+                        .adjustments
+                        .get(&borrow_id)
+                        .map(|a| &a.kind) {
                     if LoanCause::AutoRef == loan_cause {
                         // x.foo()
                         if autoderefs == 0 {
@@ -173,14 +181,15 @@ impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'g
                     }
                 } else if LoanCause::AddrOf == loan_cause {
                     // &x
-                    if let Some(&Adjust::DerefRef { autoderefs, .. }) = self.tcx
-                                                                            .tables
-                                                                            .borrow()
-                                                                            .adjustments
-                                                                            .get(&self.tcx
-                                                                            .map
-                                                                            .get_parent_node(borrow_id))
-                                                                            .map(|a| &a.kind) {
+                    if let Some(&Adjust::DerefRef { autoderefs, .. }) =
+                        self.tcx
+                            .tables
+                            .borrow()
+                            .adjustments
+                            .get(&self.tcx
+                                .map
+                                .get_parent_node(borrow_id))
+                            .map(|a| &a.kind) {
                         if autoderefs <= 1 {
                             // foo(&x) where no extra autoreffing is happening
                             self.set.remove(&lid);
@@ -198,7 +207,7 @@ impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'g
     fn mutate(&mut self, _: NodeId, _: Span, _: cmt<'tcx>, _: MutateMode) {}
 }
 
-impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> EscapeDelegate<'a, 'tcx, 'gcx> {
+impl<'a, 'tcx: 'a + 'gcx, 'gcx: 'a> EscapeDelegate<'a, 'tcx, 'gcx> {
     fn is_large_box(&self, ty: ty::Ty<'gcx>) -> bool {
         // Large types need to be boxed to avoid stack
         // overflows.
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 2bf91f8d1bce..f25014b6805e 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -41,7 +41,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EtaPass {
                 for arg in args {
                     check_closure(cx, arg)
                 }
-            }
+            },
             _ => (),
         }
     }
@@ -65,11 +65,10 @@ fn check_closure(cx: &LateContext, expr: &Expr) {
                 // Is it an unsafe function? They don't implement the closure traits
                 ty::TyFnDef(_, _, fn_ty) |
                 ty::TyFnPtr(fn_ty) => {
-                    if fn_ty.unsafety == Unsafety::Unsafe ||
-                       fn_ty.sig.skip_binder().output().sty == ty::TyNever {
+                    if fn_ty.unsafety == Unsafety::Unsafe || fn_ty.sig.skip_binder().output().sty == ty::TyNever {
                         return;
                     }
-                }
+                },
                 _ => (),
             }
             for (a1, a2) in decl.inputs.iter().zip(args) {
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 88e1180067a7..f83b3271d506 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -60,7 +60,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         // Find a write to a local variable.
         match expr.node {
-            ExprAssign(ref lhs, _) | ExprAssignOp(_, ref lhs, _) => {
+            ExprAssign(ref lhs, _) |
+            ExprAssignOp(_, ref lhs, _) => {
                 if let ExprPath(ref qpath) = lhs.node {
                     if let QPath::Resolved(_, ref path) = *qpath {
                         if path.segments.len() == 1 {
@@ -75,13 +76,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence {
                         }
                     }
                 }
-            }
-            _ => {}
+            },
+            _ => {},
         }
     }
     fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) {
         match stmt.node {
-            StmtExpr(ref e, _) | StmtSemi(ref e, _) => DivergenceVisitor { cx: cx }.maybe_walk_expr(e),
+            StmtExpr(ref e, _) |
+            StmtSemi(ref e, _) => DivergenceVisitor { cx: cx }.maybe_walk_expr(e),
             StmtDecl(ref d, _) => {
                 if let DeclLocal(ref local) = d.node {
                     if let Local { init: Some(ref e), .. } = **local {
@@ -110,32 +112,29 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
                     // make sure top level arm expressions aren't linted
                     self.maybe_walk_expr(&*arm.body);
                 }
-            }
+            },
             _ => walk_expr(self, e),
         }
     }
     fn report_diverging_sub_expr(&mut self, e: &Expr) {
-        span_lint(
-            self.cx,
-            DIVERGING_SUB_EXPRESSION,
-            e.span,
-            "sub-expression diverges",
-        );
+        span_lint(self.cx, DIVERGING_SUB_EXPRESSION, e.span, "sub-expression diverges");
     }
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, e: &'tcx Expr) {
         match e.node {
-            ExprAgain(_) |
-            ExprBreak(_, _) |
-            ExprRet(_) => self.report_diverging_sub_expr(e),
-            ExprCall(ref func, _) => match self.cx.tcx.tables().expr_ty(func).sty {
-                ty::TyFnDef(_, _, fn_ty) |
-                ty::TyFnPtr(fn_ty) => if let ty::TyNever = self.cx.tcx.erase_late_bound_regions(&fn_ty.sig).output().sty {
-                    self.report_diverging_sub_expr(e);
-                },
-                _ => {},
+            ExprAgain(_) | ExprBreak(_, _) | ExprRet(_) => self.report_diverging_sub_expr(e),
+            ExprCall(ref func, _) => {
+                match self.cx.tcx.tables().expr_ty(func).sty {
+                    ty::TyFnDef(_, _, fn_ty) |
+                    ty::TyFnPtr(fn_ty) => {
+                        if let ty::TyNever = self.cx.tcx.erase_late_bound_regions(&fn_ty.sig).output().sty {
+                            self.report_diverging_sub_expr(e);
+                        }
+                    },
+                    _ => {},
+                }
             },
             ExprMethodCall(..) => {
                 let method_call = ty::MethodCall::expr(e.id);
@@ -147,7 +146,8 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
                 }
             },
             _ => {
-                // do not lint expressions referencing objects of type `!`, as that required a diverging expression to begin with
+                // do not lint expressions referencing objects of type `!`, as that required a diverging expression
+                // to begin with
             },
         }
         self.maybe_walk_expr(e);
@@ -195,7 +195,7 @@ fn check_for_unsequenced_reads(vis: &mut ReadVisitor) {
                 // We reached the top of the function, stop.
                 break;
             },
-            _ => { StopEarly::KeepGoing }
+            _ => StopEarly::KeepGoing,
         };
         match stop_early {
             StopEarly::Stop => break,
@@ -214,7 +214,7 @@ enum StopEarly {
     Stop,
 }
 
-fn check_expr<'a, 'tcx>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> StopEarly {
+fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> StopEarly {
     if expr.id == vis.last_expr.id {
         return StopEarly::KeepGoing;
     }
@@ -229,7 +229,7 @@ fn check_expr<'a, 'tcx>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> S
         ExprRepeat(_, _) |
         ExprStruct(_, _, _) => {
             walk_expr(vis, expr);
-        }
+        },
         ExprBinary(op, _, _) |
         ExprAssignOp(op, _, _) => {
             if op.node == BiAnd || op.node == BiOr {
@@ -238,7 +238,7 @@ fn check_expr<'a, 'tcx>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> S
             } else {
                 walk_expr(vis, expr);
             }
-        }
+        },
         ExprClosure(_, _, _, _) => {
             // Either
             //
@@ -252,10 +252,10 @@ fn check_expr<'a, 'tcx>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> S
             //
             // This is also the only place we need to stop early (grrr).
             return StopEarly::Stop;
-        }
+        },
         // All other expressions either have only one child or strictly
         // sequence the evaluation order of their sub-expressions.
-        _ => {}
+        _ => {},
     }
 
     vis.last_expr = expr;
@@ -276,7 +276,7 @@ fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt) -> St
             };
             local.and_then(|local| local.init.as_ref())
                 .map_or(StopEarly::KeepGoing, |expr| check_expr(vis, expr))
-        }
+        },
     }
 }
 
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 0cf4762364ba..1894a12a6d3e 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -55,7 +55,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                     ], {
                         span_lint(cx, USELESS_FORMAT, span, "useless use of `format!`");
                     }}
-                }
+                },
                 // `format!("foo")` expansion contains `match () { () => [], }`
                 ExprMatch(ref matchee, _, _) => {
                     if let ExprTup(ref tup) = matchee.node {
@@ -63,7 +63,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                             span_lint(cx, USELESS_FORMAT, span, "useless use of `format!`");
                         }
                     }
-                }
+                },
                 _ => (),
             }
         }
@@ -72,8 +72,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
 
 /// Returns the slice of format string parts in an `Arguments::new_v1` call.
 /// Public because it's shared with a lint in print.rs.
-pub fn get_argument_fmtstr_parts<'a, 'b>(cx: &LateContext<'a, 'b>, expr: &'a Expr)
-                                         -> Option<Vec<InternedString>> {
+pub fn get_argument_fmtstr_parts<'a, 'b>(cx: &LateContext<'a, 'b>, expr: &'a Expr) -> Option<Vec<InternedString>> {
     if_let_chain! {[
         let ExprBlock(ref block) = expr.node,
         block.stmts.len() == 1,
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index e9af1a011d98..6fdedaeed43b 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -62,7 +62,7 @@ impl EarlyLintPass for Formatting {
                 (&ast::StmtKind::Expr(ref first), &ast::StmtKind::Expr(ref second)) |
                 (&ast::StmtKind::Expr(ref first), &ast::StmtKind::Semi(ref second)) => {
                     check_consecutive_ifs(cx, first, second);
-                }
+                },
                 _ => (),
             }
         }
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 52461d08ee8d..5ad676e57a08 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -76,7 +76,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions {
         decl: &'tcx hir::FnDecl,
         expr: &'tcx hir::Expr,
         span: Span,
-        nodeid: ast::NodeId,
+        nodeid: ast::NodeId
     ) {
         use rustc::hir::map::Node::*;
 
@@ -137,7 +137,7 @@ impl<'a, 'tcx> Functions {
         unsafety: hir::Unsafety,
         decl: &'tcx hir::FnDecl,
         expr: &'tcx hir::Expr,
-        nodeid: ast::NodeId,
+        nodeid: ast::NodeId
     ) {
         if unsafety == hir::Unsafety::Normal && cx.access_levels.is_exported(nodeid) {
             let raw_ptrs = decl.inputs.iter().filter_map(|arg| raw_ptr_arg(cx, arg)).collect::<HashSet<_>>();
@@ -178,7 +178,7 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
                         self.check_arg(arg);
                     }
                 }
-            }
+            },
             hir::ExprMethodCall(_, _, ref args) => {
                 let method_call = ty::MethodCall::expr(expr.id);
                 let base_type = self.cx.tcx.tables.borrow().method_map[&method_call].ty;
@@ -188,7 +188,7 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
                         self.check_arg(arg);
                     }
                 }
-            }
+            },
             hir::ExprUnary(hir::UnDeref, ref ptr) => self.check_arg(ptr),
             _ => (),
         }
diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 547aa23f0de8..a10a9523ac1b 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -41,17 +41,17 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityOp {
                 BiAdd | BiBitOr | BiBitXor => {
                     check(cx, left, 0, e.span, right.span);
                     check(cx, right, 0, e.span, left.span);
-                }
+                },
                 BiShl | BiShr | BiSub => check(cx, right, 0, e.span, left.span),
                 BiMul => {
                     check(cx, left, 1, e.span, right.span);
                     check(cx, right, 1, e.span, left.span);
-                }
+                },
                 BiDiv => check(cx, right, 1, e.span, left.span),
                 BiBitAnd => {
                     check(cx, left, -1, e.span, right.span);
                     check(cx, right, -1, e.span, left.span);
-                }
+                },
                 _ => (),
             }
         }
diff --git a/clippy_lints/src/if_let_redundant_pattern_matching.rs b/clippy_lints/src/if_let_redundant_pattern_matching.rs
index 399b58956bd6..921cd7f8885e 100644
--- a/clippy_lints/src/if_let_redundant_pattern_matching.rs
+++ b/clippy_lints/src/if_let_redundant_pattern_matching.rs
@@ -45,13 +45,12 @@ impl LintPass for Pass {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
 
-        if let ExprMatch(ref op, ref arms, MatchSource::IfLetDesugar{..}) = expr.node {
+        if let ExprMatch(ref op, ref arms, MatchSource::IfLetDesugar { .. }) = expr.node {
 
             if arms[0].pats.len() == 1 {
 
                 let good_method = match arms[0].pats[0].node {
-                    PatKind::TupleStruct(ref path, ref pats, _) if pats.len() == 1 && pats[0].node == PatKind::Wild =>  {
-
+                    PatKind::TupleStruct(ref path, ref pats, _) if pats.len() == 1 && pats[0].node == PatKind::Wild => {
                         if match_path(path, &paths::RESULT_OK) {
                             "is_ok()"
                         } else if match_path(path, &paths::RESULT_ERR) {
@@ -59,15 +58,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                         } else if match_path(path, &paths::OPTION_SOME) {
                             "is_some()"
                         } else {
-                            return
+                            return;
                         }
-                    }
+                    },
 
-                    PatKind::Path(ref path) if match_path(path, &paths::OPTION_NONE) => {
-                        "is_none()"
-                    }
+                    PatKind::Path(ref path) if match_path(path, &paths::OPTION_NONE) => "is_none()",
 
-                    _ => return
+                    _ => return,
                 };
 
                 span_lint_and_then(cx,
@@ -75,15 +72,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                                    arms[0].pats[0].span,
                                    &format!("redundant pattern matching, consider using `{}`", good_method),
                                    |db| {
-                                        let span = Span {
-                                            lo: expr.span.lo,
-                                            hi: op.span.hi,
-                                            expn_id: expr.span.expn_id,
-                                        };
-                                        db.span_suggestion(span,
-                                                           "try this",
-                                                           format!("if {}.{}", snippet(cx, op.span, "_"), good_method));
-                                    });
+                    let span = Span {
+                        lo: expr.span.lo,
+                        hi: op.span.hi,
+                        expn_id: expr.span.expn_id,
+                    };
+                    db.span_suggestion(span, "try this", format!("if {}.{}", snippet(cx, op.span, "_"), good_method));
+                });
             }
 
         }
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index 273c1bd0eb0a..72a3d485bd08 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -55,14 +55,14 @@ impl EarlyLintPass for IfNotElse {
                                            item.span,
                                            "Unnecessary boolean `not` operation",
                                            "remove the `!` and swap the blocks of the if/else");
-                    }
+                    },
                     ExprKind::Binary(ref kind, _, _) if kind.node == BinOpKind::Ne => {
                         span_help_and_lint(cx,
                                            IF_NOT_ELSE,
                                            item.span,
                                            "Unnecessary `!=` operation",
                                            "change to `==` and swap the blocks of the if/else");
-                    }
+                    },
                     _ => (),
                 }
             }
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index 78b43974364d..3b3cd423729b 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -47,9 +47,10 @@ impl EarlyLintPass for ItemsAfterStatements {
         }
 
         // skip initial items
-        let stmts = item.stmts.iter()
-                              .map(|stmt| &stmt.node)
-                              .skip_while(|s| matches!(**s, StmtKind::Item(..)));
+        let stmts = item.stmts
+            .iter()
+            .map(|stmt| &stmt.node)
+            .skip_while(|s| matches!(**s, StmtKind::Item(..)));
 
         // lint on all further items
         for stmt in stmts {
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 0242fb523ee5..22835b488403 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -107,8 +107,7 @@ fn check_trait_items(cx: &LateContext, item: &Item, trait_items: &[TraitItem]) {
                 span_lint(cx,
                           LEN_WITHOUT_IS_EMPTY,
                           i.span,
-                          &format!("trait `{}` has a `len` method but no `is_empty` method",
-                                   item.name));
+                          &format!("trait `{}` has a `len` method but no `is_empty` method", item.name));
             }
         }
     }
@@ -118,7 +117,8 @@ fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItemRef]) {
     fn is_named_self(cx: &LateContext, item: &ImplItemRef, name: &str) -> bool {
         &*item.name.as_str() == name &&
         if let AssociatedItemKind::Method { has_self } = item.kind {
-            has_self && {
+            has_self &&
+            {
                 let did = cx.tcx.map.local_def_id(item.id.node_id);
                 let impl_ty = cx.tcx.item_type(did);
                 impl_ty.fn_args().skip_binder().len() == 1
@@ -146,9 +146,7 @@ fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItemRef]) {
             span_lint(cx,
                       LEN_WITHOUT_IS_EMPTY,
                       i.span,
-                      &format!("item `{}` has a public `len` method but {} `is_empty` method",
-                               ty,
-                               is_empty));
+                      &format!("item `{}` has a public `len` method but {} `is_empty` method", ty, is_empty));
         }
     }
 }
@@ -164,7 +162,7 @@ fn check_cmp(cx: &LateContext, span: Span, left: &Expr, right: &Expr, op: &str)
         (&ExprLit(ref lit), &ExprMethodCall(ref method, _, ref args)) |
         (&ExprMethodCall(ref method, _, ref args), &ExprLit(ref lit)) => {
             check_len_zero(cx, span, &method.node, args, lit, op)
-        }
+        },
         _ => (),
     }
 }
@@ -199,20 +197,18 @@ fn has_is_empty(cx: &LateContext, expr: &Expr) -> bool {
 
     /// Check the inherent impl's items for an `is_empty(self)` method.
     fn has_is_empty_impl(cx: &LateContext, id: DefId) -> bool {
-        cx.tcx.inherent_impls.borrow().get(&id).map_or(false, |impls| impls.iter().any(|imp| {
-            cx.tcx.associated_items(*imp).any(|item| {
-                is_is_empty(cx, &item)
-            })
-        }))
+        cx.tcx.inherent_impls.borrow().get(&id).map_or(false, |impls| {
+            impls.iter().any(|imp| cx.tcx.associated_items(*imp).any(|item| is_is_empty(cx, &item)))
+        })
     }
 
     let ty = &walk_ptrs_ty(cx.tcx.tables().expr_ty(expr));
     match ty.sty {
         ty::TyDynamic(..) => {
             cx.tcx
-              .associated_items(ty.ty_to_def_id().expect("trait impl not found"))
-              .any(|item| is_is_empty(cx, &item))
-        }
+                .associated_items(ty.ty_to_def_id().expect("trait impl not found"))
+                .any(|item| is_is_empty(cx, &item))
+        },
         ty::TyProjection(_) => ty.ty_to_def_id().map_or(false, |id| has_is_empty_impl(cx, id)),
         ty::TyAdt(id, _) => has_is_empty_impl(cx, id.did),
         ty::TyArray(..) | ty::TyStr => true,
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 474a86cdb788..88d74b018863 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -152,7 +152,7 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for UsedVisitor<'a, 'tcx> {
 fn check_assign<'a, 'tcx>(
     cx: &LateContext<'a, 'tcx>,
     decl: hir::def_id::DefId,
-    block: &'tcx hir::Block,
+    block: &'tcx hir::Block
 ) -> Option<&'tcx hir::Expr> {
     if_let_chain! {[
         block.expr.is_none(),
@@ -182,11 +182,7 @@ fn check_assign<'a, 'tcx>(
     None
 }
 
-fn used_in_expr<'a, 'tcx: 'a>(
-    cx: &LateContext<'a, 'tcx>,
-    id: hir::def_id::DefId,
-    expr: &'tcx hir::Expr,
-) -> bool {
+fn used_in_expr<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, id: hir::def_id::DefId, expr: &'tcx hir::Expr) -> bool {
     let mut v = UsedVisitor {
         cx: cx,
         id: id,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c6852477a11a..3641b476c5fb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -173,10 +173,22 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) {
     };
 
     let mut store = reg.sess.lint_store.borrow_mut();
-    store.register_removed("unstable_as_slice", "`Vec::as_slice` has been stabilized in 1.7");
-    store.register_removed("unstable_as_mut_slice", "`Vec::as_mut_slice` has been stabilized in 1.7");
-    store.register_removed("str_to_string", "using `str::to_string` is common even today and specialization will likely happen soon");
-    store.register_removed("string_to_string", "using `string::to_string` is common even today and specialization will likely happen soon");
+    store.register_removed(
+        "unstable_as_slice",
+        "`Vec::as_slice` has been stabilized in 1.7",
+    );
+    store.register_removed(
+        "unstable_as_mut_slice",
+        "`Vec::as_mut_slice` has been stabilized in 1.7",
+    );
+    store.register_removed(
+        "str_to_string",
+        "using `str::to_string` is common even today and specialization will likely happen soon",
+    );
+    store.register_removed(
+        "string_to_string",
+        "using `string::to_string` is common even today and specialization will likely happen soon",
+    );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
     reg.register_late_lint_pass(box serde::Serde);
@@ -229,7 +241,9 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) {
     reg.register_late_lint_pass(box map_clone::Pass);
     reg.register_late_lint_pass(box temporary_assignment::Pass);
     reg.register_late_lint_pass(box transmute::Transmute);
-    reg.register_late_lint_pass(box cyclomatic_complexity::CyclomaticComplexity::new(conf.cyclomatic_complexity_threshold));
+    reg.register_late_lint_pass(
+        box cyclomatic_complexity::CyclomaticComplexity::new(conf.cyclomatic_complexity_threshold)
+    );
     reg.register_late_lint_pass(box escape::Pass{too_large_for_stack: conf.too_large_for_stack});
     reg.register_early_lint_pass(box misc_early::MiscEarly);
     reg.register_late_lint_pass(box array_indexing::ArrayIndexing);
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 60132ad9161c..ba705a84089c 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -87,30 +87,25 @@ enum RefLt {
 fn bound_lifetimes(bound: &TyParamBound) -> HirVec<&Lifetime> {
     if let TraitTyParamBound(ref trait_ref, _) = *bound {
         trait_ref.trait_ref
-                 .path
-                 .segments
-                 .last()
-                 .expect("a path must have at least one segment")
-                 .parameters
-                 .lifetimes()
+            .path
+            .segments
+            .last()
+            .expect("a path must have at least one segment")
+            .parameters
+            .lifetimes()
     } else {
         HirVec::new()
     }
 }
 
-fn check_fn_inner<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
-    decl: &'tcx FnDecl,
-    generics: &'tcx Generics,
-    span: Span,
-) {
+fn check_fn_inner<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl, generics: &'tcx Generics, span: Span) {
     if in_external_macro(cx, span) || has_where_lifetimes(cx, &generics.where_clause) {
         return;
     }
 
     let bounds_lts = generics.ty_params
-                             .iter()
-                             .flat_map(|typ| typ.bounds.iter().flat_map(bound_lifetimes));
+        .iter()
+        .flat_map(|typ| typ.bounds.iter().flat_map(bound_lifetimes));
 
     if could_use_elision(cx, decl, &generics.lifetimes, bounds_lts) {
         span_lint(cx,
@@ -121,15 +116,11 @@ fn check_fn_inner<'a, 'tcx>(
     report_extra_lifetimes(cx, decl, generics);
 }
 
-fn could_use_elision<
-    'a,
-    'tcx: 'a,
-    T: Iterator<Item = &'tcx Lifetime>
->(
+fn could_use_elision<'a, 'tcx: 'a, T: Iterator<Item = &'tcx Lifetime>>(
     cx: &LateContext<'a, 'tcx>,
     func: &'tcx FnDecl,
     named_lts: &'tcx [LifetimeDef],
-    bounds_lts: T,
+    bounds_lts: T
 ) -> bool {
     // There are two scenarios where elision works:
     // * no output references, all input references have different LT
@@ -262,13 +253,13 @@ impl<'v, 't> RefVisitor<'v, 't> {
                         for _ in generics.regions.as_slice() {
                             self.record(&None);
                         }
-                    }
+                    },
                     Def::Trait(def_id) => {
                         let trait_def = self.cx.tcx.trait_defs.borrow()[&def_id];
                         for _ in &self.cx.tcx.item_generics(trait_def.def_id).regions {
                             self.record(&None);
                         }
-                    }
+                    },
                     _ => (),
                 }
             }
@@ -286,10 +277,10 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
         match ty.node {
             TyRptr(None, _) => {
                 self.record(&None);
-            }
+            },
             TyPath(ref path) => {
                 self.collect_anonymous_lifetimes(path, ty);
-            }
+            },
             _ => (),
         }
         walk_ty(self, ty);
@@ -325,14 +316,14 @@ fn has_where_lifetimes<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, where_clause: &
                         return true;
                     }
                 }
-            }
+            },
             WherePredicate::EqPredicate(ref pred) => {
                 let mut visitor = RefVisitor::new(cx);
                 walk_ty(&mut visitor, &pred.ty);
                 if !visitor.lts.is_empty() {
                     return true;
                 }
-            }
+            },
         }
     }
     false
@@ -362,9 +353,9 @@ impl<'tcx> Visitor<'tcx> for LifetimeChecker {
 
 fn report_extra_lifetimes<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, func: &'tcx FnDecl, generics: &'tcx Generics) {
     let hs = generics.lifetimes
-                     .iter()
-                     .map(|lt| (lt.lifetime.name, lt.lifetime.span))
-                     .collect();
+        .iter()
+        .map(|lt| (lt.lifetime.name, lt.lifetime.span))
+        .collect();
     let mut checker = LifetimeChecker { map: hs };
 
     walk_generics(&mut checker, generics);
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 77f2df03a6a4..9a3defec72df 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -14,9 +14,9 @@ use std::collections::HashMap;
 use syntax::ast;
 use utils::sugg;
 
-use utils::{snippet, span_lint, get_parent_expr, match_trait_method, match_type, multispan_sugg,
-            in_external_macro, is_refutable, span_help_and_lint, is_integer_literal,
-            get_enclosing_block, span_lint_and_then, higher, walk_ptrs_ty, last_path_segment};
+use utils::{snippet, span_lint, get_parent_expr, match_trait_method, match_type, multispan_sugg, in_external_macro,
+            is_refutable, span_help_and_lint, is_integer_literal, get_enclosing_block, span_lint_and_then, higher,
+            walk_ptrs_ty, last_path_segment};
 use utils::paths;
 
 /// **What it does:** Checks for looping over the range of `0..len` of some
@@ -334,8 +334,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                     match *source {
                         MatchSource::Normal |
                         MatchSource::IfLetDesugar { .. } => {
-                            if arms.len() == 2 &&
-                               arms[0].pats.len() == 1 && arms[0].guard.is_none() &&
+                            if arms.len() == 2 && arms[0].pats.len() == 1 && arms[0].guard.is_none() &&
                                arms[1].pats.len() == 1 && arms[1].guard.is_none() &&
                                is_break_expr(&arms[1].body) {
                                 if in_external_macro(cx, expr.span) {
@@ -352,13 +351,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                                                    expr.span,
                                                    "this loop could be written as a `while let` loop",
                                                    |db| {
-                                                       let sug = format!("while let {} = {} {{ .. }}",
-                                                                         snippet(cx, arms[0].pats[0].span, ".."),
-                                                                         snippet(cx, matchexpr.span, ".."));
-                                                       db.span_suggestion(expr.span, "try", sug);
-                                                   });
+                                    let sug = format!("while let {} = {} {{ .. }}",
+                                                      snippet(cx, arms[0].pats[0].span, ".."),
+                                                      snippet(cx, matchexpr.span, ".."));
+                                    db.span_suggestion(expr.span, "try", sug);
+                                });
                             }
-                        }
+                        },
                         _ => (),
                     }
                 }
@@ -370,10 +369,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                     &ExprMethodCall(method_name, _, ref method_args)) = (pat, &match_expr.node) {
                 let iter_expr = &method_args[0];
                 let lhs_constructor = last_path_segment(qpath);
-                if &*method_name.node.as_str() == "next" &&
-                   match_trait_method(cx, match_expr, &paths::ITERATOR) &&
-                   &*lhs_constructor.name.as_str() == "Some" &&
-                   !is_refutable(cx, &pat_args[0]) &&
+                if &*method_name.node.as_str() == "next" && match_trait_method(cx, match_expr, &paths::ITERATOR) &&
+                   &*lhs_constructor.name.as_str() == "Some" && !is_refutable(cx, &pat_args[0]) &&
                    !is_iterator_used_after_while_let(cx, iter_expr) {
                     let iterator = snippet(cx, method_args[0].span, "_");
                     let loop_var = snippet(cx, pat_args[0].span, "_");
@@ -382,9 +379,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                                        expr.span,
                                        "this loop could be written as a `for` loop",
                                        |db| {
-                    db.span_suggestion(expr.span,
-                                       "try",
-                                       format!("for {} in {} {{ .. }}", loop_var, iterator));
+                        db.span_suggestion(expr.span, "try", format!("for {} in {} {{ .. }}", loop_var, iterator));
                     });
                 }
             }
@@ -412,7 +407,7 @@ fn check_for_loop<'a, 'tcx>(
     pat: &'tcx Pat,
     arg: &'tcx Expr,
     body: &'tcx Expr,
-    expr: &'tcx Expr,
+    expr: &'tcx Expr
 ) {
     check_for_loop_range(cx, pat, arg, body, expr);
     check_for_loop_reverse_range(cx, arg, expr);
@@ -428,7 +423,7 @@ fn check_for_loop_range<'a, 'tcx>(
     pat: &'tcx Pat,
     arg: &'tcx Expr,
     body: &'tcx Expr,
-    expr: &'tcx Expr,
+    expr: &'tcx Expr
 ) {
     if let Some(higher::Range { start: Some(start), ref end, limits }) = higher::range(arg) {
         // the var must be a single name
@@ -444,9 +439,9 @@ fn check_for_loop_range<'a, 'tcx>(
             // linting condition: we only indexed one variable
             if visitor.indexed.len() == 1 {
                 let (indexed, indexed_extent) = visitor.indexed
-                                                       .into_iter()
-                                                       .next()
-                                                       .unwrap_or_else(|| unreachable!() /* len == 1 */);
+                    .into_iter()
+                    .next()
+                    .unwrap_or_else(|| unreachable!() /* len == 1 */);
 
                 // ensure that the indexed variable was declared before the loop, see #601
                 if let Some(indexed_extent) = indexed_extent {
@@ -472,10 +467,8 @@ fn check_for_loop_range<'a, 'tcx>(
                             ast::RangeLimits::Closed => {
                                 let end = sugg::Sugg::hir(cx, end, "<count>");
                                 format!(".take({})", end + sugg::ONE)
-                            }
-                            ast::RangeLimits::HalfOpen => {
-                                format!(".take({})", snippet(cx, end.span, ".."))
-                            }
+                            },
+                            ast::RangeLimits::HalfOpen => format!(".take({})", snippet(cx, end.span, "..")),
                         }
                     }
                 } else {
@@ -488,10 +481,10 @@ fn check_for_loop_range<'a, 'tcx>(
                                        expr.span,
                                        &format!("the loop variable `{}` is used to index `{}`", ident.node, indexed),
                                        |db| {
-                        multispan_sugg(db, "consider using an iterator".to_string(), &[
-                            (pat.span, &format!("({}, <item>)", ident.node)),
-                            (arg.span, &format!("{}.iter().enumerate(){}{}", indexed, take, skip)),
-                        ]);
+                        multispan_sugg(db,
+                                       "consider using an iterator".to_string(),
+                                       &[(pat.span, &format!("({}, <item>)", ident.node)),
+                                         (arg.span, &format!("{}.iter().enumerate(){}{}", indexed, take, skip))]);
                     });
                 } else {
                     let repl = if starts_at_zero && take.is_empty() {
@@ -503,12 +496,13 @@ fn check_for_loop_range<'a, 'tcx>(
                     span_lint_and_then(cx,
                                        NEEDLESS_RANGE_LOOP,
                                        expr.span,
-                                       &format!("the loop variable `{}` is only used to index `{}`.", ident.node, indexed),
+                                       &format!("the loop variable `{}` is only used to index `{}`.",
+                                                ident.node,
+                                                indexed),
                                        |db| {
-                        multispan_sugg(db, "consider using an iterator".to_string(), &[
-                            (pat.span, "<item>"),
-                            (arg.span, &repl),
-                        ]);
+                        multispan_sugg(db,
+                                       "consider using an iterator".to_string(),
+                                       &[(pat.span, "<item>"), (arg.span, &repl)]);
                     });
                 }
             }
@@ -544,7 +538,7 @@ fn check_for_loop_reverse_range(cx: &LateContext, arg: &Expr, expr: &Expr) {
                 let (sup, eq) = match (start_idx, end_idx) {
                     (ConstVal::Integral(start_idx), ConstVal::Integral(end_idx)) => {
                         (start_idx > end_idx, start_idx == end_idx)
-                    }
+                    },
                     _ => (false, false),
                 };
 
@@ -562,15 +556,14 @@ fn check_for_loop_reverse_range(cx: &LateContext, arg: &Expr, expr: &Expr) {
                                        expr.span,
                                        "this range is empty so this for loop will never run",
                                        |db| {
-                                           db.span_suggestion(arg.span,
-                                                              "consider using the following if \
-                                                               you are attempting to iterate \
-                                                               over this range in reverse",
-                                                              format!("({end}{dots}{start}).rev()",
-                                                                      end=end_snippet,
-                                                                      dots=dots,
-                                                                      start=start_snippet));
-                                       });
+                        db.span_suggestion(arg.span,
+                                           "consider using the following if you are attempting to iterate over this \
+                                            range in reverse",
+                                           format!("({end}{dots}{start}).rev()",
+                                                   end = end_snippet,
+                                                   dots = dots,
+                                                   start = start_snippet));
+                    });
                 } else if eq && limits != ast::RangeLimits::Closed {
                     // if they are equal, it's also problematic - this loop
                     // will never run.
@@ -608,14 +601,14 @@ fn check_for_loop_arg(cx: &LateContext, pat: &Pat, arg: &Expr, expr: &Expr) {
                                        method_name));
                 }
             } else if &*method_name.as_str() == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
-                    let object = snippet(cx, args[0].span, "_");
-                    span_lint(cx,
-                              EXPLICIT_INTO_ITER_LOOP,
-                              expr.span,
-                              &format!("it is more idiomatic to loop over `{}` instead of `{}.{}()`",
-                                       object,
-                                       object,
-                                       method_name));
+                let object = snippet(cx, args[0].span, "_");
+                span_lint(cx,
+                          EXPLICIT_INTO_ITER_LOOP,
+                          expr.span,
+                          &format!("it is more idiomatic to loop over `{}` instead of `{}.{}()`",
+                                   object,
+                                   object,
+                                   method_name));
 
             } else if &*method_name.as_str() == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
                 span_lint(cx,
@@ -662,7 +655,7 @@ fn check_for_loop_explicit_counter<'a, 'tcx>(
     cx: &LateContext<'a, 'tcx>,
     arg: &'tcx Expr,
     body: &'tcx Expr,
-    expr: &'tcx Expr,
+    expr: &'tcx Expr
 ) {
     // Look for variables that are incremented once per loop iteration.
     let mut visitor = IncrementVisitor {
@@ -713,7 +706,7 @@ fn check_for_loop_over_map_kv<'a, 'tcx>(
     pat: &'tcx Pat,
     arg: &'tcx Expr,
     body: &'tcx Expr,
-    expr: &'tcx Expr,
+    expr: &'tcx Expr
 ) {
     let pat_span = pat.span;
 
@@ -739,10 +732,10 @@ fn check_for_loop_over_map_kv<'a, 'tcx>(
                                    &format!("you seem to want to iterate on a map's {}s", kind),
                                    |db| {
                     let map = sugg::Sugg::hir(cx, arg, "map");
-                    multispan_sugg(db, "use the corresponding method".into(), &[
-                        (pat_span, &snippet(cx, new_pat_span, kind)),
-                        (arg_span, &format!("{}.{}s()", map.maybe_par(), kind)),
-                    ]);
+                    multispan_sugg(db,
+                                   "use the corresponding method".into(),
+                                   &[(pat_span, &snippet(cx, new_pat_span, kind)),
+                                     (arg_span, &format!("{}.{}s()", map.maybe_par(), kind))]);
                 });
             }
         }
@@ -751,11 +744,7 @@ fn check_for_loop_over_map_kv<'a, 'tcx>(
 }
 
 /// Return true if the pattern is a `PatWild` or an ident prefixed with `'_'`.
-fn pat_is_wild<'a, 'tcx: 'a>(
-    cx: &LateContext<'a, 'tcx>,
-    pat: &'tcx PatKind,
-    body: &'tcx Expr,
-) -> bool {
+fn pat_is_wild<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, pat: &'tcx PatKind, body: &'tcx Expr) -> bool {
     match *pat {
         PatKind::Wild => true,
         PatKind::Binding(_, _, ident, None) if ident.node.as_str().starts_with('_') => {
@@ -766,7 +755,7 @@ fn pat_is_wild<'a, 'tcx: 'a>(
             };
             walk_expr(&mut visitor, body);
             !visitor.used
-        }
+        },
         _ => false,
     }
 }
@@ -938,10 +927,11 @@ fn extract_first_expr(block: &Block) -> Option<&Expr> {
         Some(ref expr) if block.stmts.is_empty() => Some(expr),
         None if !block.stmts.is_empty() => {
             match block.stmts[0].node {
-                StmtExpr(ref expr, _) | StmtSemi(ref expr, _) => Some(expr),
+                StmtExpr(ref expr, _) |
+                StmtSemi(ref expr, _) => Some(expr),
                 StmtDecl(..) => None,
             }
-        }
+        },
         _ => None,
     }
 }
@@ -955,7 +945,7 @@ fn is_break_expr(expr: &Expr) -> bool {
                 Some(subexpr) => is_break_expr(subexpr),
                 None => false,
             }
-        }
+        },
         _ => false,
     }
 }
@@ -1004,7 +994,7 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                                 *state = VarState::DontWarn;
                             }
                         }
-                    }
+                    },
                     ExprAssign(ref lhs, _) if lhs.id == expr.id => *state = VarState::DontWarn,
                     ExprAddrOf(mutability, _) if mutability == MutMutable => *state = VarState::DontWarn,
                     _ => (),
@@ -1081,14 +1071,14 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                 match parent.node {
                     ExprAssignOp(_, ref lhs, _) if lhs.id == expr.id => {
                         self.state = VarState::DontWarn;
-                    }
+                    },
                     ExprAssign(ref lhs, ref rhs) if lhs.id == expr.id => {
                         self.state = if is_integer_literal(rhs, 0) && self.depth == 0 {
                             VarState::Warn
                         } else {
                             VarState::DontWarn
                         }
-                    }
+                    },
                     ExprAddrOf(mutability, _) if mutability == MutMutable => self.state = VarState::DontWarn,
                     _ => (),
                 }
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 4539c3c8c105..f04a4b32de2b 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -63,7 +63,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                                 }
                             }
                         }}
-                    }
+                    },
                     ExprPath(ref path) => {
                         if match_path(path, &paths::CLONE) {
                             let type_name = get_type_name(cx, expr, &args[0]).unwrap_or("_");
@@ -75,7 +75,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                                                         type_name),
                                                &format!("try\n{}.cloned()", snippet(cx, args[0].span, "..")));
                         }
-                    }
+                    },
                     _ => (),
                 }
             }
@@ -91,7 +91,7 @@ fn expr_eq_name(expr: &Expr, id: ast::Name) -> bool {
                                    parameters: PathParameters::none(),
                                }];
             !path.global && path.segments[..] == arg_segment
-        }
+        },
         _ => false,
     }
 }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 1d59afd9eace..978e9f5a029f 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -125,7 +125,11 @@ pub struct MatchPass;
 
 impl LintPass for MatchPass {
     fn get_lints(&self) -> LintArray {
-        lint_array!(SINGLE_MATCH, MATCH_REF_PATS, MATCH_BOOL, SINGLE_MATCH_ELSE, MATCH_OVERLAPPING_ARM)
+        lint_array!(SINGLE_MATCH,
+                    MATCH_REF_PATS,
+                    MATCH_BOOL,
+                    SINGLE_MATCH_ELSE,
+                    MATCH_OVERLAPPING_ARM)
     }
 }
 
@@ -192,7 +196,14 @@ fn check_single_match_single_pattern(cx: &LateContext, ex: &Expr, arms: &[Arm],
     }
 }
 
-fn check_single_match_opt_like(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr, ty: ty::Ty, els: Option<&Expr>) {
+fn check_single_match_opt_like(
+    cx: &LateContext,
+    ex: &Expr,
+    arms: &[Arm],
+    expr: &Expr,
+    ty: ty::Ty,
+    els: Option<&Expr>
+) {
     // list of candidate Enums we know will never get any more members
     let candidates = &[(&paths::COW, "Borrowed"),
                        (&paths::COW, "Cow::Borrowed"),
@@ -209,7 +220,7 @@ fn check_single_match_opt_like(cx: &LateContext, ex: &Expr, arms: &[Arm], expr:
                 return;
             }
             path.to_string()
-        }
+        },
         PatKind::Binding(BindByValue(MutImmutable), _, ident, None) => ident.node.to_string(),
         PatKind::Path(ref path) => path.to_string(),
         _ => return,
@@ -272,16 +283,14 @@ fn check_match_bool(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr) {
                                          snippet(cx, ex.span, "b"),
                                          expr_block(cx, true_expr, None, ".."),
                                          expr_block(cx, false_expr, None, "..")))
-                        }
+                        },
                         (false, true) => {
                             Some(format!("if {} {}", snippet(cx, ex.span, "b"), expr_block(cx, true_expr, None, "..")))
-                        }
+                        },
                         (true, false) => {
                             let test = Sugg::hir(cx, ex, "..");
-                            Some(format!("if {} {}",
-                                         !test,
-                                         expr_block(cx, false_expr, None, "..")))
-                        }
+                            Some(format!("if {} {}", !test, expr_block(cx, false_expr, None, "..")))
+                        },
                         (true, true) => None,
                     };
 
@@ -291,7 +300,7 @@ fn check_match_bool(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr) {
                 }
             }
 
-       });
+        });
     }
 }
 
@@ -333,8 +342,7 @@ fn check_match_ref_pats(cx: &LateContext, ex: &Expr, arms: &[Arm], source: Match
                 let ex = Sugg::hir(cx, ex, "..");
                 let template = match_template(expr.span, source, ex.deref());
                 db.span_suggestion(expr.span,
-                                   "instead of prefixing all patterns with `&`, you can \
-                                   dereference the expression",
+                                   "instead of prefixing all patterns with `&`, you can dereference the expression",
                                    template);
             });
         }
@@ -346,11 +354,12 @@ fn all_ranges(cx: &LateContext, arms: &[Arm]) -> Vec<SpannedRange<ConstVal>> {
     arms.iter()
         .flat_map(|arm| {
             if let Arm { ref pats, guard: None, .. } = *arm {
-                pats.iter()
-            } else {
-                [].iter()
-            }.filter_map(|pat| {
-                if_let_chain! {[
+                    pats.iter()
+                } else {
+                    [].iter()
+                }
+                .filter_map(|pat| {
+                    if_let_chain! {[
                     let PatKind::Range(ref lhs, ref rhs) = pat.node,
                     let Ok(lhs) = eval_const_expr_partial(cx.tcx, lhs, ExprTypeChecked, None),
                     let Ok(rhs) = eval_const_expr_partial(cx.tcx, rhs, ExprTypeChecked, None)
@@ -358,15 +367,15 @@ fn all_ranges(cx: &LateContext, arms: &[Arm]) -> Vec<SpannedRange<ConstVal>> {
                     return Some(SpannedRange { span: pat.span, node: (lhs, rhs) });
                 }}
 
-                if_let_chain! {[
+                    if_let_chain! {[
                     let PatKind::Lit(ref value) = pat.node,
                     let Ok(value) = eval_const_expr_partial(cx.tcx, value, ExprTypeChecked, None)
                 ], {
                     return Some(SpannedRange { span: pat.span, node: (value.clone(), value) });
                 }}
 
-                None
-            })
+                    None
+                })
         })
         .collect()
 }
@@ -383,17 +392,17 @@ type TypedRanges = Vec<SpannedRange<ConstInt>>;
 /// `Uint` and `Int` probably don't make sense.
 fn type_ranges(ranges: &[SpannedRange<ConstVal>]) -> TypedRanges {
     ranges.iter()
-          .filter_map(|range| {
-              if let (ConstVal::Integral(start), ConstVal::Integral(end)) = range.node {
-                  Some(SpannedRange {
-                      span: range.span,
-                      node: (start, end),
-                  })
-              } else {
-                  None
-              }
-          })
-          .collect()
+        .filter_map(|range| {
+            if let (ConstVal::Integral(start), ConstVal::Integral(end)) = range.node {
+                Some(SpannedRange {
+                    span: range.span,
+                    node: (start, end),
+                })
+            } else {
+                None
+            }
+        })
+        .collect()
 }
 
 fn is_unit_expr(expr: &Expr) -> bool {
@@ -406,15 +415,15 @@ fn is_unit_expr(expr: &Expr) -> bool {
 
 fn has_only_ref_pats(arms: &[Arm]) -> bool {
     let mapped = arms.iter()
-                     .flat_map(|a| &a.pats)
-                     .map(|p| {
-                         match p.node {
-                             PatKind::Ref(..) => Some(true),  // &-patterns
-                             PatKind::Wild => Some(false),   // an "anything" wildcard is also fine
-                             _ => None,                    // any other pattern is not fine
-                         }
-                     })
-                     .collect::<Option<Vec<bool>>>();
+        .flat_map(|a| &a.pats)
+        .map(|p| {
+            match p.node {
+                PatKind::Ref(..) => Some(true),  // &-patterns
+                PatKind::Wild => Some(false),   // an "anything" wildcard is also fine
+                _ => None,                    // any other pattern is not fine
+            }
+        })
+        .collect::<Option<Vec<bool>>>();
     // look for Some(v) where there's at least one true element
     mapped.map_or(false, |v| v.iter().any(|el| *el))
 }
@@ -481,7 +490,7 @@ pub fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &
                 if ra.node != rb.node {
                     return Some((ra, rb));
                 }
-            }
+            },
             (&Kind::End(a, _), &Kind::Start(b, _)) if a != b => (),
             _ => return Some((a.range(), b.range())),
         }
diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs
index cb8fd62961d8..591b395fe709 100644
--- a/clippy_lints/src/methods.rs
+++ b/clippy_lints/src/methods.rs
@@ -9,10 +9,10 @@ use rustc_const_eval::eval_const_expr_partial;
 use std::borrow::Cow;
 use std::fmt;
 use syntax::codemap::Span;
-use utils::{get_trait_def_id, implements_trait, in_external_macro, in_macro, is_copy, match_path,
-            match_trait_method, match_type, method_chain_args, return_ty, same_tys, snippet,
-            span_lint, span_lint_and_then, span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth,
-            last_path_segment, single_segment_path, match_def_path};
+use utils::{get_trait_def_id, implements_trait, in_external_macro, in_macro, is_copy, match_path, match_trait_method,
+            match_type, method_chain_args, return_ty, same_tys, snippet, span_lint, span_lint_and_then,
+            span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth, last_path_segment, single_segment_path,
+            match_def_path};
 use utils::paths;
 use utils::sugg;
 
@@ -616,15 +616,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                                 lint_single_char_pattern(cx, expr, &args[pos]);
                             }
                         }
-                    }
+                    },
                     _ => (),
                 }
-            }
+            },
             hir::ExprBinary(op, ref lhs, ref rhs) if op.node == hir::BiEq || op.node == hir::BiNe => {
                 if !lint_chars_next(cx, expr, lhs, rhs, op.node == hir::BiEq) {
                     lint_chars_next(cx, expr, rhs, lhs, op.node == hir::BiEq);
                 }
-            }
+            },
             _ => (),
         }
     }
@@ -695,9 +695,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
 /// Checks for the `OR_FUN_CALL` lint.
 fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir::Expr]) {
     /// Check for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
-    fn check_unwrap_or_default(cx: &LateContext, name: &str, fun: &hir::Expr, self_expr: &hir::Expr, arg: &hir::Expr,
-                               or_has_args: bool, span: Span)
-                               -> bool {
+    fn check_unwrap_or_default(
+        cx: &LateContext,
+        name: &str,
+        fun: &hir::Expr,
+        self_expr: &hir::Expr,
+        arg: &hir::Expr,
+        or_has_args: bool,
+        span: Span
+    ) -> bool {
         if or_has_args {
             return false;
         }
@@ -708,7 +714,8 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir:
 
                 if ["default", "new"].contains(&path) {
                     let arg_ty = cx.tcx.tables().expr_ty(arg);
-                    let default_trait_id = if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT) {
+                    let default_trait_id = if let Some(default_trait_id) =
+                        get_trait_def_id(cx, &paths::DEFAULT_TRAIT) {
                         default_trait_id
                     } else {
                         return false;
@@ -716,13 +723,14 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir:
 
                     if implements_trait(cx, arg_ty, default_trait_id, Vec::new()) {
                         span_lint_and_then(cx,
-                                  OR_FUN_CALL,
-                                  span,
-                                  &format!("use of `{}` followed by a call to `{}`", name, path),
-                                  |db| {
-                                      db.span_suggestion(span, "try this",
-                                                          format!("{}.unwrap_or_default()", snippet(cx, self_expr.span, "_")));
-                                  });
+                                           OR_FUN_CALL,
+                                           span,
+                                           &format!("use of `{}` followed by a call to `{}`", name, path),
+                                           |db| {
+                            db.span_suggestion(span,
+                                               "try this",
+                                               format!("{}.unwrap_or_default()", snippet(cx, self_expr.span, "_")));
+                        });
                         return true;
                     }
                 }
@@ -733,8 +741,15 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir:
     }
 
     /// Check for `*or(foo())`.
-    fn check_general_case(cx: &LateContext, name: &str, fun: &hir::Expr, self_expr: &hir::Expr, arg: &hir::Expr, or_has_args: bool,
-                          span: Span) {
+    fn check_general_case(
+        cx: &LateContext,
+        name: &str,
+        fun: &hir::Expr,
+        self_expr: &hir::Expr,
+        arg: &hir::Expr,
+        or_has_args: bool,
+        span: Span
+    ) {
         // don't lint for constant values
         // FIXME: can we `expect` here instead of match?
         if let Some(qualif) = cx.tcx.const_qualif_map.borrow().get(&arg.id) {
@@ -743,18 +758,16 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir:
             }
         }
         // (path, fn_has_argument, methods, suffix)
-        let know_types: &[(&[_], _, &[_], _)] = &[(&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
-                                                  (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
-                                                  (&paths::OPTION,
-                                                   false,
-                                                   &["map_or", "ok_or", "or", "unwrap_or"],
-                                                   "else"),
-                                                  (&paths::RESULT, true, &["or", "unwrap_or"], "else")];
+        let know_types: &[(&[_], _, &[_], _)] =
+            &[(&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
+              (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
+              (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
+              (&paths::RESULT, true, &["or", "unwrap_or"], "else")];
 
         let self_ty = cx.tcx.tables().expr_ty(self_expr);
 
         let (fn_has_arguments, poss, suffix) = if let Some(&(_, fn_has_arguments, poss, suffix)) =
-                                                      know_types.iter().find(|&&i| match_type(cx, self_ty, i.0)) {
+            know_types.iter().find(|&&i| match_type(cx, self_ty, i.0)) {
             (fn_has_arguments, poss, suffix)
         } else {
             return;
@@ -770,7 +783,11 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir:
             (false, true) => snippet(cx, fun.span, ".."),
         };
 
-        span_lint_and_then(cx, OR_FUN_CALL, span, &format!("use of `{}` followed by a function call", name), |db| {
+        span_lint_and_then(cx,
+                           OR_FUN_CALL,
+                           span,
+                           &format!("use of `{}` followed by a function call", name),
+                           |db| {
             db.span_suggestion(span,
                                "try this",
                                format!("{}.{}_{}({})", snippet(cx, self_expr.span, "_"), name, suffix, sugg));
@@ -800,7 +817,9 @@ fn lint_clone_on_copy(cx: &LateContext, expr: &hir::Expr, arg: &hir::Expr, arg_t
                                "using `clone` on a double-reference; \
                                 this will copy the reference instead of cloning the inner type",
                                |db| if let Some(snip) = sugg::Sugg::hir_opt(cx, arg) {
-                                   db.span_suggestion(expr.span, "try dereferencing it", format!("({}).clone()", snip.deref()));
+                                   db.span_suggestion(expr.span,
+                                                      "try dereferencing it",
+                                                      format!("({}).clone()", snip.deref()));
                                });
             return; // don't report clone_on_copy
         }
@@ -824,12 +843,14 @@ fn lint_clone_on_copy(cx: &LateContext, expr: &hir::Expr, arg: &hir::Expr, arg_t
 fn lint_vec_extend(cx: &LateContext, expr: &hir::Expr, args: &[hir::Expr]) {
     let arg_ty = cx.tcx.tables().expr_ty(&args[1]);
     if let Some(slice) = derefs_to_slice(cx, &args[1], arg_ty) {
-        span_lint_and_then(cx, EXTEND_FROM_SLICE, expr.span, "use of `extend` to extend a Vec by a slice", |db| {
+        span_lint_and_then(cx,
+                           EXTEND_FROM_SLICE,
+                           expr.span,
+                           "use of `extend` to extend a Vec by a slice",
+                           |db| {
             db.span_suggestion(expr.span,
                                "try this",
-                               format!("{}.extend_from_slice({})",
-                                       snippet(cx, args[0].span, "_"),
-                                       slice));
+                               format!("{}.extend_from_slice({})", snippet(cx, args[0].span, "_"), slice));
         });
     }
 }
@@ -847,18 +868,14 @@ fn lint_string_extend(cx: &LateContext, expr: &hir::Expr, args: &[hir::Expr]) {
             return;
         };
 
-        span_lint_and_then(
-            cx,
-            STRING_EXTEND_CHARS,
-            expr.span,
-            "calling `.extend(_.chars())`",
-            |db| {
-                db.span_suggestion(expr.span, "try this",
-                        format!("{}.push_str({}{})",
-                                snippet(cx, args[0].span, "_"),
-                                ref_str,
-                                snippet(cx, target.span, "_")));
-            });
+        span_lint_and_then(cx, STRING_EXTEND_CHARS, expr.span, "calling `.extend(_.chars())`", |db| {
+            db.span_suggestion(expr.span,
+                               "try this",
+                               format!("{}.push_str({}{})",
+                                       snippet(cx, args[0].span, "_"),
+                                       ref_str,
+                                       snippet(cx, target.span, "_")));
+        });
     }
 }
 
@@ -888,28 +905,24 @@ fn lint_cstring_as_ptr(cx: &LateContext, expr: &hir::Expr, new: &hir::Expr, unwr
     }}
 }
 
-fn lint_iter_nth(cx: &LateContext, expr: &hir::Expr, iter_args: &[hir::Expr], is_mut: bool){
-    let mut_str = if is_mut { "_mut" } else {""};
+fn lint_iter_nth(cx: &LateContext, expr: &hir::Expr, iter_args: &[hir::Expr], is_mut: bool) {
+    let mut_str = if is_mut { "_mut" } else { "" };
     let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.tcx.tables().expr_ty(&iter_args[0])).is_some() {
         "slice"
-    }
-    else if match_type(cx, cx.tcx.tables().expr_ty(&iter_args[0]), &paths::VEC) {
+    } else if match_type(cx, cx.tcx.tables().expr_ty(&iter_args[0]), &paths::VEC) {
         "Vec"
-    }
-    else if match_type(cx, cx.tcx.tables().expr_ty(&iter_args[0]), &paths::VEC_DEQUE) {
+    } else if match_type(cx, cx.tcx.tables().expr_ty(&iter_args[0]), &paths::VEC_DEQUE) {
         "VecDeque"
-    }
-    else {
+    } else {
         return; // caller is not a type that we want to lint
     };
 
-    span_lint(
-        cx,
-        ITER_NTH,
-        expr.span,
-        &format!("called `.iter{0}().nth()` on a {1}. Calling `.get{0}()` is both faster and more readable",
-                 mut_str, caller_type)
-    );
+    span_lint(cx,
+              ITER_NTH,
+              expr.span,
+              &format!("called `.iter{0}().nth()` on a {1}. Calling `.get{0}()` is both faster and more readable",
+                       mut_str,
+                       caller_type));
 }
 
 fn lint_get_unwrap(cx: &LateContext, expr: &hir::Expr, get_args: &[hir::Expr], is_mut: bool) {
@@ -932,32 +945,29 @@ fn lint_get_unwrap(cx: &LateContext, expr: &hir::Expr, get_args: &[hir::Expr], i
 
     let mut_str = if is_mut { "_mut" } else { "" };
     let borrow_str = if is_mut { "&mut " } else { "&" };
-    span_lint_and_then(
-        cx,
-        GET_UNWRAP,
-        expr.span,
-        &format!("called `.get{0}().unwrap()` on a {1}. Using `[]` is more clear and more concise",
-                 mut_str, caller_type),
-        |db| {
-            db.span_suggestion(
-                expr.span,
-                "try this",
-                format!("{}{}[{}]", borrow_str, snippet(cx, get_args[0].span, "_"),
-                        snippet(cx, get_args[1].span, "_"))
-            );
-        }
-    );
+    span_lint_and_then(cx,
+                       GET_UNWRAP,
+                       expr.span,
+                       &format!("called `.get{0}().unwrap()` on a {1}. Using `[]` is more clear and more concise",
+                                mut_str,
+                                caller_type),
+                       |db| {
+        db.span_suggestion(expr.span,
+                           "try this",
+                           format!("{}{}[{}]",
+                                   borrow_str,
+                                   snippet(cx, get_args[0].span, "_"),
+                                   snippet(cx, get_args[1].span, "_")));
+    });
 }
 
-fn lint_iter_skip_next(cx: &LateContext, expr: &hir::Expr){
+fn lint_iter_skip_next(cx: &LateContext, expr: &hir::Expr) {
     // lint if caller of skip is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-         span_lint(
-            cx,
-            ITER_SKIP_NEXT,
-            expr.span,
-            "called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)`"
-        );
+        span_lint(cx,
+                  ITER_SKIP_NEXT,
+                  expr.span,
+                  "called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)`");
     }
 }
 
@@ -975,9 +985,7 @@ fn derefs_to_slice(cx: &LateContext, expr: &hir::Expr, ty: ty::Ty) -> Option<sug
 
     if let hir::ExprMethodCall(name, _, ref args) = expr.node {
         if &*name.node.as_str() == "iter" && may_slice(cx, cx.tcx.tables().expr_ty(&args[0])) {
-            sugg::Sugg::hir_opt(cx, &args[0]).map(|sugg| {
-                sugg.addr()
-            })
+            sugg::Sugg::hir_opt(cx, &args[0]).map(|sugg| sugg.addr())
         } else {
             None
         }
@@ -991,7 +999,7 @@ fn derefs_to_slice(cx: &LateContext, expr: &hir::Expr, ty: ty::Ty) -> Option<sug
                 } else {
                     None
                 }
-            }
+            },
             _ => None,
         }
     }
@@ -1099,8 +1107,8 @@ fn lint_map_unwrap_or_else(cx: &LateContext, expr: &hir::Expr, map_args: &[hir::
 fn lint_filter_next(cx: &LateContext, expr: &hir::Expr, filter_args: &[hir::Expr]) {
     // lint if caller of `.filter().next()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` \
-                   instead.";
+        let msg = "called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling \
+                   `.find(p)` instead.";
         let filter_snippet = snippet(cx, filter_args[1].span, "..");
         if filter_snippet.lines().count() <= 1 {
             // add note if not multi-line
@@ -1159,12 +1167,17 @@ fn lint_filter_map_flat_map(cx: &LateContext, expr: &hir::Expr, _filter_args: &[
 }
 
 /// lint searching an Iterator followed by `is_some()`
-fn lint_search_is_some(cx: &LateContext, expr: &hir::Expr, search_method: &str, search_args: &[hir::Expr],
-                       is_some_args: &[hir::Expr]) {
+fn lint_search_is_some(
+    cx: &LateContext,
+    expr: &hir::Expr,
+    search_method: &str,
+    search_args: &[hir::Expr],
+    is_some_args: &[hir::Expr]
+) {
     // lint if caller of search is an Iterator
     if match_trait_method(cx, &is_some_args[0], &paths::ITERATOR) {
-        let msg = format!("called `is_some()` after searching an `Iterator` with {}. This is more succinctly expressed \
-                           by calling `any()`.",
+        let msg = format!("called `is_some()` after searching an `Iterator` with {}. This is more succinctly \
+                           expressed by calling `any()`.",
                           search_method);
         let search_snippet = snippet(cx, search_args[1].span, "..");
         if search_snippet.lines().count() <= 1 {
@@ -1227,8 +1240,8 @@ fn lint_single_char_pattern(cx: &LateContext, expr: &hir::Expr, arg: &hir::Expr)
                                arg.span,
                                "single-character string constant used as pattern",
                                |db| {
-                                   db.span_suggestion(expr.span, "try using a char instead:", hint);
-                               });
+                db.span_suggestion(expr.span, "try using a char instead:", hint);
+            });
         }
     }
 }
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index ccfc01a00030..d4198c97d13f 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -46,7 +46,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MinMaxPass {
                     (MinMax::Min, Some(Ordering::Greater)) => (),
                     _ => {
                         span_lint(cx, MIN_MAX, expr.span, "this min/max combination leads to constant result");
-                    }
+                    },
                 }
             }
         }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 0680f6b41a16..409a7de86f06 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -8,10 +8,8 @@ use rustc_const_eval::EvalHint::ExprTypeChecked;
 use rustc_const_eval::eval_const_expr_partial;
 use rustc_const_math::ConstFloat;
 use syntax::codemap::{Span, Spanned, ExpnFormat};
-use utils::{
-    get_item_name, get_parent_expr, implements_trait, in_macro, is_integer_literal, match_path,
-    snippet, span_lint, span_lint_and_then, walk_ptrs_ty, last_path_segment
-};
+use utils::{get_item_name, get_parent_expr, implements_trait, in_macro, is_integer_literal, match_path, snippet,
+            span_lint, span_lint_and_then, walk_ptrs_ty, last_path_segment};
 use utils::sugg::Sugg;
 
 /// **What it does:** Checks for function arguments and let bindings denoted as `ref`.
@@ -161,13 +159,26 @@ pub struct Pass;
 
 impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
-        lint_array!(TOPLEVEL_REF_ARG, CMP_NAN, FLOAT_CMP, CMP_OWNED, MODULO_ONE, REDUNDANT_PATTERN,
+        lint_array!(TOPLEVEL_REF_ARG,
+                    CMP_NAN,
+                    FLOAT_CMP,
+                    CMP_OWNED,
+                    MODULO_ONE,
+                    REDUNDANT_PATTERN,
                     USED_UNDERSCORE_BINDING)
     }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
-    fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, k: FnKind<'tcx>, decl: &'tcx FnDecl, _: &'tcx Expr, _: Span, _: NodeId) {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'a, 'tcx>,
+        k: FnKind<'tcx>,
+        decl: &'tcx FnDecl,
+        _: &'tcx Expr,
+        _: Span,
+        _: NodeId
+    ) {
         if let FnKind::Closure(_) = k {
             // Does not apply to closures
             return;
@@ -236,23 +247,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                 if let Some(name) = get_item_name(cx, expr) {
                     let name = &*name.as_str();
                     if name == "eq" || name == "ne" || name == "is_nan" || name.starts_with("eq_") ||
-                        name.ends_with("_eq") {
+                       name.ends_with("_eq") {
                         return;
                     }
                 }
-                span_lint_and_then(cx,
-                                   FLOAT_CMP,
-                                   expr.span,
-                                   "strict comparison of f32 or f64",
-                                   |db| {
-                                       let lhs = Sugg::hir(cx, left, "..");
-                                       let rhs = Sugg::hir(cx, right, "..");
+                span_lint_and_then(cx, FLOAT_CMP, expr.span, "strict comparison of f32 or f64", |db| {
+                    let lhs = Sugg::hir(cx, left, "..");
+                    let rhs = Sugg::hir(cx, right, "..");
 
-                                       db.span_suggestion(expr.span,
-                                                          "consider comparing them within some error",
-                                                          format!("({}).abs() < error", lhs - rhs));
-                                       db.span_note(expr.span, "std::f32::EPSILON and std::f64::EPSILON are available.");
-                                   });
+                    db.span_suggestion(expr.span,
+                                       "consider comparing them within some error",
+                                       format!("({}).abs() < error", lhs - rhs));
+                    db.span_note(expr.span, "std::f32::EPSILON and std::f64::EPSILON are available.");
+                });
             } else if op == BiRem && is_integer_literal(right, 1) {
                 span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0");
             }
@@ -274,7 +281,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                 } else {
                     None
                 }
-            }
+            },
             ExprField(_, spanned) => {
                 let name = spanned.node.as_str();
                 if name.starts_with('_') && !name.starts_with("__") {
@@ -282,7 +289,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                 } else {
                     None
                 }
-            }
+            },
             _ => None,
         };
         if let Some(binding) = binding {
@@ -290,7 +297,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                       USED_UNDERSCORE_BINDING,
                       expr.span,
                       &format!("used binding `{}` which is prefixed with an underscore. A leading \
-                                underscore signals that a binding will not be used.", binding));
+                                underscore signals that a binding will not be used.",
+                               binding));
         }
     }
 
@@ -300,9 +308,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                 span_lint(cx,
                           REDUNDANT_PATTERN,
                           pat.span,
-                          &format!("the `{} @ _` pattern can be written as just `{}`",
-                                   ident.node,
-                                   ident.node));
+                          &format!("the `{} @ _` pattern can be written as just `{}`", ident.node, ident.node));
             }
         }
     }
@@ -339,9 +345,8 @@ fn is_allowed(cx: &LateContext, expr: &Expr) -> bool {
             f64: ::std::f64::NEG_INFINITY,
         };
 
-        val.try_cmp(zero) == Ok(Ordering::Equal)
-            || val.try_cmp(infinity) == Ok(Ordering::Equal)
-            || val.try_cmp(neg_infinity) == Ok(Ordering::Equal)
+        val.try_cmp(zero) == Ok(Ordering::Equal) || val.try_cmp(infinity) == Ok(Ordering::Equal) ||
+        val.try_cmp(neg_infinity) == Ok(Ordering::Equal)
     } else {
         false
     }
@@ -360,7 +365,7 @@ fn check_to_owned(cx: &LateContext, expr: &Expr, other: &Expr, left: bool, op: S
             } else {
                 return;
             }
-        }
+        },
         ExprCall(ref path, ref v) if v.len() == 1 => {
             if let ExprPath(ref path) = path.node {
                 if match_path(path, &["String", "from_str"]) || match_path(path, &["String", "from"]) {
@@ -371,7 +376,7 @@ fn check_to_owned(cx: &LateContext, expr: &Expr, other: &Expr, left: bool, op: S
             } else {
                 return;
             }
-        }
+        },
         _ => return,
     };
 
@@ -408,8 +413,7 @@ fn check_to_owned(cx: &LateContext, expr: &Expr, other: &Expr, left: bool, op: S
 }
 
 fn is_str_arg(cx: &LateContext, args: &[Expr]) -> bool {
-    args.len() == 1 &&
-        matches!(walk_ptrs_ty(cx.tcx.tables().expr_ty(&args[0])).sty, ty::TyStr)
+    args.len() == 1 && matches!(walk_ptrs_ty(cx.tcx.tables().expr_ty(&args[0])).sty, ty::TyStr)
 }
 
 /// Heuristic to see if an expression is used. Should be compatible with `unused_variables`'s idea
@@ -430,22 +434,21 @@ fn is_used(cx: &LateContext, expr: &Expr) -> bool {
 /// `#[derive(...)`] or the like).
 fn in_attributes_expansion(cx: &LateContext, expr: &Expr) -> bool {
     cx.sess().codemap().with_expn_info(expr.span.expn_id, |info_opt| {
-        info_opt.map_or(false, |info| {
-            matches!(info.callee.format, ExpnFormat::MacroAttribute(_))
-        })
+        info_opt.map_or(false, |info| matches!(info.callee.format, ExpnFormat::MacroAttribute(_)))
     })
 }
 
 /// Test whether `def` is a variable defined outside a macro.
 fn non_macro_local(cx: &LateContext, def: &def::Def) -> bool {
     match *def {
-        def::Def::Local(id) | def::Def::Upvar(id, _, _) => {
+        def::Def::Local(id) |
+        def::Def::Upvar(id, _, _) => {
             if let Some(span) = cx.tcx.map.span_if_local(id) {
                 !in_macro(cx, span)
             } else {
                 true
             }
-        }
+        },
         _ => false,
     }
 }
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index abb9d0fcb49a..e6f044ae9b6a 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -168,9 +168,14 @@ pub struct MiscEarly;
 
 impl LintPass for MiscEarly {
     fn get_lints(&self) -> LintArray {
-        lint_array!(UNNEEDED_FIELD_PATTERN, DUPLICATE_UNDERSCORE_ARGUMENT, REDUNDANT_CLOSURE_CALL,
-                    DOUBLE_NEG, MIXED_CASE_HEX_LITERALS, UNSEPARATED_LITERAL_SUFFIX,
-                    ZERO_PREFIXED_LITERAL, BUILTIN_TYPE_SHADOW)
+        lint_array!(UNNEEDED_FIELD_PATTERN,
+                    DUPLICATE_UNDERSCORE_ARGUMENT,
+                    REDUNDANT_CLOSURE_CALL,
+                    DOUBLE_NEG,
+                    MIXED_CASE_HEX_LITERALS,
+                    UNSEPARATED_LITERAL_SUFFIX,
+                    ZERO_PREFIXED_LITERAL,
+                    BUILTIN_TYPE_SHADOW)
     }
 }
 
@@ -272,14 +277,14 @@ impl EarlyLintPass for MiscEarly {
                                            expr.span,
                                            "Try not to call a closure in the expression where it is declared.",
                                            |db| {
-                                               if decl.inputs.is_empty() {
-                                                   let hint = snippet(cx, block.span, "..").into_owned();
-                                                   db.span_suggestion(expr.span, "Try doing something like: ", hint);
-                                               }
-                                           });
+                            if decl.inputs.is_empty() {
+                                let hint = snippet(cx, block.span, "..").into_owned();
+                                db.span_suggestion(expr.span, "Try doing something like: ", hint);
+                            }
+                        });
                     }
                 }
-            }
+            },
             ExprKind::Unary(UnOp::Neg, ref inner) => {
                 if let ExprKind::Unary(UnOp::Neg, _) = inner.node {
                     span_lint(cx,
@@ -287,7 +292,7 @@ impl EarlyLintPass for MiscEarly {
                               expr.span,
                               "`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op");
                 }
-            }
+            },
             ExprKind::Lit(ref lit) => {
                 if_let_chain! {[
                     let LitKind::Int(value, ..) = lit.node,
@@ -328,8 +333,16 @@ impl EarlyLintPass for MiscEarly {
                                            lit.span,
                                            "this is a decimal constant",
                                            |db| {
-                            db.span_suggestion(lit.span, "if you mean to use a decimal constant, remove the `0` to remove confusion:", src[1..].to_string());
-                            db.span_suggestion(lit.span, "if you mean to use an octal constant, use `0o`:", format!("0o{}", &src[1..]));
+                            db.span_suggestion(
+                                lit.span,
+                                "if you mean to use a decimal constant, remove the `0` to remove confusion:",
+                                src[1..].to_string(),
+                            );
+                            db.span_suggestion(
+                                lit.span,
+                                "if you mean to use an octal constant, use `0o`:",
+                                format!("0o{}", &src[1..]),
+                            );
                         });
                     }
                 }}
@@ -351,8 +364,8 @@ impl EarlyLintPass for MiscEarly {
                         prev = ch;
                     }
                 }}
-            }
-            _ => ()
+            },
+            _ => (),
         }
     }
 
@@ -369,7 +382,12 @@ impl EarlyLintPass for MiscEarly {
                 let ExprKind::Path(_, ref path) = closure.node
             ], {
                 if sp_ident.node == (&path.segments[0]).identifier {
-                    span_lint(cx, REDUNDANT_CLOSURE_CALL, second.span, "Closure called just once immediately after it was declared");
+                    span_lint(
+                        cx,
+                        REDUNDANT_CLOSURE_CALL,
+                        second.span,
+                        "Closure called just once immediately after it was declared",
+                    );
                 }
             }}
         }
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 2f3bdeb053c8..70696ea3908b 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -1,21 +1,24 @@
-/* This file incorporates work covered by the following copyright and
- * permission notice:
- *   Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
- *   file at the top-level directory of this distribution and at
- *   http://rust-lang.org/COPYRIGHT.
- *
- *   Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
- *   http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
- *   <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
- *   option. This file may not be copied, modified, or distributed
- *   except according to those terms.
- */
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//   Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+//   file at the top-level directory of this distribution and at
+//   http://rust-lang.org/COPYRIGHT.
+//
+//   Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+//   http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+//   <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+//   option. This file may not be copied, modified, or distributed
+//   except according to those terms.
+//
 
-/* Note: More specifically this lint is largely inspired (aka copied) from *rustc*'s
- * [`missing_doc`].
- *
- * [`missing_doc`]: https://github.com/rust-lang/rust/blob/d6d05904697d89099b55da3331155392f1db9c00/src/librustc_lint/builtin.rs#L246
- */
+// Note: More specifically this lint is largely inspired (aka copied) from *rustc*'s
+// [`missing_doc`].
+//
+// [`missing_doc`]:
+// https://github.
+// com/rust-lang/rust/blob/d6d05904697d89099b55da3331155392f1db9c00/src/librustc_lint/builtin.
+// rs#L246
+//
 
 use rustc::hir;
 use rustc::lint::*;
@@ -51,20 +54,14 @@ impl ::std::default::Default for MissingDoc {
 
 impl MissingDoc {
     pub fn new() -> MissingDoc {
-        MissingDoc {
-            doc_hidden_stack: vec![false],
-        }
+        MissingDoc { doc_hidden_stack: vec![false] }
     }
 
     fn doc_hidden(&self) -> bool {
         *self.doc_hidden_stack.last().expect("empty doc_hidden_stack")
     }
 
-    fn check_missing_docs_attrs(&self,
-                               cx: &LateContext,
-                               attrs: &[ast::Attribute],
-                               sp: Span,
-                               desc: &'static str) {
+    fn check_missing_docs_attrs(&self, cx: &LateContext, attrs: &[ast::Attribute], sp: Span, desc: &'static str) {
         // If we're building a test harness, then warning about
         // documentation is probably not really relevant right now.
         if cx.sess().opts.test {
@@ -82,7 +79,8 @@ impl MissingDoc {
 
         let has_doc = attrs.iter().any(|a| a.is_value_str() && a.name() == "doc");
         if !has_doc {
-            cx.span_lint(MISSING_DOCS_IN_PRIVATE_ITEMS, sp,
+            cx.span_lint(MISSING_DOCS_IN_PRIVATE_ITEMS,
+                         sp,
                          &format!("missing documentation for {}", desc));
         }
     }
@@ -96,8 +94,10 @@ impl LintPass for MissingDoc {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
     fn enter_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, attrs: &'tcx [ast::Attribute]) {
-        let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| {
-            attr.check_name("doc") && match attr.meta_item_list() {
+        let doc_hidden = self.doc_hidden() ||
+                         attrs.iter().any(|attr| {
+            attr.check_name("doc") &&
+            match attr.meta_item_list() {
                 None => false,
                 Some(l) => attr::list_contains_name(&l[..], "hidden"),
             }
@@ -151,9 +151,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
             ty::TraitContainer(_) => return,
             ty::ImplContainer(cid) => {
                 if cx.tcx.impl_trait_ref(cid).is_some() {
-                    return
+                    return;
                 }
-            }
+            },
         }
 
         let desc = match impl_item.node {
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 40bb77871dbc..7d4326828cb1 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -64,7 +64,10 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
             intravisit::walk_expr(self, body);
         } else if let hir::ExprAddrOf(hir::MutMutable, ref e) = expr.node {
             if let hir::ExprAddrOf(hir::MutMutable, _) = e.node {
-                span_lint(self.cx, MUT_MUT, expr.span, "generally you want to avoid `&mut &mut _` if possible");
+                span_lint(self.cx,
+                          MUT_MUT,
+                          expr.span,
+                          "generally you want to avoid `&mut &mut _` if possible");
             } else if let TyRef(_, TypeAndMut { mutbl: hir::MutMutable, .. }) = self.cx.tcx.tables().expr_ty(e).sty {
                 span_lint(self.cx,
                           MUT_MUT,
@@ -77,7 +80,10 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
     fn visit_ty(&mut self, ty: &'tcx hir::Ty) {
         if let hir::TyRptr(_, hir::MutTy { ty: ref pty, mutbl: hir::MutMutable }) = ty.node {
             if let hir::TyRptr(_, hir::MutTy { mutbl: hir::MutMutable, .. }) = pty.node {
-                span_lint(self.cx, MUT_MUT, ty.span, "generally you want to avoid `&mut &mut _` if possible");
+                span_lint(self.cx,
+                          MUT_MUT,
+                          ty.span,
+                          "generally you want to avoid `&mut &mut _` if possible");
             }
 
         }
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index d2cd0a329143..7e7733bed80c 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -38,19 +38,18 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnecessaryMutPassed {
         match e.node {
             ExprCall(ref fn_expr, ref arguments) => {
                 let function_type = borrowed_table.node_types
-                                                  .get(&fn_expr.id)
-                                                  .expect("A function with an unknown type is called. \
-                                                           If this happened, the compiler would have \
-                                                           aborted the compilation long ago");
+                    .get(&fn_expr.id)
+                    .expect("A function with an unknown type is called. If this happened, the compiler would have \
+                             aborted the compilation long ago");
                 if let ExprPath(ref path) = fn_expr.node {
                     check_arguments(cx, arguments, function_type, &path.to_string());
                 }
-            }
+            },
             ExprMethodCall(ref name, _, ref arguments) => {
                 let method_call = MethodCall::expr(e.id);
                 let method_type = borrowed_table.method_map.get(&method_call).expect("This should never happen.");
                 check_arguments(cx, arguments, method_type.ty, &name.node.as_str())
-            }
+            },
             _ => (),
         }
     }
@@ -71,11 +70,11 @@ fn check_arguments(cx: &LateContext, arguments: &[Expr], type_definition: &TyS,
                                       argument.span,
                                       &format!("The function/method \"{}\" doesn't need a mutable reference", name));
                         }
-                    }
+                    },
                     _ => (),
                 }
             }
-        }
+        },
         _ => (),
     }
 }
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 3b08ebdbc8e0..5eae3034aff3 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -62,11 +62,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool {
         if let ExprIf(ref pred, ref then_block, Some(ref else_expr)) = e.node {
             let reduce = |ret, not| {
                 let snip = Sugg::hir(cx, pred, "<predicate>");
-                let snip = if not {
-                    !snip
-                } else {
-                    snip
-                };
+                let snip = if not { !snip } else { snip };
 
                 let hint = if ret {
                     format!("return {}", snip)
@@ -79,8 +75,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool {
                                    e.span,
                                    "this if-then-else expression returns a bool literal",
                                    |db| {
-                                       db.span_suggestion(e.span, "you can reduce it to", hint);
-                                   });
+                    db.span_suggestion(e.span, "you can reduce it to", hint);
+                });
             };
             match (fetch_bool_block(then_block), fetch_bool_expr(else_expr)) {
                 (RetBool(true), RetBool(true)) |
@@ -89,14 +85,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool {
                               NEEDLESS_BOOL,
                               e.span,
                               "this if-then-else expression will always return true");
-                }
+                },
                 (RetBool(false), RetBool(false)) |
                 (Bool(false), Bool(false)) => {
                     span_lint(cx,
                               NEEDLESS_BOOL,
                               e.span,
                               "this if-then-else expression will always return false");
-                }
+                },
                 (RetBool(true), RetBool(false)) => reduce(true, false),
                 (Bool(true), Bool(false)) => reduce(false, false),
                 (RetBool(false), RetBool(true)) => reduce(true, true),
@@ -128,9 +124,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison {
                                        e.span,
                                        "equality checks against true are unnecessary",
                                        |db| {
-                                           db.span_suggestion(e.span, "try simplifying it as shown:", hint);
-                                       });
-                }
+                        db.span_suggestion(e.span, "try simplifying it as shown:", hint);
+                    });
+                },
                 (Other, Bool(true)) => {
                     let hint = snippet(cx, left_side.span, "..").into_owned();
                     span_lint_and_then(cx,
@@ -138,9 +134,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison {
                                        e.span,
                                        "equality checks against true are unnecessary",
                                        |db| {
-                                           db.span_suggestion(e.span, "try simplifying it as shown:", hint);
-                                       });
-                }
+                        db.span_suggestion(e.span, "try simplifying it as shown:", hint);
+                    });
+                },
                 (Bool(false), Other) => {
                     let hint = Sugg::hir(cx, right_side, "..");
                     span_lint_and_then(cx,
@@ -148,9 +144,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison {
                                        e.span,
                                        "equality checks against false can be replaced by a negation",
                                        |db| {
-                                           db.span_suggestion(e.span, "try simplifying it as shown:", (!hint).to_string());
-                                       });
-                }
+                        db.span_suggestion(e.span, "try simplifying it as shown:", (!hint).to_string());
+                    });
+                },
                 (Other, Bool(false)) => {
                     let hint = Sugg::hir(cx, left_side, "..");
                     span_lint_and_then(cx,
@@ -158,9 +154,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison {
                                        e.span,
                                        "equality checks against false can be replaced by a negation",
                                        |db| {
-                                           db.span_suggestion(e.span, "try simplifying it as shown:", (!hint).to_string());
-                                       });
-                }
+                        db.span_suggestion(e.span, "try simplifying it as shown:", (!hint).to_string());
+                    });
+                },
                 _ => (),
             }
         }
@@ -186,7 +182,7 @@ fn fetch_bool_block(block: &Block) -> Expression {
             } else {
                 Expression::Other
             }
-        }
+        },
         _ => Expression::Other,
     }
 }
@@ -200,13 +196,13 @@ fn fetch_bool_expr(expr: &Expr) -> Expression {
             } else {
                 Expression::Other
             }
-        }
+        },
         ExprRet(Some(ref expr)) => {
             match fetch_bool_expr(expr) {
                 Expression::Bool(value) => Expression::RetBool(value),
                 _ => Expression::Other,
             }
-        }
+        },
         _ => Expression::Other,
     }
 }
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 935e0da8c3ed..f05fdaab1764 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -41,7 +41,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrow {
         }
         if let ExprAddrOf(MutImmutable, ref inner) = e.node {
             if let ty::TyRef(..) = cx.tcx.tables().expr_ty(inner).sty {
-                if let Some(&ty::adjustment::Adjust::DerefRef { autoderefs, autoref, .. }) = cx.tcx.tables.borrow().adjustments.get(&e.id).map(|a| &a.kind) {
+                if let Some(&ty::adjustment::Adjust::DerefRef { autoderefs, autoref, .. }) =
+                    cx.tcx.tables.borrow().adjustments.get(&e.id).map(|a| &a.kind) {
                     if autoderefs > 1 && autoref.is_some() {
                         span_lint(cx,
                                   NEEDLESS_BORROW,
@@ -61,10 +62,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrow {
             if let ty::TyRef(_, ref tam) = cx.tcx.tables().pat_ty(pat).sty {
                 if tam.mutbl == MutImmutable {
                     if let ty::TyRef(..) = tam.ty.sty {
-                        span_lint(cx,
-                                  NEEDLESS_BORROW,
-                                  pat.span,
-                                  "this pattern creates a reference to a reference")
+                        span_lint(cx, NEEDLESS_BORROW, pat.span, "this pattern creates a reference to a reference")
                     }
                 }
             }
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index f4a7ebee590f..9c7b132dd3d6 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -97,7 +97,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault {
         decl: &'tcx hir::FnDecl,
         _: &'tcx hir::Expr,
         span: Span,
-        id: ast::NodeId,
+        id: ast::NodeId
     ) {
         if in_external_macro(cx, span) {
             return;
@@ -161,7 +161,7 @@ fn can_derive_default<'t, 'c>(ty: ty::Ty<'t>, cx: &LateContext<'c, 't>, default_
                 }
             }
             true
-        }
+        },
         _ => false,
     }
 }
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 4a4b73b697f8..a87c9d0f7365 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -66,7 +66,7 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool {
                 Some(ref base) => has_no_effect(cx, base),
                 None => true,
             }
-        }
+        },
         Expr_::ExprCall(ref callee, ref args) => {
             if let Expr_::ExprPath(ref qpath) = callee.node {
                 let def = cx.tcx.tables().qpath_def(qpath, callee.id);
@@ -80,7 +80,7 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool {
             } else {
                 false
             }
-        }
+        },
         Expr_::ExprBlock(ref block) => {
             block.stmts.is_empty() &&
             if let Some(ref expr) = block.expr {
@@ -88,7 +88,7 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool {
             } else {
                 false
             }
-        }
+        },
         _ => false,
     }
 }
@@ -148,7 +148,7 @@ fn reduce_expression<'a>(cx: &LateContext, expr: &'a Expr) -> Option<Vec<&'a Exp
         Expr_::ExprBox(ref inner) => reduce_expression(cx, inner).or_else(|| Some(vec![inner])),
         Expr_::ExprStruct(_, ref fields, ref base) => {
             Some(fields.iter().map(|f| &f.expr).chain(base).map(Deref::deref).collect())
-        }
+        },
         Expr_::ExprCall(ref callee, ref args) => {
             if let Expr_::ExprPath(ref qpath) = callee.node {
                 let def = cx.tcx.tables().qpath_def(qpath, callee.id);
@@ -162,7 +162,7 @@ fn reduce_expression<'a>(cx: &LateContext, expr: &'a Expr) -> Option<Vec<&'a Exp
             } else {
                 None
             }
-        }
+        },
         Expr_::ExprBlock(ref block) => {
             if block.stmts.is_empty() {
                 block.expr.as_ref().and_then(|e| {
@@ -176,7 +176,7 @@ fn reduce_expression<'a>(cx: &LateContext, expr: &'a Expr) -> Option<Vec<&'a Exp
             } else {
                 None
             }
-        }
+        },
         _ => None,
     }
 }
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 6ccdb6ee1459..a195673a53bc 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -88,7 +88,7 @@ impl<'a, 'tcx: 'a, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> {
                         self.visit_pat(&field.node.pat);
                     }
                 }
-            }
+            },
             _ => walk_pat(self, pat),
         }
     }
@@ -210,8 +210,8 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
                     diag.span_help(span,
                                    &format!("separate the discriminating character by an \
                                                                 underscore like: `{}_{}`",
-                                                               &interned_name[..split],
-                                                               &interned_name[split..]));
+                                            &interned_name[..split],
+                                            &interned_name[split..]));
                 }
             });
             return;
@@ -241,7 +241,8 @@ impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> {
         if let Some(ref init) = local.init {
             self.apply(|this| walk_expr(this, &**init));
         }
-        // add the pattern after the expression because the bindings aren't available yet in the init expression
+        // add the pattern after the expression because the bindings aren't available yet in the init
+        // expression
         SimilarNamesNameVisitor(self).visit_pat(&*local.pat);
     }
     fn visit_block(&mut self, blk: &'tcx Block) {
@@ -249,7 +250,8 @@ impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> {
     }
     fn visit_arm(&mut self, arm: &'tcx Arm) {
         self.apply(|this| {
-            // just go through the first pattern, as either all patterns bind the same bindings or rustc would have errored much earlier
+            // just go through the first pattern, as either all patterns
+            // bind the same bindings or rustc would have errored much earlier
             SimilarNamesNameVisitor(this).visit_pat(&arm.pats[0]);
             this.apply(|this| walk_expr(this, &arm.body));
         });
diff --git a/clippy_lints/src/ok_if_let.rs b/clippy_lints/src/ok_if_let.rs
index 6ac49c1f575d..65b13688ff62 100644
--- a/clippy_lints/src/ok_if_let.rs
+++ b/clippy_lints/src/ok_if_let.rs
@@ -15,7 +15,7 @@ use utils::{paths, method_chain_args, span_help_and_lint, match_type, snippet};
 ///         vec.push(bench)
 ///     }
 /// }
-///```
+/// ```
 /// Could be written:
 ///
 /// ```rust
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index f102bdcab33d..4216345e48e7 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -71,36 +71,32 @@ fn get_open_options(cx: &LateContext, argument: &Expr, options: &mut Vec<(OpenOp
             let argument_option = match arguments[1].node {
                 ExprLit(ref span) => {
                     if let Spanned { node: LitKind::Bool(lit), .. } = **span {
-                        if lit {
-                            Argument::True
-                        } else {
-                            Argument::False
-                        }
+                        if lit { Argument::True } else { Argument::False }
                     } else {
                         return; // The function is called with a literal
                                 // which is not a boolean literal. This is theoretically
                                 // possible, but not very likely.
                     }
-                }
+                },
                 _ => Argument::Unknown,
             };
 
             match &*name.node.as_str() {
                 "create" => {
                     options.push((OpenOption::Create, argument_option));
-                }
+                },
                 "append" => {
                     options.push((OpenOption::Append, argument_option));
-                }
+                },
                 "truncate" => {
                     options.push((OpenOption::Truncate, argument_option));
-                }
+                },
                 "read" => {
                     options.push((OpenOption::Read, argument_option));
-                }
+                },
                 "write" => {
                     options.push((OpenOption::Write, argument_option));
-                }
+                },
                 _ => (),
             }
 
@@ -111,11 +107,8 @@ fn get_open_options(cx: &LateContext, argument: &Expr, options: &mut Vec<(OpenOp
 
 fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span: Span) {
     let (mut create, mut append, mut truncate, mut read, mut write) = (false, false, false, false, false);
-    let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) = (false,
-                                                                                           false,
-                                                                                           false,
-                                                                                           false,
-                                                                                           false);
+    let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) =
+        (false, false, false, false, false);
     // This code is almost duplicated (oh, the irony), but I haven't found a way to unify it.
 
     for option in options {
@@ -130,7 +123,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span
                     create = true
                 }
                 create_arg = create_arg || (arg == Argument::True);;
-            }
+            },
             (OpenOption::Append, arg) => {
                 if append {
                     span_lint(cx,
@@ -141,7 +134,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span
                     append = true
                 }
                 append_arg = append_arg || (arg == Argument::True);;
-            }
+            },
             (OpenOption::Truncate, arg) => {
                 if truncate {
                     span_lint(cx,
@@ -152,7 +145,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span
                     truncate = true
                 }
                 truncate_arg = truncate_arg || (arg == Argument::True);
-            }
+            },
             (OpenOption::Read, arg) => {
                 if read {
                     span_lint(cx,
@@ -163,7 +156,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span
                     read = true
                 }
                 read_arg = read_arg || (arg == Argument::True);;
-            }
+            },
             (OpenOption::Write, arg) => {
                 if write {
                     span_lint(cx,
@@ -174,7 +167,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span
                     write = true
                 }
                 write_arg = write_arg || (arg == Argument::True);;
-            }
+            },
         }
     }
 
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index a09ff3bebf68..f2e478865497 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -44,12 +44,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OverflowCheckConditional {
         ], {
             if let BinOp_::BiLt = op.node {
                 if let BinOp_::BiAdd = op2.node {
-                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C overflow conditions that will fail in Rust.");
+                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
+                        "You are trying to use classic C overflow conditions that will fail in Rust.");
                 }
             }
             if let BinOp_::BiGt = op.node {
                 if let BinOp_::BiSub = op2.node {
-                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C underflow conditions that will fail in Rust.");
+                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
+                        "You are trying to use classic C underflow conditions that will fail in Rust.");
                 }
             }
         }}
@@ -66,12 +68,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OverflowCheckConditional {
         ], {
             if let BinOp_::BiGt = op.node {
                 if let BinOp_::BiAdd = op2.node {
-                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C overflow conditions that will fail in Rust.");
+                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
+                        "You are trying to use classic C overflow conditions that will fail in Rust.");
                 }
             }
             if let BinOp_::BiLt = op.node {
                 if let BinOp_::BiSub = op2.node {
-                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C underflow conditions that will fail in Rust.");
+                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
+                        "You are trying to use classic C underflow conditions that will fail in Rust.");
                 }
             }
         }}
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index 1d10fb19c733..146706646ae4 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -49,7 +49,7 @@ impl EarlyLintPass for Precedence {
                                        snippet(cx, left.span, ".."),
                                        op.to_string(),
                                        snippet(cx, right.span, "..")));
-                }
+                },
                 (true, false) => {
                     span_lint(cx,
                               PRECEDENCE,
@@ -59,7 +59,7 @@ impl EarlyLintPass for Precedence {
                                        snippet(cx, left.span, ".."),
                                        op.to_string(),
                                        snippet(cx, right.span, "..")));
-                }
+                },
                 (false, true) => {
                     span_lint(cx,
                               PRECEDENCE,
@@ -69,7 +69,7 @@ impl EarlyLintPass for Precedence {
                                        snippet(cx, left.span, ".."),
                                        op.to_string(),
                                        snippet(cx, right.span, "..")));
-                }
+                },
                 _ => (),
             }
         }
@@ -88,7 +88,7 @@ impl EarlyLintPass for Precedence {
                                           &format!("unary minus has lower precedence than method call. Consider \
                                                     adding parentheses to clarify your intent: -({})",
                                                    snippet(cx, rhs.span, "..")));
-                            }
+                            },
                             _ => (),
                         }
                     }
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 1461189946c1..2f74390cc73e 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -117,7 +117,7 @@ fn is_null_path(expr: &Expr) -> bool {
     if let ExprCall(ref pathexp, ref args) = expr.node {
         if args.is_empty() {
             if let ExprPath(ref path) = pathexp.node {
-                return match_path(path, &paths::PTR_NULL) || match_path(path, &paths::PTR_NULL_MUT)
+                return match_path(path, &paths::PTR_NULL) || match_path(path, &paths::PTR_NULL_MUT);
             }
         }
     }
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 78f097002039..01829ffea45b 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -52,8 +52,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StepByZero {
             let name = &*name.as_str();
 
             // Range with step_by(0).
-            if name == "step_by" && args.len() == 2 && has_step_by(cx, &args[0]) &&
-               is_integer_literal(&args[1], 0) {
+            if name == "step_by" && args.len() == 2 && has_step_by(cx, &args[0]) && is_integer_literal(&args[1], 0) {
                 span_lint(cx,
                           RANGE_STEP_BY_ZERO,
                           expr.span,
@@ -94,7 +93,6 @@ fn has_step_by(cx: &LateContext, expr: &Expr) -> bool {
     let ty = cx.tcx.tables().expr_ty(expr);
 
     // Note: `RangeTo`, `RangeToInclusive` and `RangeFull` don't have step_by
-    match_type(cx, ty, &paths::RANGE)
-        || match_type(cx, ty, &paths::RANGE_FROM)
-        || match_type(cx, ty, &paths::RANGE_INCLUSIVE)
+    match_type(cx, ty, &paths::RANGE) || match_type(cx, ty, &paths::RANGE_FROM) ||
+    match_type(cx, ty, &paths::RANGE_INCLUSIVE)
 }
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 19e8a3c7d146..7c5c5713550a 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,4 +1,4 @@
-use syntax::ast::{Expr,ExprKind,UnOp};
+use syntax::ast::{Expr, ExprKind, UnOp};
 use rustc::lint::*;
 use utils::{span_lint_and_then, snippet};
 
@@ -40,15 +40,9 @@ impl EarlyLintPass for Pass {
     fn check_expr(&mut self, cx: &EarlyContext, e: &Expr) {
         if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.node {
             if let ExprKind::AddrOf(_, ref addrof_target) = without_parens(deref_target).node {
-                span_lint_and_then(
-                    cx,
-                    DEREF_ADDROF,
-                    e.span,
-                    "immediately dereferencing a reference",
-                    |db| {
-                        db.span_suggestion(e.span, "try this",
-                                             format!("{}", snippet(cx, addrof_target.span, "_")));
-                    });
+                span_lint_and_then(cx, DEREF_ADDROF, e.span, "immediately dereferencing a reference", |db| {
+                    db.span_suggestion(e.span, "try this", format!("{}", snippet(cx, addrof_target.span, "_")));
+                });
             }
         }
     }
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 6e6b6156d6e6..31ac194ca7bf 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -145,7 +145,7 @@ fn str_span(base: Span, s: &str, c: usize) -> Span {
                 hi: base.lo + BytePos(h as u32),
                 ..base
             }
-        }
+        },
         _ => base,
     }
 }
@@ -172,17 +172,18 @@ fn is_trivial_regex(s: &regex_syntax::Expr) -> Option<&'static str> {
                         (&Expr::Literal { .. }, &Expr::EndText) => Some("consider using `str::ends_with`"),
                         _ => None,
                     }
-                }
+                },
                 3 => {
-                    if let (&Expr::StartText, &Expr::Literal {..}, &Expr::EndText) = (&exprs[0], &exprs[1], &exprs[2]) {
+                    if let (&Expr::StartText, &Expr::Literal { .. }, &Expr::EndText) =
+                        (&exprs[0], &exprs[1], &exprs[2]) {
                         Some("consider using `==` on `str`s")
                     } else {
                         None
                     }
-                }
+                },
                 _ => None,
             }
-        }
+        },
         _ => None,
     }
 }
@@ -213,14 +214,13 @@ fn check_regex(cx: &LateContext, expr: &Expr, utf8: bool) {
                                            "trivial regex",
                                            &format!("consider using {}", repl));
                     }
-                }
+                },
                 Err(e) => {
                     span_lint(cx,
                               INVALID_REGEX,
                               str_span(expr.span, r, e.position()),
-                              &format!("regex syntax error: {}",
-                                       e.description()));
-                }
+                              &format!("regex syntax error: {}", e.description()));
+                },
             }
         }
     } else if let Some(r) = const_str(cx, expr) {
@@ -233,15 +233,13 @@ fn check_regex(cx: &LateContext, expr: &Expr, utf8: bool) {
                                        "trivial regex",
                                        &format!("consider using {}", repl));
                 }
-            }
+            },
             Err(e) => {
                 span_lint(cx,
                           INVALID_REGEX,
                           expr.span,
-                          &format!("regex syntax error on position {}: {}",
-                                   e.position(),
-                                   e.description()));
-            }
+                          &format!("regex syntax error on position {}: {}", e.position(), e.description()));
+            },
         }
     }
 }
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index d79913b2c15b..b9054f72164b 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -48,9 +48,10 @@ impl ReturnPass {
     fn check_block_return(&mut self, cx: &EarlyContext, block: &ast::Block) {
         if let Some(stmt) = block.stmts.last() {
             match stmt.node {
-                ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => {
+                ast::StmtKind::Expr(ref expr) |
+                ast::StmtKind::Semi(ref expr) => {
                     self.check_final_expr(cx, expr, Some(stmt.span));
-                }
+                },
                 _ => (),
             }
         }
@@ -65,24 +66,24 @@ impl ReturnPass {
                 if !expr.attrs.iter().any(attr_is_cfg) {
                     self.emit_return_lint(cx, span.expect("`else return` is not possible"), inner.span);
                 }
-            }
+            },
             // a whole block? check it!
             ast::ExprKind::Block(ref block) => {
                 self.check_block_return(cx, block);
-            }
+            },
             // an if/if let expr, check both exprs
             // note, if without else is going to be a type checking error anyways
             // (except for unit type functions) so we don't match it
             ast::ExprKind::If(_, ref ifblock, Some(ref elsexpr)) => {
                 self.check_block_return(cx, ifblock);
                 self.check_final_expr(cx, elsexpr, None);
-            }
+            },
             // a match expr, check all arms
             ast::ExprKind::Match(_, ref arms) => {
                 for arm in arms {
                     self.check_final_expr(cx, &arm.body, Some(arm.body.span));
                 }
-            }
+            },
             _ => (),
         }
     }
@@ -135,7 +136,8 @@ impl LintPass for ReturnPass {
 impl EarlyLintPass for ReturnPass {
     fn check_fn(&mut self, cx: &EarlyContext, kind: FnKind, _: &ast::FnDecl, _: Span, _: ast::NodeId) {
         match kind {
-            FnKind::ItemFn(.., block) | FnKind::Method(.., block) => self.check_block_return(cx, block),
+            FnKind::ItemFn(.., block) |
+            FnKind::Method(.., block) => self.check_block_return(cx, block),
             FnKind::Closure(body) => self.check_final_expr(cx, body, None),
         }
     }
@@ -152,4 +154,3 @@ fn attr_is_cfg(attr: &ast::Attribute) -> bool {
         false
     }
 }
-
diff --git a/clippy_lints/src/serde.rs b/clippy_lints/src/serde.rs
index ec4bce557061..02faf7a204fb 100644
--- a/clippy_lints/src/serde.rs
+++ b/clippy_lints/src/serde.rs
@@ -46,8 +46,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Serde {
                             span_lint(cx,
                                       SERDE_API_MISUSE,
                                       span,
-                                      "you should not implement `visit_string` without also implementing `visit_str`",
-                            );
+                                      "you should not implement `visit_string` without also implementing `visit_str`");
                         }
                     }
                 }
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 2d32a8792741..9c5b032f6251 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -87,7 +87,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
         decl: &'tcx FnDecl,
         expr: &'tcx Expr,
         _: Span,
-        _: NodeId,
+        _: NodeId
     ) {
         if in_external_macro(cx, expr.span) {
             return;
@@ -155,7 +155,7 @@ fn check_pat<'a, 'tcx>(
     pat: &'tcx Pat,
     init: Option<&'tcx Expr>,
     span: Span,
-    bindings: &mut Vec<(Name, Span)>,
+    bindings: &mut Vec<(Name, Span)>
 ) {
     // TODO: match more stuff / destructuring
     match pat.node {
@@ -178,15 +178,15 @@ fn check_pat<'a, 'tcx>(
             if let Some(ref p) = *inner {
                 check_pat(cx, p, init, span, bindings);
             }
-        }
+        },
         PatKind::Struct(_, ref pfields, _) => {
             if let Some(init_struct) = init {
                 if let ExprStruct(_, ref efields, _) = init_struct.node {
                     for field in pfields {
                         let name = field.node.name;
                         let efield = efields.iter()
-                                            .find(|f| f.name.node == name)
-                                            .map(|f| &*f.expr);
+                            .find(|f| f.name.node == name)
+                            .map(|f| &*f.expr);
                         check_pat(cx, &field.node.pat, efield, span, bindings);
                     }
                 } else {
@@ -199,7 +199,7 @@ fn check_pat<'a, 'tcx>(
                     check_pat(cx, &field.node.pat, None, span, bindings);
                 }
             }
-        }
+        },
         PatKind::Tuple(ref inner, _) => {
             if let Some(init_tup) = init {
                 if let ExprTup(ref tup) = init_tup.node {
@@ -216,7 +216,7 @@ fn check_pat<'a, 'tcx>(
                     check_pat(cx, p, None, span, bindings);
                 }
             }
-        }
+        },
         PatKind::Box(ref inner) => {
             if let Some(initp) = init {
                 if let ExprBox(ref inner_init) = initp.node {
@@ -227,7 +227,7 @@ fn check_pat<'a, 'tcx>(
             } else {
                 check_pat(cx, inner, init, span, bindings);
             }
-        }
+        },
         PatKind::Ref(ref inner, _) => check_pat(cx, inner, init, span, bindings),
         // PatVec(Vec<P<Pat>>, Option<P<Pat>>, Vec<P<Pat>>),
         _ => (),
@@ -240,7 +240,7 @@ fn lint_shadow<'a, 'tcx: 'a>(
     span: Span,
     pattern_span: Span,
     init: Option<&'tcx Expr>,
-    prev_span: Span,
+    prev_span: Span
 ) {
     if let Some(expr) = init {
         if is_self_shadow(name, expr) {
@@ -250,8 +250,9 @@ fn lint_shadow<'a, 'tcx: 'a>(
                                &format!("`{}` is shadowed by itself in `{}`",
                                         snippet(cx, pattern_span, "_"),
                                         snippet(cx, expr.span, "..")),
-                               |db| { db.span_note(prev_span, "previous binding is here"); },
-            );
+                               |db| {
+                db.span_note(prev_span, "previous binding is here");
+            });
         } else if contains_self(cx, name, expr) {
             span_lint_and_then(cx,
                                SHADOW_REUSE,
@@ -260,9 +261,9 @@ fn lint_shadow<'a, 'tcx: 'a>(
                                         snippet(cx, pattern_span, "_"),
                                         snippet(cx, expr.span, "..")),
                                |db| {
-                                   db.span_note(expr.span, "initialization happens here");
-                                   db.span_note(prev_span, "previous binding is here");
-                               });
+                db.span_note(expr.span, "initialization happens here");
+                db.span_note(prev_span, "previous binding is here");
+            });
         } else {
             span_lint_and_then(cx,
                                SHADOW_UNRELATED,
@@ -271,9 +272,9 @@ fn lint_shadow<'a, 'tcx: 'a>(
                                         snippet(cx, pattern_span, "_"),
                                         snippet(cx, expr.span, "..")),
                                |db| {
-                                   db.span_note(expr.span, "initialization happens here");
-                                   db.span_note(prev_span, "previous binding is here");
-                               });
+                db.span_note(expr.span, "initialization happens here");
+                db.span_note(prev_span, "previous binding is here");
+            });
         }
 
     } else {
@@ -281,7 +282,9 @@ fn lint_shadow<'a, 'tcx: 'a>(
                            SHADOW_UNRELATED,
                            span,
                            &format!("`{}` shadows a previous declaration", snippet(cx, pattern_span, "_")),
-                           |db| { db.span_note(prev_span, "previous binding is here"); });
+                           |db| {
+            db.span_note(prev_span, "previous binding is here");
+        });
     }
 }
 
@@ -303,18 +306,18 @@ fn check_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings:
             for e in v {
                 check_expr(cx, e, bindings)
             }
-        }
+        },
         ExprIf(ref cond, ref then, ref otherwise) => {
             check_expr(cx, cond, bindings);
             check_block(cx, then, bindings);
             if let Some(ref o) = *otherwise {
                 check_expr(cx, o, bindings);
             }
-        }
+        },
         ExprWhile(ref cond, ref block, _) => {
             check_expr(cx, cond, bindings);
             check_block(cx, block, bindings);
-        }
+        },
         ExprMatch(ref init, ref arms, _) => {
             check_expr(cx, init, bindings);
             let len = bindings.len();
@@ -329,7 +332,7 @@ fn check_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings:
                     bindings.truncate(len);
                 }
             }
-        }
+        },
         _ => (),
     }
 }
@@ -341,14 +344,14 @@ fn check_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty, bindings: &mut V
         TyArray(ref fty, ref expr) => {
             check_ty(cx, fty, bindings);
             check_expr(cx, expr, bindings);
-        }
+        },
         TyPtr(MutTy { ty: ref mty, .. }) |
         TyRptr(_, MutTy { ty: ref mty, .. }) => check_ty(cx, mty, bindings),
         TyTup(ref tup) => {
             for t in tup {
                 check_ty(cx, t, bindings)
             }
-        }
+        },
         TyTypeof(ref expr) => check_expr(cx, expr, bindings),
         _ => (),
     }
@@ -360,7 +363,7 @@ fn is_self_shadow(name: Name, expr: &Expr) -> bool {
         ExprAddrOf(_, ref inner) => is_self_shadow(name, inner),
         ExprBlock(ref block) => {
             block.stmts.is_empty() && block.expr.as_ref().map_or(false, |e| is_self_shadow(name, e))
-        }
+        },
         ExprUnary(op, ref inner) => (UnDeref == op) && is_self_shadow(name, inner),
         ExprPath(QPath::Resolved(_, ref path)) => path_eq_name(name, path),
         _ => false,
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 01f2f66c2fde..195b49c72f68 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -122,7 +122,7 @@ fn is_add(cx: &LateContext, src: &Expr, target: &Expr) -> bool {
         ExprBinary(Spanned { node: BiAdd, .. }, ref left, _) => SpanlessEq::new(cx).eq_expr(target, left),
         ExprBlock(ref block) => {
             block.stmts.is_empty() && block.expr.as_ref().map_or(false, |expr| is_add(cx, expr, target))
-        }
+        },
         _ => false,
     }
 }
@@ -152,11 +152,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StringLitAsBytes {
                                                e.span,
                                                "calling `as_bytes()` on a string literal",
                                                |db| {
-                                                   let sugg = format!("b{}", snippet(cx, args[0].span, r#""foo""#));
-                                                   db.span_suggestion(e.span,
-                                                                      "consider using a byte string literal instead",
-                                                                      sugg);
-                                               });
+                                let sugg = format!("b{}", snippet(cx, args[0].span, r#""foo""#));
+                                db.span_suggestion(e.span, "consider using a byte string literal instead", sugg);
+                            });
 
                         }
                     }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 7393ee3890e5..8ed7e3558797 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -81,7 +81,11 @@ fn check_manual_swap(cx: &LateContext, block: &Block) {
             SpanlessEq::new(cx).ignore_fn().eq_expr(tmp_init, lhs1),
             SpanlessEq::new(cx).ignore_fn().eq_expr(rhs1, lhs2)
         ], {
-            fn check_for_slice<'a>(cx: &LateContext, lhs1: &'a Expr, lhs2: &'a Expr) -> Option<(&'a Expr, &'a Expr, &'a Expr)> {
+            fn check_for_slice<'a>(
+                cx: &LateContext,
+                lhs1: &'a Expr,
+                lhs2: &'a Expr,
+            ) -> Option<(&'a Expr, &'a Expr, &'a Expr)> {
                 if let ExprIndex(ref lhs1, ref idx1) = lhs1.node {
                     if let ExprIndex(ref lhs2, ref idx2) = lhs2.node {
                         if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, lhs2) {
@@ -104,7 +108,10 @@ fn check_manual_swap(cx: &LateContext, block: &Block) {
                 if let Some(slice) = Sugg::hir_opt(cx, slice) {
                     (false,
                      format!(" elements of `{}`", slice),
-                     format!("{}.swap({}, {})", slice.maybe_par(), snippet(cx, idx1.span, ".."), snippet(cx, idx2.span, "..")))
+                     format!("{}.swap({}, {})",
+                             slice.maybe_par(),
+                             snippet(cx, idx1.span, ".."),
+                             snippet(cx, idx2.span, "..")))
                 } else {
                     (false, "".to_owned(), "".to_owned())
                 }
@@ -148,7 +155,9 @@ fn check_suspicious_swap(cx: &LateContext, block: &Block) {
             SpanlessEq::new(cx).ignore_fn().eq_expr(lhs0, rhs1),
             SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, rhs0)
         ], {
-            let (what, lhs, rhs) = if let (Some(first), Some(second)) = (Sugg::hir_opt(cx, lhs0), Sugg::hir_opt(cx, rhs0)) {
+            let lhs0 = Sugg::hir_opt(cx, lhs0);
+            let rhs0 = Sugg::hir_opt(cx, rhs0);
+            let (what, lhs, rhs) = if let (Some(first), Some(second)) = (lhs0, rhs0) {
                 (format!(" `{}` and `{}`", first, second), first.mut_addr().to_string(), second.mut_addr().to_string())
             } else {
                 ("".to_owned(), "".to_owned(), "".to_owned())
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index 2f6e6d97fbf7..1669b2d65572 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -46,7 +46,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                     if is_temporary(base) && !is_adjusted(cx, base) {
                         span_lint(cx, TEMPORARY_ASSIGNMENT, expr.span, "assignment to temporary");
                     }
-                }
+                },
                 _ => (),
             }
         }
diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index b6731db93839..5e01f891eb17 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -95,18 +95,18 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                     let to_ty = cx.tcx.tables().expr_ty(e);
 
                     match (&from_ty.sty, &to_ty.sty) {
-                        _ if from_ty == to_ty => span_lint(
-                            cx,
-                            USELESS_TRANSMUTE,
-                            e.span,
-                            &format!("transmute from a type (`{}`) to itself", from_ty),
-                        ),
-                        (&TyRef(_, rty), &TyRawPtr(ptr_ty)) => span_lint_and_then(
-                            cx,
-                            USELESS_TRANSMUTE,
-                            e.span,
-                            "transmute from a reference to a pointer",
-                            |db| {
+                        _ if from_ty == to_ty => {
+                            span_lint(cx,
+                                      USELESS_TRANSMUTE,
+                                      e.span,
+                                      &format!("transmute from a type (`{}`) to itself", from_ty))
+                        },
+                        (&TyRef(_, rty), &TyRawPtr(ptr_ty)) => {
+                            span_lint_and_then(cx,
+                                               USELESS_TRANSMUTE,
+                                               e.span,
+                                               "transmute from a reference to a pointer",
+                                               |db| {
                                 if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
                                     let sugg = if ptr_ty == rty {
                                         arg.as_ty(to_ty)
@@ -116,53 +116,54 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
 
                                     db.span_suggestion(e.span, "try", sugg.to_string());
                                 }
-                            },
-                        ),
+                            })
+                        },
                         (&ty::TyInt(_), &TyRawPtr(_)) |
-                        (&ty::TyUint(_), &TyRawPtr(_)) => span_lint_and_then(
-                            cx,
-                            USELESS_TRANSMUTE,
-                            e.span,
-                            "transmute from an integer to a pointer",
-                            |db| {
+                        (&ty::TyUint(_), &TyRawPtr(_)) => {
+                            span_lint_and_then(cx,
+                                               USELESS_TRANSMUTE,
+                                               e.span,
+                                               "transmute from an integer to a pointer",
+                                               |db| {
                                 if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
                                     db.span_suggestion(e.span, "try", arg.as_ty(&to_ty.to_string()).to_string());
                                 }
-                            },
-                        ),
+                            })
+                        },
                         (&ty::TyFloat(_), &TyRef(..)) |
                         (&ty::TyFloat(_), &TyRawPtr(_)) |
                         (&ty::TyChar, &TyRef(..)) |
-                        (&ty::TyChar, &TyRawPtr(_)) => span_lint(
-                            cx,
-                            WRONG_TRANSMUTE,
-                            e.span,
-                            &format!("transmute from a `{}` to a pointer", from_ty),
-                        ),
-                        (&TyRawPtr(from_ptr), _) if from_ptr.ty == to_ty => span_lint(
-                            cx,
-                            CROSSPOINTER_TRANSMUTE,
-                            e.span,
-                            &format!("transmute from a type (`{}`) to the type that it points to (`{}`)",
-                                     from_ty,
-                                     to_ty),
-                        ),
-                        (_, &TyRawPtr(to_ptr)) if to_ptr.ty == from_ty => span_lint(
-                            cx,
-                            CROSSPOINTER_TRANSMUTE,
-                            e.span,
-                            &format!("transmute from a type (`{}`) to a pointer to that type (`{}`)",
-                                     from_ty,
-                                     to_ty),
-                        ),
-                        (&TyRawPtr(from_pty), &TyRef(_, to_rty)) => span_lint_and_then(
-                            cx,
-                            TRANSMUTE_PTR_TO_REF,
-                            e.span,
-                            &format!("transmute from a pointer type (`{}`) to a reference type (`{}`)",
-                                    from_ty,
-                                    to_ty),
-                            |db| {
+                        (&ty::TyChar, &TyRawPtr(_)) => {
+                            span_lint(cx,
+                                      WRONG_TRANSMUTE,
+                                      e.span,
+                                      &format!("transmute from a `{}` to a pointer", from_ty))
+                        },
+                        (&TyRawPtr(from_ptr), _) if from_ptr.ty == to_ty => {
+                            span_lint(cx,
+                                      CROSSPOINTER_TRANSMUTE,
+                                      e.span,
+                                      &format!("transmute from a type (`{}`) to the type that it points to (`{}`)",
+                                               from_ty,
+                                               to_ty))
+                        },
+                        (_, &TyRawPtr(to_ptr)) if to_ptr.ty == from_ty => {
+                            span_lint(cx,
+                                      CROSSPOINTER_TRANSMUTE,
+                                      e.span,
+                                      &format!("transmute from a type (`{}`) to a pointer to that type (`{}`)",
+                                               from_ty,
+                                               to_ty))
+                        },
+                        (&TyRawPtr(from_pty), &TyRef(_, to_rty)) => {
+                            span_lint_and_then(cx,
+                                               TRANSMUTE_PTR_TO_REF,
+                                               e.span,
+                                               &format!("transmute from a pointer type (`{}`) to a reference type \
+                                                         (`{}`)",
+                                                        from_ty,
+                                                        to_ty),
+                                               |db| {
                                 let arg = sugg::Sugg::hir(cx, &args[0], "..");
                                 let (deref, cast) = if to_rty.mutbl == Mutability::MutMutable {
                                     ("&mut *", "*mut")
@@ -177,8 +178,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                                 };
 
                                 db.span_suggestion(e.span, "try", sugg::make_unop(deref, arg).to_string());
-                            },
-                        ),
+                            })
+                        },
                         _ => return,
                     };
                 }
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 930c44c88633..89bc46074fda 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -6,8 +6,8 @@ use rustc::ty;
 use std::cmp::Ordering;
 use syntax::ast::{IntTy, UintTy, FloatTy};
 use syntax::codemap::Span;
-use utils::{comparisons, higher, in_external_macro, in_macro, match_def_path, snippet,
-            span_help_and_lint, span_lint, opt_def_id, last_path_segment};
+use utils::{comparisons, higher, in_external_macro, in_macro, match_def_path, snippet, span_help_and_lint, span_lint,
+            opt_def_id, last_path_segment};
 use utils::paths;
 
 /// Handles all the linting of funky types
@@ -95,10 +95,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypePass {
                     }}
                 } else if match_def_path(cx, def_id, &paths::LINKED_LIST) {
                     span_help_and_lint(cx,
-                                        LINKEDLIST,
-                                        ast_ty.span,
-                                        "I see you're using a LinkedList! Perhaps you meant some other data structure?",
-                                        "a VecDeque might work");
+                                       LINKEDLIST,
+                                       ast_ty.span,
+                                       "I see you're using a LinkedList! Perhaps you meant some other data structure?",
+                                       "a VecDeque might work");
                 }
             }
         }
@@ -141,7 +141,7 @@ fn check_let_unit(cx: &LateContext, decl: &Decl) {
                           decl.span,
                           &format!("this let-binding has unit value. Consider omitting `let {} =`",
                                    snippet(cx, local.pat.span, "..")));
-            }
+            },
             _ => (),
         }
     }
@@ -211,8 +211,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitCmp {
                                   &format!("{}-comparison of unit values detected. This will always be {}",
                                            op.as_str(),
                                            result));
-                    }
-                    _ => ()
+                    },
+                    _ => (),
                 }
             }
         }
@@ -336,11 +336,7 @@ fn is_isize_or_usize(typ: &ty::TyS) -> bool {
 }
 
 fn span_precision_loss_lint(cx: &LateContext, expr: &Expr, cast_from: &ty::TyS, cast_to_f64: bool) {
-    let mantissa_nbits = if cast_to_f64 {
-        52
-    } else {
-        23
-    };
+    let mantissa_nbits = if cast_to_f64 { 52 } else { 23 };
     let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64;
     let arch_dependent_str = "on targets with 64-bit wide pointers ";
     let from_nbits_str = if arch_dependent {
@@ -356,11 +352,7 @@ fn span_precision_loss_lint(cx: &LateContext, expr: &Expr, cast_from: &ty::TyS,
               &format!("casting {0} to {1} causes a loss of precision {2}({0} is {3} bits wide, but {1}'s mantissa \
                         is only {4} bits wide)",
                        cast_from,
-                       if cast_to_f64 {
-                           "f64"
-                       } else {
-                           "f32"
-                       },
+                       if cast_to_f64 { "f64" } else { "f32" },
                        if arch_dependent {
                            arch_dependent_str
                        } else {
@@ -388,27 +380,27 @@ fn check_truncation_and_wrapping(cx: &LateContext, expr: &Expr, cast_from: &ty::
              ArchSuffix::None,
              to_nbits == from_nbits && cast_unsigned_to_signed,
              ArchSuffix::None)
-        }
+        },
         (true, false) => {
             (to_nbits <= 32,
              if to_nbits == 32 {
-                ArchSuffix::_64
-            } else {
-                ArchSuffix::None
-            },
+                 ArchSuffix::_64
+             } else {
+                 ArchSuffix::None
+             },
              to_nbits <= 32 && cast_unsigned_to_signed,
              ArchSuffix::_32)
-        }
+        },
         (false, true) => {
             (from_nbits == 64,
              ArchSuffix::_32,
              cast_unsigned_to_signed,
              if from_nbits == 64 {
-                ArchSuffix::_64
-            } else {
-                ArchSuffix::_32
-            })
-        }
+                 ArchSuffix::_64
+             } else {
+                 ArchSuffix::_32
+             })
+        },
     };
     if span_truncation {
         span_lint(cx,
@@ -463,7 +455,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
                         if is_isize_or_usize(cast_from) || from_nbits >= to_nbits {
                             span_precision_loss_lint(cx, expr, cast_from, to_nbits == 64);
                         }
-                    }
+                    },
                     (false, true) => {
                         span_lint(cx,
                                   CAST_POSSIBLE_TRUNCATION,
@@ -475,7 +467,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
                                       expr.span,
                                       &format!("casting {} to {} may lose the sign of the value", cast_from, cast_to));
                         }
-                    }
+                    },
                     (true, true) => {
                         if cast_from.is_signed() && !cast_to.is_signed() {
                             span_lint(cx,
@@ -484,16 +476,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
                                       &format!("casting {} to {} may lose the sign of the value", cast_from, cast_to));
                         }
                         check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
-                    }
+                    },
                     (false, false) => {
-                        if let (&ty::TyFloat(FloatTy::F64), &ty::TyFloat(FloatTy::F32)) = (&cast_from.sty,
-                                                                                           &cast_to.sty) {
+                        if let (&ty::TyFloat(FloatTy::F64), &ty::TyFloat(FloatTy::F32)) =
+                            (&cast_from.sty, &cast_to.sty) {
                             span_lint(cx,
                                       CAST_POSSIBLE_TRUNCATION,
                                       expr.span,
                                       "casting f64 to f32 may truncate the value");
                         }
-                    }
+                    },
                 }
             }
         }
@@ -536,7 +528,15 @@ impl LintPass for TypeComplexityPass {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeComplexityPass {
-    fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, _: FnKind<'tcx>, decl: &'tcx FnDecl, _: &'tcx Expr, _: Span, _: NodeId) {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'a, 'tcx>,
+        _: FnKind<'tcx>,
+        decl: &'tcx FnDecl,
+        _: &'tcx Expr,
+        _: Span,
+        _: NodeId
+    ) {
         self.check_fndecl(cx, decl);
     }
 
@@ -629,10 +629,7 @@ impl<'a, 'tcx: 'a> Visitor<'tcx> for TypeComplexityVisitor<'a, 'tcx> {
             TyInfer | TyPtr(..) | TyRptr(..) => (1, 0),
 
             // the "normal" components of a type: named types, arrays/tuples
-            TyPath(..) |
-            TySlice(..) |
-            TyTup(..) |
-            TyArray(..) => (10 * self.nest, 1),
+            TyPath(..) | TySlice(..) | TyTup(..) | TyArray(..) => (10 * self.nest, 1),
 
             // "Sum" of trait bounds
             TyObjectSum(..) => (20 * self.nest, 0),
@@ -693,9 +690,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CharLitAsU8 {
                         let msg = "casting character literal to u8. `char`s \
                                    are 4 bytes wide in rust, so casting to u8 \
                                    truncates them";
-                        let help = format!("Consider using a byte literal \
-                                            instead:\nb{}",
-                                           snippet(cx, e.span, "'x'"));
+                        let help = format!("Consider using a byte literal instead:\nb{}", snippet(cx, e.span, "'x'"));
                         span_help_and_lint(cx, CHAR_LIT_AS_U8, expr.span, msg, &help);
                     }
                 }
@@ -752,8 +747,12 @@ enum AbsurdComparisonResult {
 
 
 
-fn detect_absurd_comparison<'a>(cx: &LateContext, op: BinOp_, lhs: &'a Expr, rhs: &'a Expr)
-                                -> Option<(ExtremeExpr<'a>, AbsurdComparisonResult)> {
+fn detect_absurd_comparison<'a>(
+    cx: &LateContext,
+    op: BinOp_,
+    lhs: &'a Expr,
+    rhs: &'a Expr
+) -> Option<(ExtremeExpr<'a>, AbsurdComparisonResult)> {
     use types::ExtremeType::*;
     use types::AbsurdComparisonResult::*;
     use utils::comparisons::*;
@@ -775,7 +774,7 @@ fn detect_absurd_comparison<'a>(cx: &LateContext, op: BinOp_, lhs: &'a Expr, rhs
                 (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, AlwaysFalse), // x < min
                 _ => return None,
             }
-        }
+        },
         Rel::Le => {
             match (lx, rx) {
                 (Some(l @ ExtremeExpr { which: Minimum, .. }), _) => (l, AlwaysTrue), // min <= x
@@ -784,7 +783,7 @@ fn detect_absurd_comparison<'a>(cx: &LateContext, op: BinOp_, lhs: &'a Expr, rhs
                 (_, Some(r @ ExtremeExpr { which: Maximum, .. })) => (r, AlwaysTrue), // x <= max
                 _ => return None,
             }
-        }
+        },
         Rel::Ne | Rel::Eq => return None,
     })
 }
@@ -864,7 +863,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AbsurdExtremeComparisons {
                                      instead",
                                     snippet(cx, lhs.span, "lhs"),
                                     snippet(cx, rhs.span, "rhs"))
-                        }
+                        },
                     };
 
                     let help = format!("because {} is the {} value for this type, {}",
@@ -967,7 +966,7 @@ fn numeric_cast_precast_bounds<'a>(cx: &LateContext, expr: &'a Expr) -> Option<(
                     IntTy::I64 => (FullInt::S(i64::min_value() as i64), FullInt::S(i64::max_value() as i64)),
                     IntTy::Is => (FullInt::S(isize::min_value() as i64), FullInt::S(isize::max_value() as i64)),
                 })
-            }
+            },
             TyUint(uint_ty) => {
                 Some(match uint_ty {
                     UintTy::U8 => (FullInt::U(u8::min_value() as u64), FullInt::U(u8::max_value() as u64)),
@@ -976,7 +975,7 @@ fn numeric_cast_precast_bounds<'a>(cx: &LateContext, expr: &'a Expr) -> Option<(
                     UintTy::U64 => (FullInt::U(u64::min_value() as u64), FullInt::U(u64::max_value() as u64)),
                     UintTy::Us => (FullInt::U(usize::min_value() as u64), FullInt::U(usize::max_value() as u64)),
                 })
-            }
+            },
             _ => None,
         }
     } else {
@@ -1001,7 +1000,7 @@ fn node_as_const_fullint(cx: &LateContext, expr: &Expr) -> Option<FullInt> {
             } else {
                 None
             }
-        }
+        },
         Err(_) => None,
     }
 }
@@ -1019,8 +1018,15 @@ fn err_upcast_comparison(cx: &LateContext, span: &Span, expr: &Expr, always: boo
     }
 }
 
-fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons::Rel,
-                                lhs_bounds: Option<(FullInt, FullInt)>, lhs: &Expr, rhs: &Expr, invert: bool) {
+fn upcast_comparison_bounds_err(
+    cx: &LateContext,
+    span: &Span,
+    rel: comparisons::Rel,
+    lhs_bounds: Option<(FullInt, FullInt)>,
+    lhs: &Expr,
+    rhs: &Expr,
+    invert: bool
+) {
     use utils::comparisons::*;
 
     if let Some((lb, ub)) = lhs_bounds {
@@ -1036,14 +1042,14 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons:
                     } else {
                         ub < norm_rhs_val
                     }
-                }
+                },
                 Rel::Le => {
                     if invert {
                         norm_rhs_val <= lb
                     } else {
                         ub <= norm_rhs_val
                     }
-                }
+                },
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
                 err_upcast_comparison(cx, span, lhs, true)
@@ -1054,14 +1060,14 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons:
                     } else {
                         lb >= norm_rhs_val
                     }
-                }
+                },
                 Rel::Le => {
                     if invert {
                         norm_rhs_val > ub
                     } else {
                         lb > norm_rhs_val
                     }
-                }
+                },
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
                 err_upcast_comparison(cx, span, lhs, false)
diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs
index 341848a868cd..07afc55ae7f1 100644
--- a/clippy_lints/src/unsafe_removed_from_name.rs
+++ b/clippy_lints/src/unsafe_removed_from_name.rs
@@ -38,15 +38,14 @@ impl EarlyLintPass for UnsafeNameRemoval {
         if let ItemKind::Use(ref item_use) = item.node {
             match item_use.node {
                 ViewPath_::ViewPathSimple(ref name, ref path) => {
-                    unsafe_to_safe_check(
-                        path.segments
-                            .last()
-                            .expect("use paths cannot be empty")
-                            .identifier,
-                        *name,
-                        cx, &item.span
-                        );
-                }
+                    unsafe_to_safe_check(path.segments
+                                             .last()
+                                             .expect("use paths cannot be empty")
+                                             .identifier,
+                                         *name,
+                                         cx,
+                                         &item.span);
+                },
                 ViewPath_::ViewPathList(_, ref path_list_items) => {
                     for path_list_item in path_list_items.iter() {
                         let plid = path_list_item.node;
@@ -54,8 +53,8 @@ impl EarlyLintPass for UnsafeNameRemoval {
                             unsafe_to_safe_check(plid.name, rename, cx, &item.span);
                         };
                     }
-                }
-                ViewPath_::ViewPathGlob(_) => {}
+                },
+                ViewPath_::ViewPathGlob(_) => {},
             }
         }
     }
@@ -68,11 +67,7 @@ fn unsafe_to_safe_check(old_name: Ident, new_name: Ident, cx: &EarlyContext, spa
         span_lint(cx,
                   UNSAFE_REMOVED_FROM_NAME,
                   *span,
-                  &format!(
-                "removed \"unsafe\" from the name of `{}` in use as `{}`",
-                old_str,
-                new_str
-            ));
+                  &format!("removed \"unsafe\" from the name of `{}` in use as `{}`", old_str, new_str));
     }
 }
 
diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs
index 4f1e01af6e9f..9017fd6933e8 100644
--- a/clippy_lints/src/unused_label.rs
+++ b/clippy_lints/src/unused_label.rs
@@ -48,7 +48,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedLabel {
         decl: &'tcx hir::FnDecl,
         body: &'tcx hir::Expr,
         span: Span,
-        fn_id: ast::NodeId,
+        fn_id: ast::NodeId
     ) {
         if in_macro(cx, span) {
             return;
@@ -72,11 +72,11 @@ impl<'a, 'tcx: 'a> Visitor<'tcx> for UnusedLabelVisitor<'a, 'tcx> {
             hir::ExprBreak(Some(label), _) |
             hir::ExprAgain(Some(label)) => {
                 self.labels.remove(&label.name.as_str());
-            }
+            },
             hir::ExprLoop(_, Some(label), _) |
             hir::ExprWhile(_, _, Some(label)) => {
                 self.labels.insert(label.node.as_str(), expr.span);
-            }
+            },
             _ => (),
         }
 
diff --git a/clippy_lints/src/utils/comparisons.rs b/clippy_lints/src/utils/comparisons.rs
index a277226eb67c..f973c2afd27a 100644
--- a/clippy_lints/src/utils/comparisons.rs
+++ b/clippy_lints/src/utils/comparisons.rs
@@ -18,8 +18,7 @@ pub enum Rel {
 }
 
 /// Put the expression in the form  `lhs < rhs`, `lhs <= rhs`, `lhs == rhs` or `lhs != rhs`.
-pub fn normalize_comparison<'a>(op: BinOp_, lhs: &'a Expr, rhs: &'a Expr)
-                                -> Option<(Rel, &'a Expr, &'a Expr)> {
+pub fn normalize_comparison<'a>(op: BinOp_, lhs: &'a Expr, rhs: &'a Expr) -> Option<(Rel, &'a Expr, &'a Expr)> {
     match op {
         BinOp_::BiLt => Some((Rel::Lt, lhs, rhs)),
         BinOp_::BiLe => Some((Rel::Le, lhs, rhs)),
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 9a1753d511ce..d80fa17e29f7 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -8,21 +8,20 @@ use syntax::{ast, codemap};
 use toml;
 
 /// Get the configuration file from arguments.
-pub fn file_from_args(args: &[codemap::Spanned<ast::NestedMetaItemKind>]) -> Result<Option<path::PathBuf>, (&'static str, codemap::Span)> {
+pub fn file_from_args(args: &[codemap::Spanned<ast::NestedMetaItemKind>])
+    -> Result<Option<path::PathBuf>, (&'static str, codemap::Span)> {
     for arg in args.iter().filter_map(|a| a.meta_item()) {
         if arg.name() == "conf_file" {
             return match arg.node {
                 ast::MetaItemKind::Word |
-                ast::MetaItemKind::List(_) => {
-                    Err(("`conf_file` must be a named value", arg.span))
-                }
+                ast::MetaItemKind::List(_) => Err(("`conf_file` must be a named value", arg.span)),
                 ast::MetaItemKind::NameValue(ref value) => {
                     if let ast::LitKind::Str(ref file, _) = value.node {
                         Ok(Some(file.to_string().into()))
                     } else {
                         Err(("`conf_file` value must be a string", value.span))
                     }
-                }
+                },
             };
         }
     }
@@ -38,14 +37,12 @@ pub enum Error {
     /// The file is not valid TOML.
     Toml(Vec<toml::ParserError>),
     /// Type error.
-    Type(
-        /// The name of the key.
-        &'static str,
-        /// The expected type.
-        &'static str,
-        /// The type we got instead.
-        &'static str
-    ),
+    Type(/// The name of the key.
+         &'static str,
+         /// The expected type.
+         &'static str,
+         /// The type we got instead.
+         &'static str),
     /// There is an unknown key is the file.
     UnknownKey(String),
 }
@@ -66,10 +63,10 @@ impl fmt::Display for Error {
                 }
 
                 Ok(())
-            }
+            },
             Error::Type(key, expected, got) => {
                 write!(f, "`{}` is expected to be a `{}` but is a `{}`", key, expected, got)
-            }
+            },
             Error::UnknownKey(ref key) => write!(f, "unknown key `{}`", key),
         }
     }
@@ -134,7 +131,12 @@ macro_rules! define_Conf {
 
     // how to read the value?
     (CONV i64, $value: expr) => { $value.as_integer() };
-    (CONV u64, $value: expr) => { $value.as_integer().iter().filter_map(|&i| if i >= 0 { Some(i as u64) } else { None }).next() };
+    (CONV u64, $value: expr) => {
+        $value.as_integer()
+        .iter()
+        .filter_map(|&i| if i >= 0 { Some(i as u64) } else { None })
+        .next()
+    };
     (CONV String, $value: expr) => { $value.as_str().map(Into::into) };
     (CONV Vec<String>, $value: expr) => {{
         let slice = $value.as_slice();
@@ -142,12 +144,10 @@ macro_rules! define_Conf {
         if let Some(slice) = slice {
             if slice.iter().any(|v| v.as_str().is_none()) {
                 None
+            } else {
+                Some(slice.iter().map(|v| v.as_str().expect("already checked").to_owned()).collect())
             }
-            else {
-                Some(slice.iter().map(|v| v.as_str().unwrap_or_else(|| unreachable!()).to_owned()).collect())
-            }
-        }
-        else {
+        } else {
             None
         }
     }};
@@ -163,7 +163,19 @@ define_Conf! {
     /// Lint: CYCLOMATIC_COMPLEXITY. The maximum cyclomatic complexity a function can have
     ("cyclomatic-complexity-threshold", cyclomatic_complexity_threshold, 25 => u64),
     /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
-    ("doc-valid-idents", doc_valid_idents, ["MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "GPLv2", "GPLv3", "GitHub", "IPv4", "IPv6", "JavaScript", "NaN", "OAuth", "OpenGL", "TrueType", "iOS", "macOS"] => Vec<String>),
+    ("doc-valid-idents", doc_valid_idents, [
+        "MiB", "GiB", "TiB", "PiB", "EiB",
+        "DirectX",
+        "GPLv2", "GPLv3",
+        "GitHub",
+        "IPv4", "IPv6",
+        "JavaScript",
+        "NaN",
+        "OAuth",
+        "OpenGL",
+        "TrueType",
+        "iOS", "macOS",
+    ] => Vec<String>),
     /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
     ("too-many-arguments-threshold", too_many_arguments_threshold, 7 => u64),
     /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
@@ -196,7 +208,7 @@ pub fn lookup_conf_file() -> io::Result<Option<path::PathBuf>> {
                     if e.kind() != io::ErrorKind::NotFound {
                         return Err(e);
                     }
-                }
+                },
                 _ => (),
             }
         }
@@ -231,11 +243,11 @@ pub fn read(path: Option<&path::Path>) -> (Conf, Vec<Error>) {
             }
 
             buf
-        }
+        },
         Err(err) => {
             errors.push(err.into());
             return (conf, errors);
-        }
+        },
     };
 
     let mut parser = toml::Parser::new(&file);
diff --git a/clippy_lints/src/utils/constants.rs b/clippy_lints/src/utils/constants.rs
index 179c251e3228..87008307c5f6 100644
--- a/clippy_lints/src/utils/constants.rs
+++ b/clippy_lints/src/utils/constants.rs
@@ -7,15 +7,5 @@
 /// See also [the reference][reference-types] for a list of such types.
 ///
 /// [reference-types]: https://doc.rust-lang.org/reference.html#types
-pub const BUILTIN_TYPES: &'static [&'static str] = &[
-    "i8", "u8",
-    "i16", "u16",
-    "i32", "u32",
-    "i64", "u64",
-    "isize", "usize",
-    "f32",
-    "f64",
-    "bool",
-    "str",
-    "char",
-];
+pub const BUILTIN_TYPES: &'static [&'static str] = &["i8", "u8", "i16", "u16", "i32", "u32", "i64", "u64", "isize",
+                                                     "usize", "f32", "f64", "bool", "str", "char"];
diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs
index 6ae4743a368c..c83dae26fdaa 100644
--- a/clippy_lints/src/utils/higher.rs
+++ b/clippy_lints/src/utils/higher.rs
@@ -47,9 +47,9 @@ pub fn range(expr: &hir::Expr) -> Option<Range> {
     /// Find the field named `name` in the field. Always return `Some` for convenience.
     fn get_field<'a>(name: &str, fields: &'a [hir::Field]) -> Option<&'a hir::Expr> {
         let expr = &fields.iter()
-                          .find(|field| field.name.node == name)
-                          .unwrap_or_else(|| panic!("missing {} field for range", name))
-                          .expr;
+            .find(|field| field.name.node == name)
+            .unwrap_or_else(|| panic!("missing {} field for range", name))
+            .expr;
 
         Some(expr)
     }
@@ -68,7 +68,7 @@ pub fn range(expr: &hir::Expr) -> Option<Range> {
             } else {
                 None
             }
-        }
+        },
         hir::ExprStruct(ref path, ref fields, None) => {
             if match_path(path, &paths::RANGE_FROM_STD) || match_path(path, &paths::RANGE_FROM) {
                 Some(Range {
@@ -77,7 +77,7 @@ pub fn range(expr: &hir::Expr) -> Option<Range> {
                     limits: ast::RangeLimits::HalfOpen,
                 })
             } else if match_path(path, &paths::RANGE_INCLUSIVE_NON_EMPTY_STD) ||
-               match_path(path, &paths::RANGE_INCLUSIVE_NON_EMPTY) {
+                      match_path(path, &paths::RANGE_INCLUSIVE_NON_EMPTY) {
                 Some(Range {
                     start: get_field("start", fields),
                     end: get_field("end", fields),
@@ -104,7 +104,7 @@ pub fn range(expr: &hir::Expr) -> Option<Range> {
             } else {
                 None
             }
-        }
+        },
         _ => None,
     }
 }
diff --git a/clippy_lints/src/utils/hir.rs b/clippy_lints/src/utils/hir.rs
index e01feb3fcae2..80399825b6d1 100644
--- a/clippy_lints/src/utils/hir.rs
+++ b/clippy_lints/src/utils/hir.rs
@@ -38,12 +38,11 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
         match (&left.node, &right.node) {
             (&StmtDecl(ref l, _), &StmtDecl(ref r, _)) => {
                 if let (&DeclLocal(ref l), &DeclLocal(ref r)) = (&l.node, &r.node) {
-                    both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) &&
-                    both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
+                    both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) && both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
                 } else {
                     false
                 }
-            }
+            },
             (&StmtExpr(ref l, _), &StmtExpr(ref r, _)) |
             (&StmtSemi(ref l, _), &StmtSemi(ref r, _)) => self.eq_expr(l, r),
             _ => false,
@@ -73,64 +72,60 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
             (&ExprAssign(ref ll, ref lr), &ExprAssign(ref rl, ref rr)) => self.eq_expr(ll, rl) && self.eq_expr(lr, rr),
             (&ExprAssignOp(ref lo, ref ll, ref lr), &ExprAssignOp(ref ro, ref rl, ref rr)) => {
                 lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-            }
+            },
             (&ExprBlock(ref l), &ExprBlock(ref r)) => self.eq_block(l, r),
             (&ExprBinary(l_op, ref ll, ref lr), &ExprBinary(r_op, ref rl, ref rr)) => {
                 l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) ||
                 swap_binop(l_op.node, ll, lr).map_or(false, |(l_op, ll, lr)| {
                     l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
                 })
-            }
-            (&ExprBreak(li, ref le), &ExprBreak(ri, ref re)) =>
-                both(&li, &ri, |l, r| l.name.as_str() == r.name.as_str())
-                && both(le, re, |l, r| self.eq_expr(l, r)),
+            },
+            (&ExprBreak(li, ref le), &ExprBreak(ri, ref re)) => {
+                both(&li, &ri, |l, r| l.name.as_str() == r.name.as_str()) && both(le, re, |l, r| self.eq_expr(l, r))
+            },
             (&ExprBox(ref l), &ExprBox(ref r)) => self.eq_expr(l, r),
             (&ExprCall(ref l_fun, ref l_args), &ExprCall(ref r_fun, ref r_args)) => {
                 !self.ignore_fn && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
-            }
+            },
             (&ExprCast(ref lx, ref lt), &ExprCast(ref rx, ref rt)) |
-            (&ExprType(ref lx, ref lt), &ExprType(ref rx, ref rt)) => {
-                self.eq_expr(lx, rx) && self.eq_ty(lt, rt)
-            }
+            (&ExprType(ref lx, ref lt), &ExprType(ref rx, ref rt)) => self.eq_expr(lx, rx) && self.eq_ty(lt, rt),
             (&ExprField(ref l_f_exp, ref l_f_ident), &ExprField(ref r_f_exp, ref r_f_ident)) => {
                 l_f_ident.node == r_f_ident.node && self.eq_expr(l_f_exp, r_f_exp)
-            }
+            },
             (&ExprIndex(ref la, ref li), &ExprIndex(ref ra, ref ri)) => self.eq_expr(la, ra) && self.eq_expr(li, ri),
             (&ExprIf(ref lc, ref lt, ref le), &ExprIf(ref rc, ref rt, ref re)) => {
                 self.eq_expr(lc, rc) && self.eq_block(lt, rt) && both(le, re, |l, r| self.eq_expr(l, r))
-            }
+            },
             (&ExprLit(ref l), &ExprLit(ref r)) => l.node == r.node,
             (&ExprLoop(ref lb, ref ll, ref lls), &ExprLoop(ref rb, ref rl, ref rls)) => {
                 lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str())
-            }
+            },
             (&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => {
                 ls == rs && self.eq_expr(le, re) &&
                 over(la, ra, |l, r| {
-                    self.eq_expr(&l.body, &r.body) &&
-                    both(&l.guard, &r.guard, |l, r| self.eq_expr(l, r)) &&
+                    self.eq_expr(&l.body, &r.body) && both(&l.guard, &r.guard, |l, r| self.eq_expr(l, r)) &&
                     over(&l.pats, &r.pats, |l, r| self.eq_pat(l, r))
                 })
-            }
+            },
             (&ExprMethodCall(ref l_name, ref l_tys, ref l_args),
              &ExprMethodCall(ref r_name, ref r_tys, ref r_args)) => {
-                !self.ignore_fn && l_name.node == r_name.node &&
-                over(l_tys, r_tys, |l, r| self.eq_ty(l, r)) &&
+                !self.ignore_fn && l_name.node == r_name.node && over(l_tys, r_tys, |l, r| self.eq_ty(l, r)) &&
                 self.eq_exprs(l_args, r_args)
-            }
+            },
             (&ExprRepeat(ref le, ref ll), &ExprRepeat(ref re, ref rl)) => self.eq_expr(le, re) && self.eq_expr(ll, rl),
             (&ExprRet(ref l), &ExprRet(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)),
             (&ExprPath(ref l), &ExprPath(ref r)) => self.eq_qpath(l, r),
             (&ExprStruct(ref l_path, ref lf, ref lo), &ExprStruct(ref r_path, ref rf, ref ro)) => {
                 self.eq_qpath(l_path, r_path) && both(lo, ro, |l, r| self.eq_expr(l, r)) &&
                 over(lf, rf, |l, r| self.eq_field(l, r))
-            }
+            },
             (&ExprTup(ref l_tup), &ExprTup(ref r_tup)) => self.eq_exprs(l_tup, r_tup),
             (&ExprTupField(ref le, li), &ExprTupField(ref re, ri)) => li.node == ri.node && self.eq_expr(le, re),
             (&ExprUnary(l_op, ref le), &ExprUnary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re),
             (&ExprArray(ref l), &ExprArray(ref r)) => self.eq_exprs(l, r),
             (&ExprWhile(ref lc, ref lb, ref ll), &ExprWhile(ref rc, ref rb, ref rl)) => {
                 self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str())
-            }
+            },
             _ => false,
         }
     }
@@ -153,23 +148,23 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
             (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r),
             (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => {
                 self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
-            }
+            },
             (&PatKind::Binding(ref lb, _, ref li, ref lp), &PatKind::Binding(ref rb, _, ref ri, ref rp)) => {
                 lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r))
-            }
+            },
             (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
             (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r),
             (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => {
                 ls == rs && over(l, r, |l, r| self.eq_pat(l, r))
-            }
+            },
             (&PatKind::Range(ref ls, ref le), &PatKind::Range(ref rs, ref re)) => {
                 self.eq_expr(ls, rs) && self.eq_expr(le, re)
-            }
+            },
             (&PatKind::Ref(ref le, ref lm), &PatKind::Ref(ref re, ref rm)) => lm == rm && self.eq_pat(le, re),
             (&PatKind::Slice(ref ls, ref li, ref le), &PatKind::Slice(ref rs, ref ri, ref re)) => {
                 over(ls, rs, |l, r| self.eq_pat(l, r)) && over(le, re, |l, r| self.eq_pat(l, r)) &&
                 both(li, ri, |l, r| self.eq_pat(l, r))
-            }
+            },
             (&PatKind::Wild, &PatKind::Wild) => true,
             _ => false,
         }
@@ -188,8 +183,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
     }
 
     fn eq_path(&self, left: &Path, right: &Path) -> bool {
-        left.global == right.global &&
-        over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r))
+        left.global == right.global && over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r))
     }
 
     fn eq_path_parameters(&self, left: &PathParameters, right: &PathParameters) -> bool {
@@ -198,35 +192,30 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
                 over(&left.lifetimes, &right.lifetimes, |l, r| self.eq_lifetime(l, r)) &&
                 over(&left.types, &right.types, |l, r| self.eq_ty(l, r)) &&
                 over(&left.bindings, &right.bindings, |l, r| self.eq_type_binding(l, r))
-            }
+            },
             (&ParenthesizedParameters(ref left), &ParenthesizedParameters(ref right)) => {
                 over(&left.inputs, &right.inputs, |l, r| self.eq_ty(l, r)) &&
                 both(&left.output, &right.output, |l, r| self.eq_ty(l, r))
-            }
+            },
             (&AngleBracketedParameters(_), &ParenthesizedParameters(_)) |
-            (&ParenthesizedParameters(_), &AngleBracketedParameters(_)) => {
-                false
-            }
+            (&ParenthesizedParameters(_), &AngleBracketedParameters(_)) => false,
         }
     }
 
     fn eq_path_segment(&self, left: &PathSegment, right: &PathSegment) -> bool {
         // The == of idents doesn't work with different contexts,
         // we have to be explicit about hygiene
-        left.name.as_str() == right.name.as_str() &&
-        self.eq_path_parameters(&left.parameters, &right.parameters)
+        left.name.as_str() == right.name.as_str() && self.eq_path_parameters(&left.parameters, &right.parameters)
     }
 
     fn eq_ty(&self, left: &Ty, right: &Ty) -> bool {
         match (&left.node, &right.node) {
             (&TySlice(ref l_vec), &TySlice(ref r_vec)) => self.eq_ty(l_vec, r_vec),
-            (&TyArray(ref lt, ref ll), &TyArray(ref rt, ref rl)) => {
-                self.eq_ty(lt, rt) && self.eq_expr(ll, rl)
-            }
+            (&TyArray(ref lt, ref ll), &TyArray(ref rt, ref rl)) => self.eq_ty(lt, rt) && self.eq_expr(ll, rl),
             (&TyPtr(ref l_mut), &TyPtr(ref r_mut)) => l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty),
             (&TyRptr(_, ref l_rmut), &TyRptr(_, ref r_rmut)) => {
                 l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty)
-            }
+            },
             (&TyPath(ref l), &TyPath(ref r)) => self.eq_qpath(l, r),
             (&TyTup(ref l), &TyTup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)),
             (&TyInfer, &TyInfer) => true,
@@ -241,13 +230,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
 
 fn swap_binop<'a>(binop: BinOp_, lhs: &'a Expr, rhs: &'a Expr) -> Option<(BinOp_, &'a Expr, &'a Expr)> {
     match binop {
-        BiAdd |
-        BiMul |
-        BiBitXor |
-        BiBitAnd |
-        BiEq |
-        BiNe |
-        BiBitOr => Some((binop, rhs, lhs)),
+        BiAdd | BiMul | BiBitXor | BiBitAnd | BiEq | BiNe | BiBitOr => Some((binop, rhs, lhs)),
         BiLt => Some((BiGt, rhs, lhs)),
         BiLe => Some((BiGe, rhs, lhs)),
         BiGe => Some((BiLe, rhs, lhs)),
@@ -316,39 +299,39 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 c.hash(&mut self.s);
                 m.hash(&mut self.s);
                 self.hash_expr(e);
-            }
+            },
             ExprAgain(i) => {
                 let c: fn(_) -> _ = ExprAgain;
                 c.hash(&mut self.s);
                 if let Some(i) = i {
                     self.hash_name(&i.name);
                 }
-            }
+            },
             ExprAssign(ref l, ref r) => {
                 let c: fn(_, _) -> _ = ExprAssign;
                 c.hash(&mut self.s);
                 self.hash_expr(l);
                 self.hash_expr(r);
-            }
+            },
             ExprAssignOp(ref o, ref l, ref r) => {
                 let c: fn(_, _, _) -> _ = ExprAssignOp;
                 c.hash(&mut self.s);
                 o.hash(&mut self.s);
                 self.hash_expr(l);
                 self.hash_expr(r);
-            }
+            },
             ExprBlock(ref b) => {
                 let c: fn(_) -> _ = ExprBlock;
                 c.hash(&mut self.s);
                 self.hash_block(b);
-            }
+            },
             ExprBinary(op, ref l, ref r) => {
                 let c: fn(_, _, _) -> _ = ExprBinary;
                 c.hash(&mut self.s);
                 op.node.hash(&mut self.s);
                 self.hash_expr(l);
                 self.hash_expr(r);
-            }
+            },
             ExprBreak(i, ref j) => {
                 let c: fn(_, _) -> _ = ExprBreak;
                 c.hash(&mut self.s);
@@ -358,46 +341,46 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 if let Some(ref j) = *j {
                     self.hash_expr(&*j);
                 }
-            }
+            },
             ExprBox(ref e) => {
                 let c: fn(_) -> _ = ExprBox;
                 c.hash(&mut self.s);
                 self.hash_expr(e);
-            }
+            },
             ExprCall(ref fun, ref args) => {
                 let c: fn(_, _) -> _ = ExprCall;
                 c.hash(&mut self.s);
                 self.hash_expr(fun);
                 self.hash_exprs(args);
-            }
+            },
             ExprCast(ref e, ref _ty) => {
                 let c: fn(_, _) -> _ = ExprCast;
                 c.hash(&mut self.s);
                 self.hash_expr(e);
                 // TODO: _ty
-            }
+            },
             ExprClosure(cap, _, eid, _) => {
                 let c: fn(_, _, _, _) -> _ = ExprClosure;
                 c.hash(&mut self.s);
                 cap.hash(&mut self.s);
                 self.hash_expr(self.cx.tcx.map.expr(eid));
-            }
+            },
             ExprField(ref e, ref f) => {
                 let c: fn(_, _) -> _ = ExprField;
                 c.hash(&mut self.s);
                 self.hash_expr(e);
                 self.hash_name(&f.node);
-            }
+            },
             ExprIndex(ref a, ref i) => {
                 let c: fn(_, _) -> _ = ExprIndex;
                 c.hash(&mut self.s);
                 self.hash_expr(a);
                 self.hash_expr(i);
-            }
+            },
             ExprInlineAsm(..) => {
                 let c: fn(_, _, _) -> _ = ExprInlineAsm;
                 c.hash(&mut self.s);
-            }
+            },
             ExprIf(ref cond, ref t, ref e) => {
                 let c: fn(_, _, _) -> _ = ExprIf;
                 c.hash(&mut self.s);
@@ -406,12 +389,12 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 if let Some(ref e) = *e {
                     self.hash_expr(e);
                 }
-            }
+            },
             ExprLit(ref l) => {
                 let c: fn(_) -> _ = ExprLit;
                 c.hash(&mut self.s);
                 l.hash(&mut self.s);
-            }
+            },
             ExprLoop(ref b, ref i, _) => {
                 let c: fn(_, _, _) -> _ = ExprLoop;
                 c.hash(&mut self.s);
@@ -419,7 +402,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 if let Some(i) = *i {
                     self.hash_name(&i.node);
                 }
-            }
+            },
             ExprMatch(ref e, ref arms, ref s) => {
                 let c: fn(_, _, _) -> _ = ExprMatch;
                 c.hash(&mut self.s);
@@ -434,31 +417,31 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 }
 
                 s.hash(&mut self.s);
-            }
+            },
             ExprMethodCall(ref name, ref _tys, ref args) => {
                 let c: fn(_, _, _) -> _ = ExprMethodCall;
                 c.hash(&mut self.s);
                 self.hash_name(&name.node);
                 self.hash_exprs(args);
-            }
+            },
             ExprRepeat(ref e, ref l) => {
                 let c: fn(_, _) -> _ = ExprRepeat;
                 c.hash(&mut self.s);
                 self.hash_expr(e);
                 self.hash_expr(l);
-            }
+            },
             ExprRet(ref e) => {
                 let c: fn(_) -> _ = ExprRet;
                 c.hash(&mut self.s);
                 if let Some(ref e) = *e {
                     self.hash_expr(e);
                 }
-            }
+            },
             ExprPath(ref qpath) => {
                 let c: fn(_) -> _ = ExprPath;
                 c.hash(&mut self.s);
                 self.hash_qpath(qpath);
-            }
+            },
             ExprStruct(ref path, ref fields, ref expr) => {
                 let c: fn(_, _, _) -> _ = ExprStruct;
                 c.hash(&mut self.s);
@@ -473,38 +456,38 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 if let Some(ref e) = *expr {
                     self.hash_expr(e);
                 }
-            }
+            },
             ExprTup(ref tup) => {
                 let c: fn(_) -> _ = ExprTup;
                 c.hash(&mut self.s);
                 self.hash_exprs(tup);
-            }
+            },
             ExprTupField(ref le, li) => {
                 let c: fn(_, _) -> _ = ExprTupField;
                 c.hash(&mut self.s);
 
                 self.hash_expr(le);
                 li.node.hash(&mut self.s);
-            }
+            },
             ExprType(ref e, ref _ty) => {
                 let c: fn(_, _) -> _ = ExprType;
                 c.hash(&mut self.s);
                 self.hash_expr(e);
                 // TODO: _ty
-            }
+            },
             ExprUnary(lop, ref le) => {
                 let c: fn(_, _) -> _ = ExprUnary;
                 c.hash(&mut self.s);
 
                 lop.hash(&mut self.s);
                 self.hash_expr(le);
-            }
+            },
             ExprArray(ref v) => {
                 let c: fn(_) -> _ = ExprArray;
                 c.hash(&mut self.s);
 
                 self.hash_exprs(v);
-            }
+            },
             ExprWhile(ref cond, ref b, l) => {
                 let c: fn(_, _, _) -> _ = ExprWhile;
                 c.hash(&mut self.s);
@@ -514,7 +497,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 if let Some(l) = l {
                     self.hash_name(&l.node);
                 }
-            }
+            },
         }
     }
 
@@ -532,12 +515,12 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
         match *p {
             QPath::Resolved(_, ref path) => {
                 self.hash_path(path);
-            }
+            },
             QPath::TypeRelative(_, ref path) => {
                 self.hash_name(&path.name);
-            }
+            },
         }
-        //self.cx.tcx.tables().qpath_def(p, id).hash(&mut self.s);
+        // self.cx.tcx.tables().qpath_def(p, id).hash(&mut self.s);
     }
 
     pub fn hash_path(&mut self, p: &Path) {
@@ -558,17 +541,17 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                         self.hash_expr(init);
                     }
                 }
-            }
+            },
             StmtExpr(ref expr, _) => {
                 let c: fn(_, _) -> _ = StmtExpr;
                 c.hash(&mut self.s);
                 self.hash_expr(expr);
-            }
+            },
             StmtSemi(ref expr, _) => {
                 let c: fn(_, _) -> _ = StmtSemi;
                 c.hash(&mut self.s);
                 self.hash_expr(expr);
-            }
+            },
         }
     }
 }
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
index b2900c5691c7..79cf15b6c5f5 100644
--- a/clippy_lints/src/utils/inspector.rs
+++ b/clippy_lints/src/utils/inspector.rs
@@ -67,25 +67,25 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
             hir::ImplItemKind::Type(_) => println!("associated type"),
         }
     }
-/*
-    fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) {
-        if !has_attr(&item.attrs) {
-            return;
-        }
-    }
-
-    fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, _: &hir::Generics) {
-        if !has_attr(&var.node.attrs) {
-            return;
-        }
-    }
-
-    fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) {
-        if !has_attr(&field.attrs) {
-            return;
-        }
-    }
-*/
+    // fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) {
+    // if !has_attr(&item.attrs) {
+    // return;
+    // }
+    // }
+    //
+    // fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, _:
+    // &hir::Generics) {
+    // if !has_attr(&var.node.attrs) {
+    // return;
+    // }
+    // }
+    //
+    // fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) {
+    // if !has_attr(&field.attrs) {
+    // return;
+    // }
+    // }
+    //
 
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
         if !has_attr(&expr.attrs) {
@@ -115,17 +115,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
         }
         match stmt.node {
             hir::StmtDecl(ref decl, _) => print_decl(cx, decl),
-            hir::StmtExpr(ref e, _) | hir::StmtSemi(ref e, _) => print_expr(cx, e, 0),
+            hir::StmtExpr(ref e, _) |
+            hir::StmtSemi(ref e, _) => print_expr(cx, e, 0),
         }
     }
-/*
-
-    fn check_foreign_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ForeignItem) {
-        if !has_attr(&item.attrs) {
-            return;
-        }
-    }
-*/
+    // fn check_foreign_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ForeignItem) {
+    // if !has_attr(&item.attrs) {
+    // return;
+    // }
+    // }
+    //
 }
 
 fn has_attr(attrs: &[Attribute]) -> bool {
@@ -282,7 +281,7 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
         hir::ExprPath(hir::QPath::TypeRelative(ref ty, ref seg)) => {
             println!("{}Relative Path, {:?}", ind, ty);
             println!("{}seg: {:?}", ind, seg);
-        }
+        },
         hir::ExprAddrOf(ref muta, ref e) => {
             println!("{}AddrOf, {}", ind, ty);
             println!("mutability: {:?}", muta);
@@ -356,7 +355,7 @@ fn print_item(cx: &LateContext, item: &hir::Item) {
             } else {
                 println!("weird extern crate without a crate id");
             }
-        }
+        },
         hir::ItemUse(ref path, ref kind) => println!("{:?}, {:?}", path, kind),
         hir::ItemStatic(..) => println!("static item of type {:#?}", cx.tcx.item_type(did)),
         hir::ItemConst(..) => println!("const item of type {:#?}", cx.tcx.item_type(did)),
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 91961f906919..cf9e90d62bd4 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -75,8 +75,8 @@ impl EarlyLintPass for Clippy {
                                     span_lint(cx,
                                               CLIPPY_LINTS_INTERNAL,
                                               item.span,
-                                              "this constant should be before the previous constant due to lexical ordering",
-                                    );
+                                              "this constant should be before the previous constant due to lexical \
+                                               ordering");
                                 }
                             }
                             last_name = Some(name);
@@ -110,7 +110,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LintWithoutLintPass {
             if is_lint_ref_type(ty) {
                 self.declared_lints.insert(item.name, item.span);
             } else if is_lint_array_type(ty) && item.vis == Visibility::Inherited && item.name == "ARRAY" {
-                let mut collector = LintCollector { output: &mut self.registered_lints, cx: cx };
+                let mut collector = LintCollector {
+                    output: &mut self.registered_lints,
+                    cx: cx,
+                };
                 collector.visit_expr(expr);
             }
         }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index d8afb96298d4..77b33d7b5893 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -35,23 +35,27 @@ pub type MethodArgs = HirVec<P<Expr>>;
 
 /// Produce a nested chain of if-lets and ifs from the patterns:
 ///
-///     if_let_chain! {[
-///         let Some(y) = x,
-///         y.len() == 2,
-///         let Some(z) = y,
-///     ], {
-///         block
-///     }}
+/// ```rust,ignore
+/// if_let_chain! {[
+///     let Some(y) = x,
+///     y.len() == 2,
+///     let Some(z) = y,
+/// ], {
+///     block
+/// }}
+/// ```
 ///
 /// becomes
 ///
-///     if let Some(y) = x {
-///         if y.len() == 2 {
-///             if let Some(z) = y {
-///                 block
-///             }
+/// ```rust,ignore
+/// if let Some(y) = x {
+///     if y.len() == 2 {
+///         if let Some(z) = y {
+///             block
 ///         }
 ///     }
+/// }
+/// ```
 #[macro_export]
 macro_rules! if_let_chain {
     ([let $pat:pat = $expr:expr, $($tt:tt)+], $block:block) => {
@@ -95,15 +99,17 @@ pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool {
 }
 /// Returns true if this `expn_info` was expanded by any macro.
 pub fn in_macro<'a, T: LintContext<'a>>(cx: &T, span: Span) -> bool {
-    cx.sess().codemap().with_expn_info(span.expn_id, |info| match info {
-        Some(info) => {
-            match info.callee.format {
-                // don't treat range expressions desugared to structs as "in_macro"
-                ExpnFormat::CompilerDesugaring(name) => name != "...",
-                _ => true,
-            }
-        },
-        None => false,
+    cx.sess().codemap().with_expn_info(span.expn_id, |info| {
+        match info {
+            Some(info) => {
+                match info.callee.format {
+                    // don't treat range expressions desugared to structs as "in_macro"
+                    ExpnFormat::CompilerDesugaring(name) => name != "...",
+                    _ => true,
+                }
+            },
+            None => false,
+        }
     })
 }
 
@@ -133,7 +139,7 @@ pub fn in_external_macro<'a, T: LintContext<'a>>(cx: &T, span: Span) -> bool {
 /// Check if a `DefId`'s path matches the given absolute type path usage.
 ///
 /// # Examples
-/// ```
+/// ```rust,ignore
 /// match_def_path(cx, id, &["core", "option", "Option"])
 /// ```
 ///
@@ -160,8 +166,7 @@ pub fn match_def_path(cx: &LateContext, def_id: DefId, path: &[&str]) -> bool {
 
     cx.tcx.push_item_path(&mut apb, def_id);
 
-    apb.names.len() == path.len() &&
-    apb.names.iter().zip(path.iter()).all(|(a, &b)| &**a == b)
+    apb.names.len() == path.len() && apb.names.iter().zip(path.iter()).all(|(a, &b)| &**a == b)
 }
 
 /// Check if type is struct, enum or union type with given def path.
@@ -177,11 +182,11 @@ pub fn match_impl_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool {
     let method_call = ty::MethodCall::expr(expr.id);
 
     let trt_id = cx.tcx
-                   .tables
-                   .borrow()
-                   .method_map
-                   .get(&method_call)
-                   .and_then(|callee| cx.tcx.impl_of_method(callee.def_id));
+        .tables
+        .borrow()
+        .method_map
+        .get(&method_call)
+        .and_then(|callee| cx.tcx.impl_of_method(callee.def_id));
     if let Some(trt_id) = trt_id {
         match_def_path(cx, trt_id, path)
     } else {
@@ -194,11 +199,11 @@ pub fn match_trait_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool
     let method_call = ty::MethodCall::expr(expr.id);
 
     let trt_id = cx.tcx
-                   .tables
-                   .borrow()
-                   .method_map
-                   .get(&method_call)
-                   .and_then(|callee| cx.tcx.trait_of_item(callee.def_id));
+        .tables
+        .borrow()
+        .method_map
+        .get(&method_call)
+        .and_then(|callee| cx.tcx.trait_of_item(callee.def_id));
     if let Some(trt_id) = trt_id {
         match_def_path(cx, trt_id, path)
     } else {
@@ -208,9 +213,11 @@ pub fn match_trait_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool
 
 pub fn last_path_segment(path: &QPath) -> &PathSegment {
     match *path {
-        QPath::Resolved(_, ref path) => path.segments
-                                            .last()
-                                            .expect("A path must have at least one segment"),
+        QPath::Resolved(_, ref path) => {
+            path.segments
+                .last()
+                .expect("A path must have at least one segment")
+        },
         QPath::TypeRelative(_, ref seg) => seg,
     }
 }
@@ -226,19 +233,20 @@ pub fn single_segment_path(path: &QPath) -> Option<&PathSegment> {
 /// Match a `Path` against a slice of segment string literals.
 ///
 /// # Examples
-/// ```
+/// ```rust,ignore
 /// match_path(path, &["std", "rt", "begin_unwind"])
 /// ```
 pub fn match_path(path: &QPath, segments: &[&str]) -> bool {
     match *path {
         QPath::Resolved(_, ref path) => match_path_old(path, segments),
-        QPath::TypeRelative(ref ty, ref segment) => match ty.node {
-            TyPath(ref inner_path) => {
-                segments.len() > 0 &&
-                match_path(inner_path, &segments[..(segments.len() - 1)]) &&
-                segment.name == segments[segments.len() - 1]
-            },
-            _ => false,
+        QPath::TypeRelative(ref ty, ref segment) => {
+            match ty.node {
+                TyPath(ref inner_path) => {
+                    segments.len() > 0 && match_path(inner_path, &segments[..(segments.len() - 1)]) &&
+                    segment.name == segments[segments.len() - 1]
+                },
+                _ => false,
+            }
         },
     }
 }
@@ -250,7 +258,7 @@ pub fn match_path_old(path: &Path, segments: &[&str]) -> bool {
 /// Match a `Path` against a slice of segment string literals, e.g.
 ///
 /// # Examples
-/// ```
+/// ```rust,ignore
 /// match_path(path, &["std", "rt", "begin_unwind"])
 /// ```
 pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
@@ -265,7 +273,10 @@ pub fn path_to_def(cx: &LateContext, path: &[&str]) -> Option<def::Def> {
     let crates = cstore.crates();
     let krate = crates.iter().find(|&&krate| cstore.crate_name(krate) == path[0]);
     if let Some(krate) = krate {
-        let krate = DefId { krate: *krate, index: CRATE_DEF_INDEX };
+        let krate = DefId {
+            krate: *krate,
+            index: CRATE_DEF_INDEX,
+        };
         let mut items = cstore.item_children(krate);
         let mut path_it = path.iter().skip(1).peekable();
 
@@ -306,18 +317,17 @@ pub fn get_trait_def_id(cx: &LateContext, path: &[&str]) -> Option<DefId> {
 
 /// Check whether a type implements a trait.
 /// See also `get_trait_def_id`.
-pub fn implements_trait<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, trait_id: DefId,
-                                  ty_params: Vec<ty::Ty<'tcx>>)
-                                  -> bool {
+pub fn implements_trait<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    ty: ty::Ty<'tcx>,
+    trait_id: DefId,
+    ty_params: Vec<ty::Ty<'tcx>>
+) -> bool {
     cx.tcx.populate_implementations_for_trait_if_necessary(trait_id);
 
     let ty = cx.tcx.erase_regions(&ty);
     cx.tcx.infer_ctxt(None, None, Reveal::All).enter(|infcx| {
-        let obligation = cx.tcx.predicate_for_trait_def(traits::ObligationCause::dummy(),
-                                                        trait_id,
-                                                        0,
-                                                        ty,
-                                                        &ty_params);
+        let obligation = cx.tcx.predicate_for_trait_def(traits::ObligationCause::dummy(), trait_id, 0, ty, &ty_params);
 
         traits::SelectionContext::new(&infcx).evaluate_obligation_conservatively(&obligation)
     })
@@ -368,7 +378,7 @@ pub fn get_item_name(cx: &LateContext, expr: &Expr) -> Option<Name> {
 /// Convert a span to a code snippet if available, otherwise use default.
 ///
 /// # Example
-/// ```
+/// ```rust,ignore
 /// snippet(cx, expr.span, "..")
 /// ```
 pub fn snippet<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
@@ -385,7 +395,7 @@ pub fn snippet_opt<'a, T: LintContext<'a>>(cx: &T, span: Span) -> Option<String>
 /// things which need to be printed as such.
 ///
 /// # Example
-/// ```
+/// ```rust,ignore
 /// snippet(cx, expr.span, "..")
 /// ```
 pub fn snippet_block<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
@@ -395,7 +405,12 @@ pub fn snippet_block<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'
 
 /// Like `snippet_block`, but add braces if the expr is not an `ExprBlock`.
 /// Also takes an `Option<String>` which can be put inside the braces.
-pub fn expr_block<'a, 'b, T: LintContext<'b>>(cx: &T, expr: &Expr, option: Option<String>, default: &'a str) -> Cow<'a, str> {
+pub fn expr_block<'a, 'b, T: LintContext<'b>>(
+    cx: &T,
+    expr: &Expr,
+    option: Option<String>,
+    default: &'a str
+) -> Cow<'a, str> {
     let code = snippet_block(cx, expr.span, default);
     let string = option.unwrap_or_default();
     if let ExprBlock(_) = expr.node {
@@ -416,32 +431,32 @@ pub fn trim_multiline(s: Cow<str>, ignore_first: bool) -> Cow<str> {
 
 fn trim_multiline_inner(s: Cow<str>, ignore_first: bool, ch: char) -> Cow<str> {
     let x = s.lines()
-             .skip(ignore_first as usize)
-             .filter_map(|l| {
-                 if l.is_empty() {
-                     None
-                 } else {
-                     // ignore empty lines
-                     Some(l.char_indices()
-                           .find(|&(_, x)| x != ch)
-                           .unwrap_or((l.len(), ch))
-                           .0)
-                 }
-             })
-             .min()
-             .unwrap_or(0);
+        .skip(ignore_first as usize)
+        .filter_map(|l| {
+            if l.is_empty() {
+                None
+            } else {
+                // ignore empty lines
+                Some(l.char_indices()
+                    .find(|&(_, x)| x != ch)
+                    .unwrap_or((l.len(), ch))
+                    .0)
+            }
+        })
+        .min()
+        .unwrap_or(0);
     if x > 0 {
         Cow::Owned(s.lines()
-                    .enumerate()
-                    .map(|(i, l)| {
-                        if (ignore_first && i == 0) || l.is_empty() {
-                            l
-                        } else {
-                            l.split_at(x).1
-                        }
-                    })
-                    .collect::<Vec<_>>()
-                    .join("\n"))
+            .enumerate()
+            .map(|(i, l)| {
+                if (ignore_first && i == 0) || l.is_empty() {
+                    l
+                } else {
+                    l.split_at(x).1
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("\n"))
     } else {
         s
     }
@@ -467,7 +482,7 @@ pub fn get_parent_expr<'c>(cx: &'c LateContext, e: &Expr) -> Option<&'c Expr> {
 pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, node: NodeId) -> Option<&'tcx Block> {
     let map = &cx.tcx.map;
     let enclosing_node = map.get_enclosing_scope(node)
-                            .and_then(|enclosing_id| map.find(enclosing_id));
+        .and_then(|enclosing_id| map.find(enclosing_id));
     if let Some(node) = enclosing_node {
         match node {
             Node::NodeBlock(block) => Some(block),
@@ -476,7 +491,7 @@ pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, node: NodeI
                     ExprBlock(ref block) => Some(block),
                     _ => None,
                 }
-            }
+            },
             _ => None,
         }
     } else {
@@ -496,7 +511,7 @@ impl<'a> DiagnosticWrapper<'a> {
     fn wiki_link(&mut self, lint: &'static Lint) {
         if env::var("CLIPPY_DISABLE_WIKI_LINKS").is_err() {
             self.0.help(&format!("for further information visit https://github.com/Manishearth/rust-clippy/wiki#{}",
-                               lint.name_lower()));
+                                 lint.name_lower()));
         }
     }
 }
@@ -508,7 +523,13 @@ pub fn span_lint<'a, T: LintContext<'a>>(cx: &T, lint: &'static Lint, sp: Span,
     }
 }
 
-pub fn span_help_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(cx: &'a T, lint: &'static Lint, span: Span, msg: &str, help: &str) {
+pub fn span_help_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(
+    cx: &'a T,
+    lint: &'static Lint,
+    span: Span,
+    msg: &str,
+    help: &str
+) {
     let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, span, msg));
     if cx.current_level(lint) != Level::Allow {
         db.0.help(help);
@@ -522,7 +543,7 @@ pub fn span_note_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(
     span: Span,
     msg: &str,
     note_span: Span,
-    note: &str,
+    note: &str
 ) {
     let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, span, msg));
     if cx.current_level(lint) != Level::Allow {
@@ -535,8 +556,13 @@ pub fn span_note_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(
     }
 }
 
-pub fn span_lint_and_then<'a, 'tcx: 'a, T: LintContext<'tcx>, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
-    where F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>)
+pub fn span_lint_and_then<'a, 'tcx: 'a, T: LintContext<'tcx>, F>(
+    cx: &'a T,
+    lint: &'static Lint,
+    sp: Span,
+    msg: &str,
+    f: F
+) where F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>)
 {
     let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, sp, msg));
     if cx.current_level(lint) != Level::Allow {
@@ -652,9 +678,9 @@ fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'
 pub fn is_expn_of(cx: &LateContext, mut span: Span, name: &str) -> Option<Span> {
     loop {
         let span_name_span = cx.tcx
-                               .sess
-                               .codemap()
-                               .with_expn_info(span.expn_id, |expn| expn.map(|ei| (ei.callee.name(), ei.call_site)));
+            .sess
+            .codemap()
+            .with_expn_info(span.expn_id, |expn| expn.map(|ei| (ei.callee.name(), ei.call_site)));
 
         match span_name_span {
             Some((mac_name, new_span)) if mac_name == name => return Some(new_span),
@@ -673,9 +699,9 @@ pub fn is_expn_of(cx: &LateContext, mut span: Span, name: &str) -> Option<Span>
 /// `is_direct_expn_of`.
 pub fn is_direct_expn_of(cx: &LateContext, span: Span, name: &str) -> Option<Span> {
     let span_name_span = cx.tcx
-                           .sess
-                           .codemap()
-                           .with_expn_info(span.expn_id, |expn| expn.map(|ei| (ei.callee.name(), ei.call_site)));
+        .sess
+        .codemap()
+        .with_expn_info(span.expn_id, |expn| expn.map(|ei| (ei.callee.name(), ei.call_site)));
 
     match span_name_span {
         Some((mac_name, new_span)) if mac_name == name => Some(new_span),
@@ -709,11 +735,7 @@ pub fn camel_case_until(s: &str) -> usize {
             return i;
         }
     }
-    if up {
-        last_i
-    } else {
-        s.len()
-    }
+    if up { last_i } else { s.len() }
 }
 
 /// Return index of the last camel-case component of `s`.
@@ -757,7 +779,12 @@ pub fn return_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, fn_item: NodeId) -> ty::T
 /// Check if two types are the same.
 // FIXME: this works correctly for lifetimes bounds (`for <'a> Foo<'a>` == `for <'b> Foo<'b>` but
 // not for type parameters.
-pub fn same_tys<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, a: ty::Ty<'tcx>, b: ty::Ty<'tcx>, parameter_item: NodeId) -> bool {
+pub fn same_tys<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    a: ty::Ty<'tcx>,
+    b: ty::Ty<'tcx>,
+    parameter_item: NodeId
+) -> bool {
     let parameter_env = ty::ParameterEnvironment::for_item(cx.tcx, parameter_item);
     cx.tcx.infer_ctxt(None, Some(parameter_env), Reveal::All).enter(|infcx| {
         let new_a = a.subst(infcx.tcx, infcx.parameter_environment.free_substs);
@@ -783,17 +810,21 @@ pub fn is_copy<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, env: Node
 /// Return whether a pattern is refutable.
 pub fn is_refutable(cx: &LateContext, pat: &Pat) -> bool {
     fn is_enum_variant(cx: &LateContext, qpath: &QPath, did: NodeId) -> bool {
-        matches!(cx.tcx.tables().qpath_def(qpath, did), def::Def::Variant(..) | def::Def::VariantCtor(..))
+        matches!(cx.tcx.tables().qpath_def(qpath, did),
+                 def::Def::Variant(..) | def::Def::VariantCtor(..))
     }
 
-    fn are_refutable<'a, I: Iterator<Item=&'a Pat>>(cx: &LateContext, mut i: I) -> bool {
+    fn are_refutable<'a, I: Iterator<Item = &'a Pat>>(cx: &LateContext, mut i: I) -> bool {
         i.any(|pat| is_refutable(cx, pat))
     }
 
     match pat.node {
-        PatKind::Binding(..) | PatKind::Wild => false,
-        PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => is_refutable(cx, pat),
-        PatKind::Lit(..) | PatKind::Range(..) => true,
+        PatKind::Binding(..) |
+        PatKind::Wild => false,
+        PatKind::Box(ref pat) |
+        PatKind::Ref(ref pat, _) => is_refutable(cx, pat),
+        PatKind::Lit(..) |
+        PatKind::Range(..) => true,
         PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.id),
         PatKind::Tuple(ref pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)),
         PatKind::Struct(ref qpath, ref fields, _) => {
@@ -802,17 +833,17 @@ pub fn is_refutable(cx: &LateContext, pat: &Pat) -> bool {
             } else {
                 are_refutable(cx, fields.iter().map(|field| &*field.node.pat))
             }
-        }
+        },
         PatKind::TupleStruct(ref qpath, ref pats, _) => {
             if is_enum_variant(cx, qpath, pat.id) {
                 true
             } else {
                 are_refutable(cx, pats.iter().map(|pat| &**pat))
             }
-        }
+        },
         PatKind::Slice(ref head, ref middle, ref tail) => {
             are_refutable(cx, head.iter().chain(middle).chain(tail.iter()).map(|pat| &**pat))
-        }
+        },
     }
 }
 
@@ -842,17 +873,26 @@ pub fn remove_blocks(expr: &Expr) -> &Expr {
 
 pub fn opt_def_id(def: Def) -> Option<DefId> {
     match def {
-        Def::Fn(id) | Def::Mod(id) | Def::Static(id, _) |
-        Def::Variant(id) | Def::VariantCtor(id, ..) | Def::Enum(id) | Def::TyAlias(id) |
-        Def::AssociatedTy(id) | Def::TyParam(id) | Def::Struct(id) | Def::StructCtor(id, ..) |
-        Def::Union(id) | Def::Trait(id) | Def::Method(id) | Def::Const(id) |
-        Def::AssociatedConst(id) | Def::Local(id) | Def::Upvar(id, ..) | Def::Macro(id) => {
-            Some(id)
-        }
+        Def::Fn(id) |
+        Def::Mod(id) |
+        Def::Static(id, _) |
+        Def::Variant(id) |
+        Def::VariantCtor(id, ..) |
+        Def::Enum(id) |
+        Def::TyAlias(id) |
+        Def::AssociatedTy(id) |
+        Def::TyParam(id) |
+        Def::Struct(id) |
+        Def::StructCtor(id, ..) |
+        Def::Union(id) |
+        Def::Trait(id) |
+        Def::Method(id) |
+        Def::Const(id) |
+        Def::AssociatedConst(id) |
+        Def::Local(id) |
+        Def::Upvar(id, ..) |
+        Def::Macro(id) => Some(id),
 
-        Def::Label(..)  |
-        Def::PrimTy(..) |
-        Def::SelfTy(..) |
-        Def::Err => None,
+        Def::Label(..) | Def::PrimTy(..) | Def::SelfTy(..) | Def::Err => None,
     }
 }
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 347834a062a7..e4938f1c1edc 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -29,9 +29,9 @@ pub const ONE: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("1"));
 impl<'a> Display for Sugg<'a> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         match *self {
-            Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) | Sugg::BinOp(_, ref s) => {
-                s.fmt(f)
-            }
+            Sugg::NonParen(ref s) |
+            Sugg::MaybeParen(ref s) |
+            Sugg::BinOp(_, ref s) => s.fmt(f),
         }
     }
 }
@@ -168,10 +168,12 @@ impl<'a> Sugg<'a> {
         match self {
             Sugg::NonParen(..) => self,
             // (x) and (x).y() both don't need additional parens
-            Sugg::MaybeParen(sugg) => if sugg.starts_with('(') && sugg.ends_with(')') {
-                Sugg::MaybeParen(sugg)
-            } else {
-                Sugg::NonParen(format!("({})", sugg).into())
+            Sugg::MaybeParen(sugg) => {
+                if sugg.starts_with('(') && sugg.ends_with(')') {
+                    Sugg::MaybeParen(sugg)
+                } else {
+                    Sugg::NonParen(format!("({})", sugg).into())
+                }
             },
             Sugg::BinOp(_, sugg) => Sugg::NonParen(format!("({})", sugg).into()),
         }
@@ -247,18 +249,17 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg, rhs: &Sugg) -> Sugg<'static> {
 
     /// Whether the operator is a arithmetic operator (`+`, `-`, `*`, `/`, `%`).
     fn is_arith(op: &AssocOp) -> bool {
-        matches!(*op, AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | AssocOp::Modulus)
+        matches!(*op,
+                 AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | AssocOp::Modulus)
     }
 
     /// Whether the operator `op` needs parenthesis with the operator `other` in the direction
     /// `dir`.
     fn needs_paren(op: &AssocOp, other: &AssocOp, dir: Associativity) -> bool {
         other.precedence() < op.precedence() ||
-            (other.precedence() == op.precedence() &&
-                ((op != other && associativity(op) != dir) ||
-                 (op == other && associativity(op) != Associativity::Both))) ||
-             is_shift(op) && is_arith(other) ||
-             is_shift(other) && is_arith(op)
+        (other.precedence() == op.precedence() &&
+         ((op != other && associativity(op) != dir) || (op == other && associativity(op) != Associativity::Both))) ||
+        is_shift(op) && is_arith(other) || is_shift(other) && is_arith(op)
     }
 
     let lhs_paren = if let Sugg::BinOp(ref lop, _) = *lhs {
@@ -276,24 +277,12 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg, rhs: &Sugg) -> Sugg<'static> {
     let lhs = ParenHelper::new(lhs_paren, lhs);
     let rhs = ParenHelper::new(rhs_paren, rhs);
     let sugg = match op {
-        AssocOp::Add |
-        AssocOp::BitAnd |
-        AssocOp::BitOr |
-        AssocOp::BitXor |
-        AssocOp::Divide |
-        AssocOp::Equal |
-        AssocOp::Greater |
-        AssocOp::GreaterEqual |
-        AssocOp::LAnd |
-        AssocOp::LOr |
-        AssocOp::Less |
-        AssocOp::LessEqual |
-        AssocOp::Modulus |
-        AssocOp::Multiply |
-        AssocOp::NotEqual |
-        AssocOp::ShiftLeft |
-        AssocOp::ShiftRight |
-        AssocOp::Subtract => format!("{} {} {}", lhs, op.to_ast_binop().expect("Those are AST ops").to_string(), rhs),
+        AssocOp::Add | AssocOp::BitAnd | AssocOp::BitOr | AssocOp::BitXor | AssocOp::Divide | AssocOp::Equal |
+        AssocOp::Greater | AssocOp::GreaterEqual | AssocOp::LAnd | AssocOp::LOr | AssocOp::Less |
+        AssocOp::LessEqual | AssocOp::Modulus | AssocOp::Multiply | AssocOp::NotEqual | AssocOp::ShiftLeft |
+        AssocOp::ShiftRight | AssocOp::Subtract => {
+            format!("{} {} {}", lhs, op.to_ast_binop().expect("Those are AST ops").to_string(), rhs)
+        },
         AssocOp::Inplace => format!("in ({}) {}", lhs, rhs),
         AssocOp::Assign => format!("{} = {}", lhs, rhs),
         AssocOp::AssignOp(op) => format!("{} {}= {}", lhs, binop_to_string(op), rhs),
@@ -335,11 +324,10 @@ fn associativity(op: &AssocOp) -> Associativity {
 
     match *op {
         Inplace | Assign | AssignOp(_) => Associativity::Right,
-        Add | BitAnd | BitOr | BitXor | LAnd | LOr | Multiply |
-        As | Colon => Associativity::Both,
-    Divide | Equal | Greater | GreaterEqual | Less | LessEqual | Modulus | NotEqual | ShiftLeft |
-        ShiftRight | Subtract => Associativity::Left,
-        DotDot | DotDotDot => Associativity::None
+        Add | BitAnd | BitOr | BitXor | LAnd | LOr | Multiply | As | Colon => Associativity::Both,
+        Divide | Equal | Greater | GreaterEqual | Less | LessEqual | Modulus | NotEqual | ShiftLeft | ShiftRight |
+        Subtract => Associativity::Left,
+        DotDot | DotDotDot => Associativity::None,
     }
 }
 
@@ -410,10 +398,10 @@ pub trait DiagnosticBuilderExt<'a, T: LintContext<'a>> {
     ///
     /// # Example
     ///
-    /// ```rust
+    /// ```rust,ignore
     /// db.suggest_item_with_attr(cx, item, "#[derive(Default)]");
     /// ```
-    fn suggest_item_with_attr<D: Display+?Sized>(&mut self, cx: &T, item: Span, msg: &str, attr: &D);
+    fn suggest_item_with_attr<D: Display + ?Sized>(&mut self, cx: &T, item: Span, msg: &str, attr: &D);
 
     /// Suggest to add an item before another.
     ///
@@ -421,7 +409,7 @@ pub trait DiagnosticBuilderExt<'a, T: LintContext<'a>> {
     ///
     /// # Example
     ///
-    /// ```rust
+    /// ```rust,ignore
     /// db.suggest_prepend_item(cx, item,
     /// "fn foo() {
     ///     bar();
@@ -431,12 +419,9 @@ pub trait DiagnosticBuilderExt<'a, T: LintContext<'a>> {
 }
 
 impl<'a, 'b, 'c, T: LintContext<'c>> DiagnosticBuilderExt<'c, T> for rustc_errors::DiagnosticBuilder<'b> {
-    fn suggest_item_with_attr<D: Display+?Sized>(&mut self, cx: &T, item: Span, msg: &str, attr: &D) {
+    fn suggest_item_with_attr<D: Display + ?Sized>(&mut self, cx: &T, item: Span, msg: &str, attr: &D) {
         if let Some(indent) = indentation(cx, item) {
-            let span = Span {
-                hi: item.lo,
-                ..item
-            };
+            let span = Span { hi: item.lo, ..item };
 
             self.span_suggestion(span, msg, format!("{}\n{}", attr, indent));
         }
@@ -444,20 +429,19 @@ impl<'a, 'b, 'c, T: LintContext<'c>> DiagnosticBuilderExt<'c, T> for rustc_error
 
     fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str) {
         if let Some(indent) = indentation(cx, item) {
-            let span = Span {
-                hi: item.lo,
-                ..item
-            };
+            let span = Span { hi: item.lo, ..item };
 
             let mut first = true;
-            let new_item = new_item.lines().map(|l| {
-                if first {
-                    first = false;
-                    format!("{}\n", l)
-                } else {
-                    format!("{}{}\n", indent, l)
-                }
-            }).collect::<String>();
+            let new_item = new_item.lines()
+                .map(|l| {
+                    if first {
+                        first = false;
+                        format!("{}\n", l)
+                    } else {
+                        format!("{}{}\n", indent, l)
+                    }
+                })
+                .collect::<String>();
 
             self.span_suggestion(span, msg, format!("{}\n{}", new_item, indent));
         }
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 1cfb57496f7a..dd3d4d261d05 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -65,7 +65,7 @@ fn check_vec_macro(cx: &LateContext, vec_args: &higher::VecArgs, span: Span) {
             } else {
                 return;
             }
-        }
+        },
         higher::VecArgs::Vec(args) => {
             if let Some(last) = args.iter().last() {
                 let span = Span {
@@ -78,7 +78,7 @@ fn check_vec_macro(cx: &LateContext, vec_args: &higher::VecArgs, span: Span) {
             } else {
                 "&[]".into()
             }
-        }
+        },
     };
 
     span_lint_and_then(cx, USELESS_VEC, span, "useless use of `vec!`", |db| {
diff --git a/rustfmt.toml b/rustfmt.toml
index 6daad2b65bd9..18d146d49173 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1,6 +1,8 @@
 max_width = 120
 ideal_width = 100
-fn_args_density = "Compressed"
 fn_call_width = 80
-fn_args_paren_newline = false
 match_block_trailing_comma = true
+fn_args_layout = "Block"
+closure_block_indent_threshold = 0
+fn_return_indent = "WithWhereClause"
+wrap_comments = true
diff --git a/src/main.rs b/src/main.rs
index 89db653929c2..0b91c79d21bc 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -38,19 +38,35 @@ impl ClippyCompilerCalls {
 }
 
 impl<'a> CompilerCalls<'a> for ClippyCompilerCalls {
-    fn early_callback(&mut self, matches: &getopts::Matches, sopts: &config::Options, cfg: &ast::CrateConfig,
-                      descriptions: &rustc_errors::registry::Registry, output: ErrorOutputType)
-                      -> Compilation {
+    fn early_callback(
+        &mut self,
+        matches: &getopts::Matches,
+        sopts: &config::Options,
+        cfg: &ast::CrateConfig,
+        descriptions: &rustc_errors::registry::Registry,
+        output: ErrorOutputType
+    ) -> Compilation {
         self.default.early_callback(matches, sopts, cfg, descriptions, output)
     }
-    fn no_input(&mut self, matches: &getopts::Matches, sopts: &config::Options, cfg: &ast::CrateConfig,
-                odir: &Option<PathBuf>, ofile: &Option<PathBuf>, descriptions: &rustc_errors::registry::Registry)
-                -> Option<(Input, Option<PathBuf>)> {
+    fn no_input(
+        &mut self,
+        matches: &getopts::Matches,
+        sopts: &config::Options,
+        cfg: &ast::CrateConfig,
+        odir: &Option<PathBuf>,
+        ofile: &Option<PathBuf>,
+        descriptions: &rustc_errors::registry::Registry
+    ) -> Option<(Input, Option<PathBuf>)> {
         self.default.no_input(matches, sopts, cfg, odir, ofile, descriptions)
     }
-    fn late_callback(&mut self, matches: &getopts::Matches, sess: &Session, input: &Input, odir: &Option<PathBuf>,
-                     ofile: &Option<PathBuf>)
-                     -> Compilation {
+    fn late_callback(
+        &mut self,
+        matches: &getopts::Matches,
+        sess: &Session,
+        input: &Input,
+        odir: &Option<PathBuf>,
+        ofile: &Option<PathBuf>
+    ) -> Compilation {
         self.default.late_callback(matches, sess, input, odir, ofile)
     }
     fn build_controller(&mut self, sess: &Session, matches: &getopts::Matches) -> driver::CompileController<'a> {
diff --git a/tests/compile-fail/absurd-extreme-comparisons.rs b/tests/compile-fail/absurd-extreme-comparisons.rs
index 627cd888aac1..81cb658df8de 100644
--- a/tests/compile-fail/absurd-extreme-comparisons.rs
+++ b/tests/compile-fail/absurd-extreme-comparisons.rs
@@ -9,7 +9,7 @@ fn main() {
     let u: u32 = 42;
 
     u <= 0;
-    //~^ ERROR this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
+    //~^ ERROR this comparison involving the minimum or maximum element for this type contains a
     //~| HELP using u == 0 instead
     u <= Z;
     //~^ ERROR this comparison involving
@@ -41,10 +41,10 @@ fn main() {
         //~| HELP because 1-1 is the minimum value for this type, this comparison is always false
     u >= !0;
         //~^ ERROR this comparison involving
-        //~| HELP because !0 is the maximum value for this type, the case where the two sides are not equal never occurs, consider using u == !0 instead
+        //~| HELP consider using u == !0 instead
     u <= 12 - 2*6;
         //~^ ERROR this comparison involving
-        //~| HELP because 12 - 2*6 is the minimum value for this type, the case where the two sides are not equal never occurs, consider using u == 12 - 2*6 instead
+        //~| HELP consider using u == 12 - 2*6 instead
 
     let i: i8 = 0;
     i < -127 - 1;
diff --git a/tests/compile-fail/block_in_if_condition.rs b/tests/compile-fail/block_in_if_condition.rs
index 43216754f753..090c39abc926 100644
--- a/tests/compile-fail/block_in_if_condition.rs
+++ b/tests/compile-fail/block_in_if_condition.rs
@@ -21,13 +21,13 @@ macro_rules! blocky_too {
 fn macro_if() {
     if blocky!() {
     }
-    
+
     if blocky_too!() {
     }
 }
 
 fn condition_has_block() -> i32 {
-    if { //~ERROR in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'
+    if { //~ERROR in an 'if' condition, avoid complex blocks or closures with blocks;
         let x = 3;
         x == 3
     } {
@@ -55,12 +55,12 @@ fn pred_test() {
     // this is a sneaky case, where the block isn't directly in the condition, but is actually
     // inside a closure that the condition is using.  same principle applies.  add some extra
     // expressions to make sure linter isn't confused by them.
-    if v == 3 && sky == "blue" && predicate(|x| { let target = 3; x == target }, v) { //~ERROR in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'
-
+    if v == 3 && sky == "blue" && predicate(|x| { let target = 3; x == target }, v) {
+        //~^ERROR in an 'if' condition, avoid complex blocks or closures with blocks;
     }
 
-    if predicate(|x| { let target = 3; x == target }, v) { //~ERROR in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'
-
+    if predicate(|x| { let target = 3; x == target }, v) {
+        //~^ERROR in an 'if' condition, avoid complex blocks or closures with blocks;
     }
 
 }
diff --git a/util/update_lints.py b/util/update_lints.py
index 965d7e272c5b..ddb5d3ab32fd 100755
--- a/util/update_lints.py
+++ b/util/update_lints.py
@@ -98,7 +98,10 @@ def gen_deprecated(lints):
     """Declare deprecated lints"""
 
     for lint in lints:
-        yield '    store.register_removed("%s", "%s");\n' % (lint[1], lint[2])
+        yield '    store.register_removed(\n'
+        yield '        "%s",\n' % lint[1]
+        yield '        "%s",\n' % lint[2]
+        yield '    );\n'
 
 
 def replace_region(fn, region_start, region_end, callback,