also run rustfmt on clippy-lints

.travis.yml

@@ -25,6 +25,7 @@ script:
  - remark -f README.md > /dev/null
  - python util/update_lints.py -c
  - PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff
+ - cd clippy_lints && PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff
  - set -e
  - cargo build --features debugging
  - cargo test --features debugging

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);
                 }
-            }
+            },
             _ => (),
         }
     }

clippy_lints/src/array_indexing.rs

@@ -123,7 +123,7 @@ fn to_const_range(start: Option<Option<ConstVal>>, end: Option<Option<ConstVal>>
             } else {
                 x
             }
-        }
+        },
         Some(_) => return None,
         None => array_size,
     };

clippy_lints/src/assign_ops.rs

@@ -95,8 +95,8 @@ 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)) {
+                                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));
@@ -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| {
@@ -176,8 +176,8 @@ 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)) {
+                                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));
@@ -195,13 +195,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 +209,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,
     }
 }

clippy_lints/src/attrs.rs

@@ -120,11 +120,15 @@ 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, '!');
-                                            db.span_suggestion(attr.span, "if you just forgot a `!`, use", sugg);
+                                                               db.span_suggestion(attr.span,
+                                                                                  "if you just forgot a `!`, use",
+                                                                                  sugg);
                                                            });
                                     }
                                 }
@@ -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,
     }
 }

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,
     }
 }

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);

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),
         }
     }

clippy_lints/src/collapsible_if.rs

@@ -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,
@@ -151,7 +146,8 @@ fn expr_block(block: &ast::Block) -> Option<&ast::Expr> {
 
     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 {

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()) {
+                    (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
+                            (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,
@@ -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);

clippy_lints/src/copies.rs

@@ -205,7 +205,9 @@ 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));
+                        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));
                     }
@@ -253,7 +255,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 +263,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 +284,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 +322,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]);
-            }
+            },
         }
     }
 

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),
         }

clippy_lints/src/derive.rs

@@ -149,18 +149,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;
-                            }
+                            },
                             _ => (),
                         }
                     }
                 }
-            }
+            },
             _ => (),
         }
 

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| {
+        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);
@@ -299,16 +294,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 +313,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 +331,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 +357,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 +382,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
     }
 

clippy_lints/src/entry.rs

@@ -78,7 +78,8 @@ 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,

clippy_lints/src/enum_variants.rs

@@ -78,7 +78,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 +111,8 @@ 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 +203,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 {

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,
     }
 }

clippy_lints/src/escape.rs

@@ -61,15 +61,8 @@ impl LintPass for Pass {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'a, 'tcx>,
-        _: visit::FnKind<'tcx>,
-        decl: &'tcx FnDecl,
-        body: &'tcx Expr,
-        _: Span,
-        id: NodeId,
-    ) {
+    fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, _: visit::FnKind<'tcx>, decl: &'tcx FnDecl, body: &'tcx Expr,
+                _: Span, id: NodeId) {
         let param_env = ty::ParameterEnvironment::for_item(cx.tcx, id);
 
         let infcx = cx.tcx.borrowck_fake_infer_ctxt(param_env);
@@ -157,7 +150,8 @@ impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'g
 
         if let Categorization::Local(lid) = cmt.cat {
             if self.set.contains(&lid) {
-                if let Some(&Adjust::DerefRef { autoderefs, .. }) = self.tcx
+                if let Some(&Adjust::DerefRef { autoderefs, .. }) =
+                    self.tcx
                         .tables
                         .borrow()
                         .adjustments
@@ -173,7 +167,8 @@ 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
+                    if let Some(&Adjust::DerefRef { autoderefs, .. }) =
+                        self.tcx
                             .tables
                             .borrow()
                             .adjustments

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) {

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 {
+            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 {
+                    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);
@@ -195,7 +194,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,
@@ -229,7 +228,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 +237,7 @@ fn check_expr<'a, 'tcx>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> S
             } else {
                 walk_expr(vis, expr);
             }
-        }
+        },
         ExprClosure(_, _, _, _) => {
             // Either
             //
@@ -252,10 +251,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 +275,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))
-        }
+        },
     }
 }
 

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,

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);
-                }
+                },
                 _ => (),
             }
         }

clippy_lints/src/functions.rs

@@ -69,15 +69,8 @@ impl LintPass for Functions {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'a, 'tcx>,
-        kind: intravisit::FnKind<'tcx>,
-        decl: &'tcx hir::FnDecl,
-        expr: &'tcx hir::Expr,
-        span: Span,
-        nodeid: ast::NodeId,
-    ) {
+    fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, kind: intravisit::FnKind<'tcx>, decl: &'tcx hir::FnDecl,
+                expr: &'tcx hir::Expr, span: Span, nodeid: ast::NodeId) {
         use rustc::hir::map::Node::*;
 
         let is_impl = if let Some(NodeItem(item)) = cx.tcx.map.find(cx.tcx.map.get_parent_node(nodeid)) {
@@ -131,14 +124,8 @@ impl<'a, 'tcx> Functions {
         }
     }
 
-    fn check_raw_ptr(
-        &self,
-        cx: &LateContext<'a, 'tcx>,
-        unsafety: hir::Unsafety,
-        decl: &'tcx hir::FnDecl,
-        expr: &'tcx hir::Expr,
-        nodeid: ast::NodeId,
-    ) {
+    fn check_raw_ptr(&self, cx: &LateContext<'a, 'tcx>, unsafety: hir::Unsafety, decl: &'tcx hir::FnDecl,
+                     expr: &'tcx hir::Expr, 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 +165,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 +175,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),
             _ => (),
         }

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);
-                }
+                },
                 _ => (),
             }
         }

clippy_lints/src/if_let_redundant_pattern_matching.rs

@@ -51,7 +51,6 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
 
                 let good_method = match arms[0].pats[0].node {
                     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,
@@ -80,9 +77,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                         hi: op.span.hi,
                         expn_id: expr.span.expn_id,
                     };
-                                        db.span_suggestion(span,
-                                                           "try this",
-                                                           format!("if {}.{}", snippet(cx, op.span, "_"), good_method));
+                    db.span_suggestion(span, "try this", format!("if {}.{}", snippet(cx, op.span, "_"), good_method));
                 });
             }
 

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");
-                    }
+                    },
                     _ => (),
                 }
             }

clippy_lints/src/items_after_statements.rs

@@ -47,7 +47,8 @@ impl EarlyLintPass for ItemsAfterStatements {
         }
 
         // skip initial items
-        let stmts = item.stmts.iter()
+        let stmts = item.stmts
+            .iter()
             .map(|stmt| &stmt.node)
             .skip_while(|s| matches!(**s, StmtKind::Item(..)));
 

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,11 +197,9 @@ 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));
@@ -212,7 +208,7 @@ fn has_is_empty(cx: &LateContext, expr: &Expr) -> bool {
             cx.tcx
                 .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,

clippy_lints/src/let_if_seq.rs

@@ -149,11 +149,8 @@ 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,
-) -> Option<&'tcx hir::Expr> {
+fn check_assign<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, decl: hir::def_id::DefId, block: &'tcx hir::Block)
+                          -> Option<&'tcx hir::Expr> {
     if_let_chain! {[
         block.expr.is_none(),
         let Some(expr) = block.stmts.iter().last(),
@@ -182,11 +179,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,

clippy_lints/src/lifetimes.rs

@@ -98,12 +98,7 @@ fn bound_lifetimes(bound: &TyParamBound) -> HirVec<&Lifetime> {
     }
 }
 
-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;
     }
@@ -121,16 +116,10 @@ fn check_fn_inner<'a, 'tcx>(
     report_extra_lifetimes(cx, decl, generics);
 }
 
-fn could_use_elision<
-    'a,
-    'tcx: 'a,
-    T: Iterator<Item = &'tcx Lifetime>
->(
-    cx: &LateContext<'a, 'tcx>,
+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,
-) -> bool {
+                                                                       named_lts: &'tcx [LifetimeDef], bounds_lts: T)
+                                                                       -> bool {
     // There are two scenarios where elision works:
     // * no output references, all input references have different LT
     // * output references, exactly one input reference with same LT
@@ -262,13 +251,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 +275,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 +314,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

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) {
@@ -358,7 +357,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                                                        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, "_");
@@ -407,13 +404,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     }
 }
 
-fn check_for_loop<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
-    pat: &'tcx Pat,
-    arg: &'tcx Expr,
-    body: &'tcx Expr,
-    expr: &'tcx Expr,
-) {
+fn check_for_loop<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, arg: &'tcx Expr, body: &'tcx Expr,
+                            expr: &'tcx Expr) {
     check_for_loop_range(cx, pat, arg, body, expr);
     check_for_loop_reverse_range(cx, arg, expr);
     check_for_loop_arg(cx, pat, arg, expr);
@@ -423,13 +415,8 @@ fn check_for_loop<'a, 'tcx>(
 
 /// Check for looping over a range and then indexing a sequence with it.
 /// The iteratee must be a range literal.
-fn check_for_loop_range<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
-    pat: &'tcx Pat,
-    arg: &'tcx Expr,
-    body: &'tcx Expr,
-    expr: &'tcx Expr,
-) {
+fn check_for_loop_range<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, arg: &'tcx Expr, body: &'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
         if let PatKind::Binding(_, def_id, ref ident, _) = pat.node {
@@ -472,10 +459,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 {
@@ -544,7 +529,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),
                 };
 
@@ -563,9 +548,8 @@ fn check_for_loop_reverse_range(cx: &LateContext, arg: &Expr, expr: &Expr) {
                                        "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",
+                                           "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,
@@ -658,12 +642,8 @@ fn check_arg_type(cx: &LateContext, pat: &Pat, arg: &Expr) {
     }
 }
 
-fn check_for_loop_explicit_counter<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
-    arg: &'tcx Expr,
-    body: &'tcx Expr,
-    expr: &'tcx Expr,
-) {
+fn check_for_loop_explicit_counter<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arg: &'tcx Expr, body: &'tcx Expr,
+                                             expr: &'tcx Expr) {
     // Look for variables that are incremented once per loop iteration.
     let mut visitor = IncrementVisitor {
         cx: cx,
@@ -708,13 +688,8 @@ fn check_for_loop_explicit_counter<'a, 'tcx>(
 }
 
 /// Check for the `FOR_KV_MAP` lint.
-fn check_for_loop_over_map_kv<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
-    pat: &'tcx Pat,
-    arg: &'tcx Expr,
-    body: &'tcx Expr,
-    expr: &'tcx Expr,
-) {
+fn check_for_loop_over_map_kv<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, arg: &'tcx Expr,
+                                        body: &'tcx Expr, expr: &'tcx Expr) {
     let pat_span = pat.span;
 
     if let PatKind::Tuple(ref pat, _) = pat.node {
@@ -739,10 +714,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 +726,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 +737,7 @@ fn pat_is_wild<'a, 'tcx: 'a>(
             };
             walk_expr(&mut visitor, body);
             !visitor.used
-        }
+        },
         _ => false,
     }
 }
@@ -938,10 +909,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 +927,7 @@ fn is_break_expr(expr: &Expr) -> bool {
                 Some(subexpr) => is_break_expr(subexpr),
                 None => false,
             }
-        }
+        },
         _ => false,
     }
 }
@@ -1004,7 +976,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 +1053,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,
                     _ => (),
                 }

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,
     }
 }

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)
     }
 }
 
@@ -209,7 +213,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 +276,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,
                     };
 
@@ -349,7 +351,8 @@ fn all_ranges(cx: &LateContext, arms: &[Arm]) -> Vec<SpannedRange<ConstVal>> {
                     pats.iter()
                 } else {
                     [].iter()
-            }.filter_map(|pat| {
+                }
+                .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),
@@ -481,7 +484,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())),
         }

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);
                 }
-            }
+            },
             _ => (),
         }
     }
@@ -708,7 +708,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;
@@ -720,8 +721,10 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir:
                                            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, "_")));
+                                               db.span_suggestion(span,
+                                                                  "try this",
+                                                                  format!("{}.unwrap_or_default()",
+                                                                          snippet(cx, self_expr.span, "_")));
                                            });
                         return true;
                     }
@@ -733,8 +736,8 @@ 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,12 +746,10 @@ 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"),
+        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::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);
@@ -770,7 +771,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 +805,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 +831,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,13 +856,9 @@ 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",
+        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,
@@ -892,24 +897,20 @@ fn lint_iter_nth(cx: &LateContext, expr: &hir::Expr, iter_args: &[hir::Expr], is
     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,
+    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)
-    );
+                       mut_str,
+                       caller_type));
 }
 
 fn lint_get_unwrap(cx: &LateContext, expr: &hir::Expr, get_args: &[hir::Expr], is_mut: bool) {
@@ -932,32 +933,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,
+    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),
+                                mut_str,
+                                caller_type),
                        |db| {
-            db.span_suggestion(
-                expr.span,
+        db.span_suggestion(expr.span,
                            "try this",
-                format!("{}{}[{}]", borrow_str, snippet(cx, get_args[0].span, "_"),
-                        snippet(cx, get_args[1].span, "_"))
-            );
-        }
-    );
+                           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) {
     // lint if caller of skip is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-         span_lint(
-            cx,
+        span_lint(cx,
                   ITER_SKIP_NEXT,
                   expr.span,
-            "called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)`"
-        );
+                  "called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)`");
     }
 }
 
@@ -975,9 +973,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 +987,7 @@ fn derefs_to_slice(cx: &LateContext, expr: &hir::Expr, ty: ty::Ty) -> Option<sug
                 } else {
                     None
                 }
-            }
+            },
             _ => None,
         }
     }
@@ -1099,8 +1095,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
@@ -1163,8 +1159,8 @@ fn lint_search_is_some(cx: &LateContext, expr: &hir::Expr, search_method: &str,
                        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 {

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");
-                    }
+                    },
                 }
             }
         }

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`.
@@ -167,7 +165,8 @@ impl LintPass for Pass {
 }
 
 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;
@@ -240,11 +239,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                         return;
                     }
                 }
-                span_lint_and_then(cx,
-                                   FLOAT_CMP,
-                                   expr.span,
-                                   "strict comparison of f32 or f64",
-                                   |db| {
+                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, "..");
 
@@ -274,7 +269,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 +277,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                 } else {
                     None
                 }
-            }
+            },
             _ => None,
         };
         if let Some(binding) = binding {
@@ -339,9 +334,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 +354,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 +365,7 @@ fn check_to_owned(cx: &LateContext, expr: &Expr, other: &Expr, left: bool, op: S
             } else {
                 return;
             }
-        }
+        },
         _ => return,
     };
 
@@ -408,8 +402,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 +423,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,
     }
 }

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)
     }
 }
 
@@ -279,7 +284,7 @@ impl EarlyLintPass for MiscEarly {
                                            });
                     }
                 }
-            }
+            },
             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,
@@ -351,8 +356,8 @@ impl EarlyLintPass for MiscEarly {
                         prev = ch;
                     }
                 }}
-            }
-            _ => ()
+            },
+            _ => (),
         }
     }
 

clippy_lints/src/missing_doc.rs

@@ -1,21 +1,21 @@
-/* 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 +51,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 +76,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 +91,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 +148,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 {

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");
             }
 
         }

clippy_lints/src/mut_reference.rs

@@ -39,18 +39,17 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnecessaryMutPassed {
             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 \
+                    .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));
                         }
-                    }
+                    },
                     _ => (),
                 }
             }
-        }
+        },
         _ => (),
     }
 }

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)
@@ -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),
@@ -130,7 +126,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison {
                                        |db| {
                                            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,
@@ -140,7 +136,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison {
                                        |db| {
                                            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,11 @@ 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 +156,11 @@ 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 +186,7 @@ fn fetch_bool_block(block: &Block) -> Expression {
             } else {
                 Expression::Other
             }
-        }
+        },
         _ => Expression::Other,
     }
 }
@@ -200,13 +200,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,
     }
 }

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")
                     }
                 }
             }

clippy_lints/src/new_without_default.rs

@@ -90,15 +90,8 @@ impl LintPass for NewWithoutDefault {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'a, 'tcx>,
-        kind: FnKind<'tcx>,
-        decl: &'tcx hir::FnDecl,
-        _: &'tcx hir::Expr,
-        span: Span,
-        id: ast::NodeId,
-    ) {
+    fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, kind: FnKind<'tcx>, decl: &'tcx hir::FnDecl,
+                _: &'tcx hir::Expr, span: Span, id: ast::NodeId) {
         if in_external_macro(cx, span) {
             return;
         }
@@ -161,7 +154,7 @@ fn can_derive_default<'t, 'c>(ty: ty::Ty<'t>, cx: &LateContext<'c, 't>, default_
                 }
             }
             true
-        }
+        },
         _ => false,
     }
 }

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,
     }
 }

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),
         }
     }

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);;
-            }
+            },
         }
     }
 

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, "..")));
-                            }
+                            },
                             _ => (),
                         }
                     }

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);
             }
         }
     }

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)
 }

clippy_lints/src/reference.rs

@@ -40,14 +40,8 @@ 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, "_")));
                 });
             }
         }

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,14 @@ 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()));
-                }
+                },
             }
         }
     } else if let Some(r) = const_str(cx, expr) {
@@ -233,7 +234,7 @@ fn check_regex(cx: &LateContext, expr: &Expr, utf8: bool) {
                                        "trivial regex",
                                        &format!("consider using {}", repl));
                 }
-            }
+            },
             Err(e) => {
                 span_lint(cx,
                           INVALID_REGEX,
@@ -241,7 +242,7 @@ fn check_regex(cx: &LateContext, expr: &Expr, utf8: bool) {
                           &format!("regex syntax error on position {}: {}",
                                    e.position(),
                                    e.description()));
-            }
+            },
         }
     }
 }

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
     }
 }
-

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`");
                         }
                     }
                 }

clippy_lints/src/shadow.rs

@@ -80,15 +80,8 @@ impl LintPass for Pass {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'a, 'tcx>,
-        _: FnKind<'tcx>,
-        decl: &'tcx FnDecl,
-        expr: &'tcx Expr,
-        _: Span,
-        _: NodeId,
-    ) {
+    fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, _: FnKind<'tcx>, decl: &'tcx FnDecl, expr: &'tcx Expr,
+                _: Span, _: NodeId) {
         if in_external_macro(cx, expr.span) {
             return;
         }
@@ -150,13 +143,8 @@ fn is_binding(cx: &LateContext, pat_id: NodeId) -> bool {
     }
 }
 
-fn check_pat<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
-    pat: &'tcx Pat,
-    init: Option<&'tcx Expr>,
-    span: Span,
-    bindings: &mut Vec<(Name, Span)>,
-) {
+fn check_pat<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, init: Option<&'tcx Expr>, span: Span,
+                       bindings: &mut Vec<(Name, Span)>) {
     // TODO: match more stuff / destructuring
     match pat.node {
         PatKind::Binding(_, _, ref ident, ref inner) => {
@@ -178,7 +166,7 @@ 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 {
@@ -199,7 +187,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 +204,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,21 +215,15 @@ 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>>),
         _ => (),
     }
 }
 
-fn lint_shadow<'a, 'tcx: 'a>(
-    cx: &LateContext<'a, 'tcx>,
-    name: Name,
-    span: Span,
-    pattern_span: Span,
-    init: Option<&'tcx Expr>,
-    prev_span: Span,
-) {
+fn lint_shadow<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, name: Name, span: Span, pattern_span: Span,
+                             init: Option<&'tcx Expr>, prev_span: Span) {
     if let Some(expr) = init {
         if is_self_shadow(name, expr) {
             span_lint_and_then(cx,
@@ -250,8 +232,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,
@@ -281,7 +264,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 +288,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 +314,7 @@ fn check_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings:
                     bindings.truncate(len);
                 }
             }
-        }
+        },
         _ => (),
     }
 }
@@ -341,14 +326,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 +345,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,

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,
     }
 }

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");
                     }
-                }
+                },
                 _ => (),
             }
         }

clippy_lints/src/transmute.rs

@@ -95,14 +95,14 @@ 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,
+                        _ 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,
+                                      &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",
@@ -116,11 +116,11 @@ 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,
+                        (&ty::TyUint(_), &TyRawPtr(_)) => {
+                            span_lint_and_then(cx,
                                                USELESS_TRANSMUTE,
                                                e.span,
                                                "transmute from an integer to a pointer",
@@ -128,33 +128,33 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                                 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,
+                        (&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,
+                                      &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,
+                                     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),
-                        ),
+                                     to_ty))
+                        },
                         (&TyRawPtr(from_pty), &TyRef(_, to_rty)) => span_lint_and_then(
                             cx,
                             TRANSMUTE_PTR_TO_REF,

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
@@ -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 {
@@ -388,7 +384,7 @@ 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 {
@@ -398,7 +394,7 @@ fn check_truncation_and_wrapping(cx: &LateContext, expr: &Expr, cast_from: &ty::
              },
              to_nbits <= 32 && cast_unsigned_to_signed,
              ArchSuffix::_32)
-        }
+        },
         (false, true) => {
             (from_nbits == 64,
              ArchSuffix::_32,
@@ -408,7 +404,7 @@ fn check_truncation_and_wrapping(cx: &LateContext, expr: &Expr, cast_from: &ty::
              } else {
                  ArchSuffix::_32
              })
-        }
+        },
     };
     if span_truncation {
         span_lint(cx,
@@ -463,7 +459,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 +471,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 +480,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 +532,8 @@ 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 +626,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),
@@ -775,7 +769,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 +778,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 +858,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 +961,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 +970,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 +995,7 @@ fn node_as_const_fullint(cx: &LateContext, expr: &Expr) -> Option<FullInt> {
             } else {
                 None
             }
-        }
+        },
         Err(_) => None,
     }
 }
@@ -1036,14 +1030,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 +1048,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)

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
+                    unsafe_to_safe_check(path.segments
                                              .last()
                                              .expect("use paths cannot be empty")
                                              .identifier,
                                          *name,
-                        cx, &item.span
-                        );
-                }
+                                         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));
     }
 }
 

clippy_lints/src/unused_label.rs

@@ -41,15 +41,8 @@ impl LintPass for UnusedLabel {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedLabel {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'a, 'tcx>,
-        kind: FnKind<'tcx>,
-        decl: &'tcx hir::FnDecl,
-        body: &'tcx hir::Expr,
-        span: Span,
-        fn_id: ast::NodeId,
-    ) {
+    fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, kind: FnKind<'tcx>, decl: &'tcx hir::FnDecl,
+                body: &'tcx hir::Expr, span: Span, fn_id: ast::NodeId) {
         if in_macro(cx, span) {
             return;
         }
@@ -72,11 +65,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);
-            }
+            },
             _ => (),
         }
 

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)),

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.
+    Type(/// The name of the key.
          &'static str,
          /// The expected type.
          &'static str,
          /// The type we got instead.
-        &'static str
-    ),
+         &'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),
         }
     }
@@ -196,7 +193,7 @@ pub fn lookup_conf_file() -> io::Result<Option<path::PathBuf>> {
                     if e.kind() != io::ErrorKind::NotFound {
                         return Err(e);
                     }
-                }
+                },
                 _ => (),
             }
         }
@@ -231,11 +228,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);

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"];

clippy_lints/src/utils/higher.rs

@@ -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 {
@@ -104,7 +104,7 @@ pub fn range(expr: &hir::Expr) -> Option<Range> {
             } else {
                 None
             }
-        }
+        },
         _ => None,
     }
 }

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,10 +515,10 @@ 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);
     }
@@ -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);
-            }
+            },
         }
     }
 }

clippy_lints/src/utils/inspector.rs

@@ -67,25 +67,24 @@ 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 +114,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 +280,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 +354,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)),

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);
             }
         }

clippy_lints/src/utils/mod.rs

@@ -95,7 +95,8 @@ 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 {
+    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"
@@ -104,6 +105,7 @@ pub fn in_macro<'a, T: LintContext<'a>>(cx: &T, span: Span) -> bool {
                 }
             },
             None => false,
+        }
     })
 }
 
@@ -160,8 +162,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.
@@ -208,9 +209,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
+        QPath::Resolved(_, ref path) => {
+            path.segments
                 .last()
-                                            .expect("A path must have at least one segment"),
+                .expect("A path must have at least one segment")
+        },
         QPath::TypeRelative(_, ref seg) => seg,
     }
 }
@@ -232,13 +235,14 @@ pub fn single_segment_path(path: &QPath) -> Option<&PathSegment> {
 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 {
+        QPath::TypeRelative(ref ty, ref segment) => {
+            match ty.node {
                 TyPath(ref inner_path) => {
-                segments.len() > 0 &&
-                match_path(inner_path, &segments[..(segments.len() - 1)]) &&
+                    segments.len() > 0 && match_path(inner_path, &segments[..(segments.len() - 1)]) &&
                     segment.name == segments[segments.len() - 1]
                 },
                 _ => false,
+            }
         },
     }
 }
@@ -265,7 +269,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();
 
@@ -313,11 +320,7 @@ pub fn implements_trait<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>,
 
     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)
     })
@@ -395,7 +398,8 @@ 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 {
@@ -476,7 +480,7 @@ pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, node: NodeI
                     ExprBlock(ref block) => Some(block),
                     _ => None,
                 }
-            }
+            },
             _ => None,
         }
     } else {
@@ -508,7 +512,8 @@ 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);
@@ -516,14 +521,8 @@ pub fn span_help_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(cx: &'a T, lint: &
     }
 }
 
-pub fn span_note_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    note_span: Span,
-    note: &str,
-) {
+pub fn span_note_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(cx: &'a T, lint: &'static Lint, span: Span, msg: &str,
+                                                              note_span: Span, note: &str) {
     let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, span, msg));
     if cx.current_level(lint) != Level::Allow {
         if note_span == span {
@@ -535,7 +534,8 @@ 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)
+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));
@@ -709,11 +709,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 +753,8 @@ 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);
@@ -791,9 +788,12 @@ pub fn is_refutable(cx: &LateContext, pat: &Pat) -> bool {
     }
 
     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 +802,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 +842,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,
     }
 }

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) => {
+                if sugg.starts_with('(') && sugg.ends_with(')') {
                     Sugg::MaybeParen(sugg)
                 } else {
                     Sugg::NonParen(format!("({})", sugg).into())
+                }
             },
             Sugg::BinOp(_, sugg) => Sugg::NonParen(format!("({})", sugg).into()),
         }
@@ -255,10 +257,8 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg, rhs: &Sugg) -> Sugg<'static> {
     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)
+         ((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 +276,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 +323,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,
     }
 }
 
@@ -433,10 +420,7 @@ 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) {
         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 +428,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| {
+            let new_item = new_item.lines()
+                .map(|l| {
                     if first {
                         first = false;
                         format!("{}\n", l)
                     } else {
                         format!("{}{}\n", indent, l)
                     }
-            }).collect::<String>();
+                })
+                .collect::<String>();
 
             self.span_suggestion(span, msg, format!("{}\n{}", new_item, indent));
         }

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| {