From 4a4e1ea2c55b27b84a83fb2951ca6f192c55fc35 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 20 Dec 2016 18:21:30 +0100 Subject: [PATCH 01/11] also run rustfmt on clippy-lints --- .travis.yml | 1 + clippy_lints/src/arithmetic.rs | 4 +- clippy_lints/src/array_indexing.rs | 2 +- clippy_lints/src/assign_ops.rs | 58 ++--- clippy_lints/src/attrs.rs | 19 +- clippy_lints/src/bit_mask.rs | 22 +- clippy_lints/src/block_in_if_condition.rs | 5 +- clippy_lints/src/booleans.rs | 38 +-- clippy_lints/src/collapsible_if.rs | 14 +- clippy_lints/src/consts.rs | 59 ++--- clippy_lints/src/copies.rs | 18 +- clippy_lints/src/cyclomatic_complexity.rs | 8 +- clippy_lints/src/derive.rs | 10 +- clippy_lints/src/doc.rs | 51 ++-- clippy_lints/src/entry.rs | 3 +- clippy_lints/src/enum_glob_use.rs | 2 +- clippy_lints/src/enum_variants.rs | 14 +- clippy_lints/src/eq_op.rs | 14 +- clippy_lints/src/escape.rs | 47 ++-- clippy_lints/src/eta_reduction.rs | 7 +- clippy_lints/src/eval_order_dependence.rs | 53 +++-- clippy_lints/src/format.rs | 7 +- clippy_lints/src/formatting.rs | 2 +- clippy_lints/src/functions.rs | 25 +- clippy_lints/src/identity_op.rs | 6 +- .../src/if_let_redundant_pattern_matching.rs | 31 ++- clippy_lints/src/if_not_else.rs | 4 +- clippy_lints/src/items_after_statements.rs | 7 +- clippy_lints/src/len_zero.rs | 26 +-- clippy_lints/src/let_if_seq.rs | 13 +- clippy_lints/src/lifetimes.rs | 55 ++--- clippy_lints/src/loops.rs | 128 ++++------- clippy_lints/src/map_clone.rs | 6 +- clippy_lints/src/matches.rs | 87 +++---- clippy_lints/src/methods.rs | 172 +++++++------- clippy_lints/src/minmax.rs | 2 +- clippy_lints/src/misc.rs | 56 ++--- clippy_lints/src/misc_early.rs | 19 +- clippy_lints/src/missing_doc.rs | 57 +++-- clippy_lints/src/mut_mut.rs | 10 +- clippy_lints/src/mut_reference.rs | 15 +- clippy_lints/src/needless_bool.rs | 32 +-- clippy_lints/src/needless_borrow.rs | 8 +- clippy_lints/src/new_without_default.rs | 13 +- clippy_lints/src/no_effect.rs | 12 +- clippy_lints/src/non_expressive_names.rs | 2 +- clippy_lints/src/ok_if_let.rs | 2 +- clippy_lints/src/open_options.rs | 35 ++- clippy_lints/src/precedence.rs | 8 +- clippy_lints/src/ptr.rs | 2 +- clippy_lints/src/ranges.rs | 8 +- clippy_lints/src/reference.rs | 14 +- clippy_lints/src/regex.rs | 19 +- clippy_lints/src/returns.rs | 17 +- clippy_lints/src/serde.rs | 3 +- clippy_lints/src/shadow.rs | 65 ++---- clippy_lints/src/strings.rs | 2 +- clippy_lints/src/temporary_assignment.rs | 2 +- clippy_lints/src/transmute.rs | 84 +++---- clippy_lints/src/types.rs | 86 ++++--- clippy_lints/src/unsafe_removed_from_name.rs | 27 +-- clippy_lints/src/unused_label.rs | 15 +- clippy_lints/src/utils/comparisons.rs | 3 +- clippy_lints/src/utils/conf.rs | 33 ++- clippy_lints/src/utils/constants.rs | 14 +- clippy_lints/src/utils/higher.rs | 12 +- clippy_lints/src/utils/hir.rs | 149 ++++++------ clippy_lints/src/utils/inspector.rs | 58 +++-- clippy_lints/src/utils/internal_lints.rs | 9 +- clippy_lints/src/utils/mod.rs | 217 +++++++++--------- clippy_lints/src/utils/sugg.rs | 89 +++---- clippy_lints/src/vec.rs | 4 +- 72 files changed, 1017 insertions(+), 1204 deletions(-) diff --git a/.travis.yml b/.travis.yml index 052a543bfd57..f6810698570f 100644 --- a/.travis.yml +++ b/.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 diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs index 5020295e20c9..109f045b619b 100644 --- a/clippy_lints/src/arithmetic.rs +++ b/clippy_lints/src/arithmetic.rs @@ -67,7 +67,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic { span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected"); self.span = Some(expr.span); } - } + }, hir::ExprUnary(hir::UnOp::UnNeg, ref arg) => { let ty = cx.tcx.tables().expr_ty(arg); if ty.is_integral() { @@ -77,7 +77,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic { span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected"); self.span = Some(expr.span); } - } + }, _ => (), } } diff --git a/clippy_lints/src/array_indexing.rs b/clippy_lints/src/array_indexing.rs index 399f93d08c7c..3387f68d93b6 100644 --- a/clippy_lints/src/array_indexing.rs +++ b/clippy_lints/src/array_indexing.rs @@ -123,7 +123,7 @@ fn to_const_range(start: Option>, end: Option> } else { x } - } + }, Some(_) => return None, None => array_size, }; diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs index 5f5cddc64714..d42880f8b9fd 100644 --- a/clippy_lints/src/assign_ops.rs +++ b/clippy_lints/src/assign_ops.rs @@ -95,13 +95,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { expr.span, "variable appears on both sides of an assignment operation", |db| { - if let (Some(snip_a), Some(snip_r)) = (snippet_opt(cx, assignee.span), - snippet_opt(cx, rhs.span)) { - db.span_suggestion(expr.span, - "replace it with", - format!("{} {}= {}", snip_a, op.node.as_str(), snip_r)); - } - }); + if let (Some(snip_a), Some(snip_r)) = + (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span)) { + db.span_suggestion(expr.span, + "replace it with", + format!("{} {}= {}", snip_a, op.node.as_str(), snip_r)); + } + }); }; // lhs op= l op r if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs, l) { @@ -113,7 +113,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { } } } - } + }, hir::ExprAssign(ref assignee, ref e) => { if let hir::ExprBinary(op, ref l, ref r) = e.node { let lint = |assignee: &hir::Expr, rhs: &hir::Expr| { @@ -176,13 +176,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { expr.span, "manual implementation of an assign operation", |db| { - if let (Some(snip_a), Some(snip_r)) = (snippet_opt(cx, assignee.span), - snippet_opt(cx, rhs.span)) { - db.span_suggestion(expr.span, - "replace it with", - format!("{} {}= {}", snip_a, op.node.as_str(), snip_r)); - } - }); + if let (Some(snip_a), Some(snip_r)) = + (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span)) { + db.span_suggestion(expr.span, + "replace it with", + format!("{} {}= {}", snip_a, op.node.as_str(), snip_r)); + } + }); } }; // a = a op b @@ -195,13 +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, } } diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index a37b08363957..528a62d7f020 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -120,12 +120,16 @@ 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); - }); + sugg.insert(1, '!'); + 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, } } diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs index 0e569bc76f7b..5b860d8cedc7 100644 --- a/clippy_lints/src/bit_mask.rs +++ b/clippy_lints/src/bit_mask.rs @@ -134,7 +134,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else if mask_value == 0 { span_lint(cx, BAD_BIT_MASK, *span, "&-masking with zero"); } - } + }, BiBitOr => { if mask_value | cmp_value != cmp_value { span_lint(cx, @@ -144,10 +144,10 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: mask_value, cmp_value)); } - } + }, _ => (), } - } + }, BiLt | BiGe => { match bit_op { BiBitAnd => { @@ -161,7 +161,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else if mask_value == 0 { span_lint(cx, BAD_BIT_MASK, *span, "&-masking with zero"); } - } + }, BiBitOr => { if mask_value >= cmp_value { span_lint(cx, @@ -173,11 +173,11 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else { check_ineffective_lt(cx, *span, mask_value, cmp_value, "|"); } - } + }, BiBitXor => check_ineffective_lt(cx, *span, mask_value, cmp_value, "^"), _ => (), } - } + }, BiLe | BiGt => { match bit_op { BiBitAnd => { @@ -191,7 +191,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else if mask_value == 0 { span_lint(cx, BAD_BIT_MASK, *span, "&-masking with zero"); } - } + }, BiBitOr => { if mask_value > cmp_value { span_lint(cx, @@ -203,11 +203,11 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else { check_ineffective_gt(cx, *span, mask_value, cmp_value, "|"); } - } + }, BiBitXor => check_ineffective_gt(cx, *span, mask_value, cmp_value, "^"), _ => (), } - } + }, _ => (), } } @@ -244,7 +244,7 @@ fn fetch_int_literal(cx: &LateContext, lit: &Expr) -> Option { } 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 { } else { None } - } + }, _ => None, } } diff --git a/clippy_lints/src/block_in_if_condition.rs b/clippy_lints/src/block_in_if_condition.rs index de004afa1a6c..2f9a6b161585 100644 --- a/clippy_lints/src/block_in_if_condition.rs +++ b/clippy_lints/src/block_in_if_condition.rs @@ -110,7 +110,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition { } } } else { - let mut visitor = ExVisitor { found_block: None, cx: cx }; + let mut visitor = ExVisitor { + found_block: None, + cx: cx, + }; walk_expr(&mut visitor, check); if let Some(block) = visitor.found_block { span_lint(cx, BLOCK_IN_IF_CONDITION_STMT, block.span, COMPLEX_BLOCK_MESSAGE); diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs index bd5657483112..979b62f8ce7e 100644 --- a/clippy_lints/src/booleans.rs +++ b/clippy_lints/src/booleans.rs @@ -94,14 +94,14 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> { BiAnd => return Ok(Bool::And(self.extract(BiAnd, &[lhs, rhs], Vec::new())?)), _ => (), } - } + }, ExprLit(ref lit) => { match lit.node { LitKind::Bool(true) => return Ok(Bool::True), LitKind::Bool(false) => return Ok(Bool::False), _ => (), } - } + }, _ => (), } } @@ -129,7 +129,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> { BiLe => mk_expr(BiGt), _ => continue, } - } + }, _ => continue, }; if SpanlessEq::new(self.cx).ignore_fn().eq_expr(&negated, expr) { @@ -156,17 +156,17 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String { True => { s.push_str("true"); s - } + }, False => { s.push_str("false"); s - } + }, Not(ref inner) => { match **inner { And(_) | Or(_) => { s.push('!'); recurse(true, cx, inner, terminals, s) - } + }, Term(n) => { if let ExprBinary(binop, ref lhs, ref rhs) = terminals[n as usize].node { let op = match binop.node { @@ -179,7 +179,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String { _ => { s.push('!'); return recurse(true, cx, inner, terminals, s); - } + }, }; s.push_str(&snip(lhs)); s.push_str(op); @@ -189,13 +189,13 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String { s.push('!'); recurse(false, cx, inner, terminals, s) } - } + }, _ => { s.push('!'); recurse(false, cx, inner, terminals, s) - } + }, } - } + }, And(ref v) => { if brackets { s.push('('); @@ -217,7 +217,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String { s.push(')'); } s - } + }, Or(ref v) => { if brackets { s.push('('); @@ -231,7 +231,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String { s.push(')'); } s - } + }, Term(n) => { if brackets { if let ExprBinary(..) = terminals[n as usize].node { @@ -245,7 +245,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String { } } s - } + }, } } recurse(false, cx, suggestion, terminals, String::new()) @@ -262,13 +262,13 @@ fn simple_negate(b: Bool) -> Bool { *el = simple_negate(::std::mem::replace(el, True)); } Or(v) - } + }, Or(mut v) => { for el in &mut v { *el = simple_negate(::std::mem::replace(el, True)); } And(v) - } + }, Not(inner) => *inner, } } @@ -290,13 +290,13 @@ fn terminal_stats(b: &Bool) -> Stats { _ => stats.negations += 1, } recurse(inner, stats); - } + }, And(ref v) | Or(ref v) => { stats.ops += v.len() - 1; for inner in v { recurse(inner, stats); } - } + }, Term(n) => stats.terminals[n as usize] += 1, } } @@ -325,7 +325,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> { let mut simplified = expr.simplify(); for simple in Bool::Not(Box::new(expr.clone())).simplify() { match simple { - Bool::Not(_) | Bool::True | Bool::False => {} + Bool::Not(_) | Bool::True | Bool::False => {}, _ => simplified.push(Bool::Not(Box::new(simple.clone()))), } let simple_negated = simple_negate(simple); @@ -399,7 +399,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> { } else { walk_expr(self, e); } - } + }, _ => walk_expr(self, e), } } diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs index 9d23d32c81ae..83b87dc74b0f 100644 --- a/clippy_lints/src/collapsible_if.rs +++ b/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 { diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs index afbf9666b10a..44288e7d7fcd 100644 --- a/clippy_lints/src/consts.rs +++ b/clippy_lints/src/consts.rs @@ -75,18 +75,16 @@ impl PartialEq for Constant { (&Constant::Char(l), &Constant::Char(r)) => l == r, (&Constant::Int(l), &Constant::Int(r)) => { l.is_negative() == r.is_negative() && l.to_u64_unchecked() == r.to_u64_unchecked() - } + }, (&Constant::Float(ref ls, _), &Constant::Float(ref rs, _)) => { // we want `Fw32 == FwAny` and `FwAny == Fw64`, by transitivity we must have // `Fw32 == Fw64` so don’t compare them match (ls.parse::(), rs.parse::()) { // mem::transmute is required to catch non-matching 0.0, -0.0, and NaNs - (Ok(l), Ok(r)) => unsafe { - mem::transmute::(l) == mem::transmute::(r) - }, + (Ok(l), Ok(r)) => unsafe { mem::transmute::(l) == mem::transmute::(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::() { unsafe { mem::transmute::(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::(), rs.parse::()) { - (Ok(ref l), Ok(ref r)) => match (l.partial_cmp(r), l.is_sign_positive() == r.is_sign_positive()) { - // Check for comparison of -0.0 and 0.0 - (Some(Ordering::Equal), false) => None, - (x, _) => x + (Ok(ref l), Ok(ref r)) => { + match (l.partial_cmp(r), l.is_sign_positive() == r.is_sign_positive()) { + // Check for comparison of -0.0 and 0.0 + (Some(Ordering::Equal), false) => None, + (x, _) => x, + } }, _ => None, } - } + }, (&Constant::Bool(ref l), &Constant::Bool(ref r)) => Some(l.cmp(r)), (&Constant::Tuple(ref l), &Constant::Tuple(ref r)) | (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l.partial_cmp(r), @@ -166,7 +166,7 @@ impl PartialOrd for Constant { Some(Equal) => Some(ls.cmp(rs)), x => x, } - } + }, _ => None, //TODO: Are there any useful inter-type orderings? } } @@ -187,14 +187,14 @@ pub fn lit_to_constant(lit: &LitKind) -> Constant { LitKind::Int(value, LitIntType::Unsigned(UintTy::U64)) => Constant::Int(ConstInt::U64(value as u64)), LitKind::Int(value, LitIntType::Unsigned(UintTy::Us)) => { Constant::Int(ConstInt::Usize(ConstUsize::Us32(value as u32))) - } + }, LitKind::Int(value, LitIntType::Signed(IntTy::I8)) => Constant::Int(ConstInt::I8(value as i8)), LitKind::Int(value, LitIntType::Signed(IntTy::I16)) => Constant::Int(ConstInt::I16(value as i16)), LitKind::Int(value, LitIntType::Signed(IntTy::I32)) => Constant::Int(ConstInt::I32(value as i32)), LitKind::Int(value, LitIntType::Signed(IntTy::I64)) => Constant::Int(ConstInt::I64(value as i64)), LitKind::Int(value, LitIntType::Signed(IntTy::Is)) => { Constant::Int(ConstInt::Isize(ConstIsize::Is32(value as i32))) - } + }, LitKind::Float(ref is, ty) => Constant::Float(is.to_string(), ty.into()), LitKind::FloatUnsuffixed(ref is) => Constant::Float(is.to_string(), FloatWidth::Any), LitKind::Bool(b) => Constant::Bool(b), @@ -260,7 +260,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { ExprTup(ref tup) => self.multi(tup).map(Constant::Tuple), ExprRepeat(ref value, ref number) => { self.binop_apply(value, number, |v, n| Some(Constant::Repeat(Box::new(v), n.as_u64() as usize))) - } + }, ExprUnary(op, ref operand) => { self.expr(operand).and_then(|o| { match op { @@ -269,7 +269,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { UnDeref => Some(o), } }) - } + }, ExprBinary(op, ref left, ref right) => self.binop(op, left, right), // TODO: add other expressions _ => None, @@ -280,8 +280,8 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { /// non-constant part fn multi(&mut self, vec: &[Expr]) -> Option> { vec.iter() - .map(|elem| self.expr(elem)) - .collect::>() + .map(|elem| self.expr(elem)) + .collect::>() } /// lookup a possibly constant expression from a ExprPath @@ -289,8 +289,11 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { if let Some(lcx) = self.lcx { let def = lcx.tcx.tables().qpath_def(qpath, id); match def { - Def::Const(def_id) | Def::AssociatedConst(def_id) => { - let substs = Some(lcx.tcx.tables().node_id_item_substs(id) + Def::Const(def_id) | + Def::AssociatedConst(def_id) => { + let substs = Some(lcx.tcx + .tables() + .node_id_item_substs(id) .unwrap_or_else(|| lcx.tcx.intern_substs(&[]))); if let Some((const_expr, _ty)) = lookup_const_by_id(lcx.tcx, def_id, substs) { let ret = self.expr(const_expr); diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs index 9fa38ad02b3e..5ef9f67a3b89 100644 --- a/clippy_lints/src/copies.rs +++ b/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 { 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 { 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(exprs: &[T], hash: Hash, eq: Eq) -> Option<(&T, &T)> return Some((o, expr)); } } - } + }, Entry::Vacant(v) => { v.insert(vec![expr]); - } + }, } } diff --git a/clippy_lints/src/cyclomatic_complexity.rs b/clippy_lints/src/cyclomatic_complexity.rs index fc9e25c7707e..897a578f19a7 100644 --- a/clippy_lints/src/cyclomatic_complexity.rs +++ b/clippy_lints/src/cyclomatic_complexity.rs @@ -136,7 +136,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> { if arms_n > 1 { self.match_arms += arms_n - 2; } - } + }, ExprCall(ref callee, _) => { walk_expr(self, e); let ty = self.cx.tcx.tables().node_id_to_type(callee.id); @@ -144,10 +144,10 @@ impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> { ty::TyFnDef(_, _, ty) | ty::TyFnPtr(ty) if ty.sig.skip_binder().output().sty == ty::TyNever => { self.divergence += 1; - } + }, _ => (), } - } + }, ExprClosure(..) => (), ExprBinary(op, _, _) => { walk_expr(self, e); @@ -155,7 +155,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> { BiAnd | BiOr => self.short_circuits += 1, _ => (), } - } + }, ExprRet(_) => self.returns += 1, _ => walk_expr(self, e), } diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index 449227c97679..463923136ff0 100644 --- a/clippy_lints/src/derive.rs +++ b/clippy_lints/src/derive.rs @@ -87,7 +87,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Derive { /// Implementation of the `DERIVE_HASH_XOR_EQ` lint. fn check_hash_peq<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, span: Span, trait_ref: &TraitRef, ty: ty::Ty<'tcx>, - hash_is_automatically_derived: bool) { + hash_is_automatically_derived: bool) { if_let_chain! {[ match_path_old(&trait_ref.path, &paths::HASH), let Some(peq_trait_def_id) = cx.tcx.lang_items.eq_trait() @@ -149,18 +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; - } + }, _ => (), } } } - } + }, _ => (), } diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs index 4183632543b7..76e8f8670402 100644 --- a/clippy_lints/src/doc.rs +++ b/clippy_lints/src/doc.rs @@ -64,26 +64,21 @@ pub fn strip_doc_comment_decoration((comment, span): (String, Span)) -> Vec<(Str const ONELINERS: &'static [&'static str] = &["///!", "///", "//!", "//"]; for prefix in ONELINERS { if comment.starts_with(*prefix) { - return vec![( - comment[prefix.len()..].to_owned(), - Span { lo: span.lo + BytePos(prefix.len() as u32), ..span } - )]; + return vec![(comment[prefix.len()..].to_owned(), + Span { lo: span.lo + BytePos(prefix.len() as u32), ..span })]; } } if comment.starts_with("/*") { - return comment[3..comment.len() - 2].lines().map(|line| { - let offset = line.as_ptr() as usize - comment.as_ptr() as usize; - debug_assert_eq!(offset as u32 as usize, offset); + return comment[3..comment.len() - 2] + .lines() + .map(|line| { + let offset = line.as_ptr() as usize - comment.as_ptr() as usize; + debug_assert_eq!(offset as u32 as usize, offset); - ( - line.to_owned(), - Span { - lo: span.lo + BytePos(offset as u32), - ..span - } - ) - }).collect(); + (line.to_owned(), Span { lo: span.lo + BytePos(offset as u32), ..span }) + }) + .collect(); } panic!("not a doc-comment: {}", comment); @@ -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 } diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs index 00a41c2e986c..657018a0ab97 100644 --- a/clippy_lints/src/entry.rs +++ b/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, diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs index 4dafcf365a6c..0bd1740c5459 100644 --- a/clippy_lints/src/enum_glob_use.rs +++ b/clippy_lints/src/enum_glob_use.rs @@ -49,7 +49,7 @@ impl EnumGlobUse { if let ItemUse(ref path, UseKind::Glob) = item.node { // FIXME: ask jseyfried why the qpath.def for `use std::cmp::Ordering::*;` // extracted through `ItemUse(ref qpath, UseKind::Glob)` is a `Mod` and not an `Enum` - //if let Def::Enum(_) = path.def { + // if let Def::Enum(_) = path.def { if path.segments.last().and_then(|seg| seg.name.as_str().chars().next()).map_or(false, char::is_uppercase) { span_lint(cx, ENUM_GLOB_USE, item.span, "don't use glob imports for enum variants"); } diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs index 74611d491c7f..ab47b7cffe23 100644 --- a/clippy_lints/src/enum_variants.rs +++ b/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 { diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs index c43dfe6e27ca..bfc16a504570 100644 --- a/clippy_lints/src/eq_op.rs +++ b/clippy_lints/src/eq_op.rs @@ -48,19 +48,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp { fn is_valid_operator(op: &BinOp) -> bool { match op.node { - BiSub | - BiDiv | - BiEq | - BiLt | - BiLe | - BiGt | - BiGe | - BiNe | - BiAnd | - BiOr | - BiBitXor | - BiBitAnd | - BiBitOr => true, + BiSub | BiDiv | BiEq | BiLt | BiLe | BiGt | BiGe | BiNe | BiAnd | BiOr | BiBitXor | BiBitAnd | BiBitOr => true, _ => false, } } diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index 0ca1f143b164..17ff2613ddae 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -46,7 +46,7 @@ fn is_non_trait_box(ty: ty::Ty) -> bool { } } -struct EscapeDelegate<'a, 'tcx: 'a+'gcx, 'gcx: 'a> { +struct EscapeDelegate<'a, 'tcx: 'a + 'gcx, 'gcx: 'a> { tcx: ty::TyCtxt<'a, 'tcx, 'tcx>, set: NodeSet, infcx: &'a InferCtxt<'a, 'gcx, 'gcx>, @@ -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); @@ -98,7 +91,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } } -impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'gcx> { +impl<'a, 'tcx: 'a + 'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'gcx> { fn consume(&mut self, _: NodeId, _: Span, cmt: cmt<'tcx>, mode: ConsumeMode) { if let Categorization::Local(lid) = cmt.cat { if self.set.contains(&lid) { @@ -157,12 +150,13 @@ 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 - .tables - .borrow() - .adjustments - .get(&borrow_id) - .map(|a| &a.kind) { + if let Some(&Adjust::DerefRef { autoderefs, .. }) = + self.tcx + .tables + .borrow() + .adjustments + .get(&borrow_id) + .map(|a| &a.kind) { if LoanCause::AutoRef == loan_cause { // x.foo() if autoderefs == 0 { @@ -173,14 +167,15 @@ impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'g } } else if LoanCause::AddrOf == loan_cause { // &x - if let Some(&Adjust::DerefRef { autoderefs, .. }) = self.tcx - .tables - .borrow() - .adjustments - .get(&self.tcx - .map - .get_parent_node(borrow_id)) - .map(|a| &a.kind) { + if let Some(&Adjust::DerefRef { autoderefs, .. }) = + self.tcx + .tables + .borrow() + .adjustments + .get(&self.tcx + .map + .get_parent_node(borrow_id)) + .map(|a| &a.kind) { if autoderefs <= 1 { // foo(&x) where no extra autoreffing is happening self.set.remove(&lid); @@ -198,7 +193,7 @@ impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, 'g fn mutate(&mut self, _: NodeId, _: Span, _: cmt<'tcx>, _: MutateMode) {} } -impl<'a, 'tcx: 'a+'gcx, 'gcx: 'a> EscapeDelegate<'a, 'tcx, 'gcx> { +impl<'a, 'tcx: 'a + 'gcx, 'gcx: 'a> EscapeDelegate<'a, 'tcx, 'gcx> { fn is_large_box(&self, ty: ty::Ty<'gcx>) -> bool { // Large types need to be boxed to avoid stack // overflows. diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs index 2bf91f8d1bce..f25014b6805e 100644 --- a/clippy_lints/src/eta_reduction.rs +++ b/clippy_lints/src/eta_reduction.rs @@ -41,7 +41,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EtaPass { for arg in args { check_closure(cx, arg) } - } + }, _ => (), } } @@ -65,11 +65,10 @@ fn check_closure(cx: &LateContext, expr: &Expr) { // Is it an unsafe function? They don't implement the closure traits ty::TyFnDef(_, _, fn_ty) | ty::TyFnPtr(fn_ty) => { - if fn_ty.unsafety == Unsafety::Unsafe || - fn_ty.sig.skip_binder().output().sty == ty::TyNever { + if fn_ty.unsafety == Unsafety::Unsafe || fn_ty.sig.skip_binder().output().sty == ty::TyNever { return; } - } + }, _ => (), } for (a1, a2) in decl.inputs.iter().zip(args) { diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs index 88e1180067a7..d975a88f7ab3 100644 --- a/clippy_lints/src/eval_order_dependence.rs +++ b/clippy_lints/src/eval_order_dependence.rs @@ -60,7 +60,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { // Find a write to a local variable. match expr.node { - ExprAssign(ref lhs, _) | ExprAssignOp(_, ref lhs, _) => { + ExprAssign(ref lhs, _) | + ExprAssignOp(_, ref lhs, _) => { if let ExprPath(ref qpath) = lhs.node { if let QPath::Resolved(_, ref path) = *qpath { if path.segments.len() == 1 { @@ -75,13 +76,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence { } } } - } - _ => {} + }, + _ => {}, } } fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { match stmt.node { - StmtExpr(ref e, _) | StmtSemi(ref e, _) => DivergenceVisitor { cx: cx }.maybe_walk_expr(e), + StmtExpr(ref e, _) | + StmtSemi(ref e, _) => DivergenceVisitor { cx: cx }.maybe_walk_expr(e), StmtDecl(ref d, _) => { if let DeclLocal(ref local) = d.node { if let Local { init: Some(ref e), .. } = **local { @@ -110,32 +112,29 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> { // make sure top level arm expressions aren't linted self.maybe_walk_expr(&*arm.body); } - } + }, _ => walk_expr(self, e), } } fn report_diverging_sub_expr(&mut self, e: &Expr) { - span_lint( - self.cx, - DIVERGING_SUB_EXPRESSION, - e.span, - "sub-expression diverges", - ); + span_lint(self.cx, DIVERGING_SUB_EXPRESSION, e.span, "sub-expression diverges"); } } impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> { fn visit_expr(&mut self, e: &'tcx Expr) { match e.node { - ExprAgain(_) | - ExprBreak(_, _) | - ExprRet(_) => self.report_diverging_sub_expr(e), - ExprCall(ref func, _) => match self.cx.tcx.tables().expr_ty(func).sty { - ty::TyFnDef(_, _, fn_ty) | - ty::TyFnPtr(fn_ty) => if let ty::TyNever = self.cx.tcx.erase_late_bound_regions(&fn_ty.sig).output().sty { - self.report_diverging_sub_expr(e); - }, - _ => {}, + ExprAgain(_) | ExprBreak(_, _) | ExprRet(_) => self.report_diverging_sub_expr(e), + ExprCall(ref func, _) => { + match self.cx.tcx.tables().expr_ty(func).sty { + ty::TyFnDef(_, _, fn_ty) | + ty::TyFnPtr(fn_ty) => { + if let ty::TyNever = self.cx.tcx.erase_late_bound_regions(&fn_ty.sig).output().sty { + self.report_diverging_sub_expr(e); + } + }, + _ => {}, + } }, ExprMethodCall(..) => { let method_call = ty::MethodCall::expr(e.id); @@ -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, @@ -214,7 +213,7 @@ enum StopEarly { Stop, } -fn check_expr<'a, 'tcx>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> StopEarly { +fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> StopEarly { if expr.id == vis.last_expr.id { return StopEarly::KeepGoing; } @@ -229,7 +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)) - } + }, } } diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs index 0cf4762364ba..1894a12a6d3e 100644 --- a/clippy_lints/src/format.rs +++ b/clippy_lints/src/format.rs @@ -55,7 +55,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { ], { span_lint(cx, USELESS_FORMAT, span, "useless use of `format!`"); }} - } + }, // `format!("foo")` expansion contains `match () { () => [], }` ExprMatch(ref matchee, _, _) => { if let ExprTup(ref tup) = matchee.node { @@ -63,7 +63,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { span_lint(cx, USELESS_FORMAT, span, "useless use of `format!`"); } } - } + }, _ => (), } } @@ -72,8 +72,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { /// Returns the slice of format string parts in an `Arguments::new_v1` call. /// Public because it's shared with a lint in print.rs. -pub fn get_argument_fmtstr_parts<'a, 'b>(cx: &LateContext<'a, 'b>, expr: &'a Expr) - -> Option> { +pub fn get_argument_fmtstr_parts<'a, 'b>(cx: &LateContext<'a, 'b>, expr: &'a Expr) -> Option> { if_let_chain! {[ let ExprBlock(ref block) = expr.node, block.stmts.len() == 1, diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs index e9af1a011d98..6fdedaeed43b 100644 --- a/clippy_lints/src/formatting.rs +++ b/clippy_lints/src/formatting.rs @@ -62,7 +62,7 @@ impl EarlyLintPass for Formatting { (&ast::StmtKind::Expr(ref first), &ast::StmtKind::Expr(ref second)) | (&ast::StmtKind::Expr(ref first), &ast::StmtKind::Semi(ref second)) => { check_consecutive_ifs(cx, first, second); - } + }, _ => (), } } diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index 52461d08ee8d..801532a1c3b2 100644 --- a/clippy_lints/src/functions.rs +++ b/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::>(); @@ -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), _ => (), } diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs index 547aa23f0de8..a10a9523ac1b 100644 --- a/clippy_lints/src/identity_op.rs +++ b/clippy_lints/src/identity_op.rs @@ -41,17 +41,17 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityOp { BiAdd | BiBitOr | BiBitXor => { check(cx, left, 0, e.span, right.span); check(cx, right, 0, e.span, left.span); - } + }, BiShl | BiShr | BiSub => check(cx, right, 0, e.span, left.span), BiMul => { check(cx, left, 1, e.span, right.span); check(cx, right, 1, e.span, left.span); - } + }, BiDiv => check(cx, right, 1, e.span, left.span), BiBitAnd => { check(cx, left, -1, e.span, right.span); check(cx, right, -1, e.span, left.span); - } + }, _ => (), } } diff --git a/clippy_lints/src/if_let_redundant_pattern_matching.rs b/clippy_lints/src/if_let_redundant_pattern_matching.rs index 399b58956bd6..921cd7f8885e 100644 --- a/clippy_lints/src/if_let_redundant_pattern_matching.rs +++ b/clippy_lints/src/if_let_redundant_pattern_matching.rs @@ -45,13 +45,12 @@ impl LintPass for Pass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { - if let ExprMatch(ref op, ref arms, MatchSource::IfLetDesugar{..}) = expr.node { + if let ExprMatch(ref op, ref arms, MatchSource::IfLetDesugar { .. }) = expr.node { if arms[0].pats.len() == 1 { let good_method = match arms[0].pats[0].node { - PatKind::TupleStruct(ref path, ref pats, _) if pats.len() == 1 && pats[0].node == PatKind::Wild => { - + PatKind::TupleStruct(ref path, ref pats, _) if pats.len() == 1 && pats[0].node == PatKind::Wild => { if match_path(path, &paths::RESULT_OK) { "is_ok()" } else if match_path(path, &paths::RESULT_ERR) { @@ -59,15 +58,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } else if match_path(path, &paths::OPTION_SOME) { "is_some()" } else { - return + return; } - } + }, - PatKind::Path(ref path) if match_path(path, &paths::OPTION_NONE) => { - "is_none()" - } + PatKind::Path(ref path) if match_path(path, &paths::OPTION_NONE) => "is_none()", - _ => return + _ => return, }; span_lint_and_then(cx, @@ -75,15 +72,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { arms[0].pats[0].span, &format!("redundant pattern matching, consider using `{}`", good_method), |db| { - let span = Span { - lo: expr.span.lo, - hi: op.span.hi, - expn_id: expr.span.expn_id, - }; - db.span_suggestion(span, - "try this", - format!("if {}.{}", snippet(cx, op.span, "_"), good_method)); - }); + let span = Span { + lo: expr.span.lo, + hi: op.span.hi, + expn_id: expr.span.expn_id, + }; + db.span_suggestion(span, "try this", format!("if {}.{}", snippet(cx, op.span, "_"), good_method)); + }); } } diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs index 273c1bd0eb0a..72a3d485bd08 100644 --- a/clippy_lints/src/if_not_else.rs +++ b/clippy_lints/src/if_not_else.rs @@ -55,14 +55,14 @@ impl EarlyLintPass for IfNotElse { item.span, "Unnecessary boolean `not` operation", "remove the `!` and swap the blocks of the if/else"); - } + }, ExprKind::Binary(ref kind, _, _) if kind.node == BinOpKind::Ne => { span_help_and_lint(cx, IF_NOT_ELSE, item.span, "Unnecessary `!=` operation", "change to `==` and swap the blocks of the if/else"); - } + }, _ => (), } } diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs index 78b43974364d..3b3cd423729b 100644 --- a/clippy_lints/src/items_after_statements.rs +++ b/clippy_lints/src/items_after_statements.rs @@ -47,9 +47,10 @@ impl EarlyLintPass for ItemsAfterStatements { } // skip initial items - let stmts = item.stmts.iter() - .map(|stmt| &stmt.node) - .skip_while(|s| matches!(**s, StmtKind::Item(..))); + let stmts = item.stmts + .iter() + .map(|stmt| &stmt.node) + .skip_while(|s| matches!(**s, StmtKind::Item(..))); // lint on all further items for stmt in stmts { diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs index 0242fb523ee5..22835b488403 100644 --- a/clippy_lints/src/len_zero.rs +++ b/clippy_lints/src/len_zero.rs @@ -107,8 +107,7 @@ fn check_trait_items(cx: &LateContext, item: &Item, trait_items: &[TraitItem]) { span_lint(cx, LEN_WITHOUT_IS_EMPTY, i.span, - &format!("trait `{}` has a `len` method but no `is_empty` method", - item.name)); + &format!("trait `{}` has a `len` method but no `is_empty` method", item.name)); } } } @@ -118,7 +117,8 @@ fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItemRef]) { fn is_named_self(cx: &LateContext, item: &ImplItemRef, name: &str) -> bool { &*item.name.as_str() == name && if let AssociatedItemKind::Method { has_self } = item.kind { - has_self && { + has_self && + { let did = cx.tcx.map.local_def_id(item.id.node_id); let impl_ty = cx.tcx.item_type(did); impl_ty.fn_args().skip_binder().len() == 1 @@ -146,9 +146,7 @@ fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItemRef]) { span_lint(cx, LEN_WITHOUT_IS_EMPTY, i.span, - &format!("item `{}` has a public `len` method but {} `is_empty` method", - ty, - is_empty)); + &format!("item `{}` has a public `len` method but {} `is_empty` method", ty, is_empty)); } } } @@ -164,7 +162,7 @@ fn check_cmp(cx: &LateContext, span: Span, left: &Expr, right: &Expr, op: &str) (&ExprLit(ref lit), &ExprMethodCall(ref method, _, ref args)) | (&ExprMethodCall(ref method, _, ref args), &ExprLit(ref lit)) => { check_len_zero(cx, span, &method.node, args, lit, op) - } + }, _ => (), } } @@ -199,20 +197,18 @@ fn has_is_empty(cx: &LateContext, expr: &Expr) -> bool { /// Check the inherent impl's items for an `is_empty(self)` method. fn has_is_empty_impl(cx: &LateContext, id: DefId) -> bool { - cx.tcx.inherent_impls.borrow().get(&id).map_or(false, |impls| impls.iter().any(|imp| { - cx.tcx.associated_items(*imp).any(|item| { - is_is_empty(cx, &item) - }) - })) + cx.tcx.inherent_impls.borrow().get(&id).map_or(false, |impls| { + impls.iter().any(|imp| cx.tcx.associated_items(*imp).any(|item| is_is_empty(cx, &item))) + }) } let ty = &walk_ptrs_ty(cx.tcx.tables().expr_ty(expr)); match ty.sty { ty::TyDynamic(..) => { cx.tcx - .associated_items(ty.ty_to_def_id().expect("trait impl not found")) - .any(|item| is_is_empty(cx, &item)) - } + .associated_items(ty.ty_to_def_id().expect("trait impl not found")) + .any(|item| is_is_empty(cx, &item)) + }, ty::TyProjection(_) => ty.ty_to_def_id().map_or(false, |id| has_is_empty_impl(cx, id)), ty::TyAdt(id, _) => has_is_empty_impl(cx, id.did), ty::TyArray(..) | ty::TyStr => true, diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs index 474a86cdb788..786420bbe659 100644 --- a/clippy_lints/src/let_if_seq.rs +++ b/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, diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index 60132ad9161c..081345a09e69 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -87,30 +87,25 @@ enum RefLt { fn bound_lifetimes(bound: &TyParamBound) -> HirVec<&Lifetime> { if let TraitTyParamBound(ref trait_ref, _) = *bound { trait_ref.trait_ref - .path - .segments - .last() - .expect("a path must have at least one segment") - .parameters - .lifetimes() + .path + .segments + .last() + .expect("a path must have at least one segment") + .parameters + .lifetimes() } else { HirVec::new() } } -fn check_fn_inner<'a, 'tcx>( - cx: &LateContext<'a, 'tcx>, - decl: &'tcx FnDecl, - generics: &'tcx Generics, - span: Span, -) { +fn check_fn_inner<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl, generics: &'tcx Generics, span: Span) { if in_external_macro(cx, span) || has_where_lifetimes(cx, &generics.where_clause) { return; } let bounds_lts = generics.ty_params - .iter() - .flat_map(|typ| typ.bounds.iter().flat_map(bound_lifetimes)); + .iter() + .flat_map(|typ| typ.bounds.iter().flat_map(bound_lifetimes)); if could_use_elision(cx, decl, &generics.lifetimes, bounds_lts) { span_lint(cx, @@ -121,16 +116,10 @@ fn check_fn_inner<'a, 'tcx>( report_extra_lifetimes(cx, decl, generics); } -fn could_use_elision< - 'a, - 'tcx: 'a, - T: Iterator ->( - cx: &LateContext<'a, 'tcx>, - func: &'tcx FnDecl, - named_lts: &'tcx [LifetimeDef], - bounds_lts: T, -) -> bool { +fn could_use_elision<'a, 'tcx: 'a, T: Iterator>(cx: &LateContext<'a, 'tcx>, + func: &'tcx FnDecl, + 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 @@ -362,9 +351,9 @@ impl<'tcx> Visitor<'tcx> for LifetimeChecker { fn report_extra_lifetimes<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, func: &'tcx FnDecl, generics: &'tcx Generics) { let hs = generics.lifetimes - .iter() - .map(|lt| (lt.lifetime.name, lt.lifetime.span)) - .collect(); + .iter() + .map(|lt| (lt.lifetime.name, lt.lifetime.span)) + .collect(); let mut checker = LifetimeChecker { map: hs }; walk_generics(&mut checker, generics); diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 77f2df03a6a4..8fd694a1f630 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -14,9 +14,9 @@ use std::collections::HashMap; use syntax::ast; use utils::sugg; -use utils::{snippet, span_lint, get_parent_expr, match_trait_method, match_type, multispan_sugg, - in_external_macro, is_refutable, span_help_and_lint, is_integer_literal, - get_enclosing_block, span_lint_and_then, higher, walk_ptrs_ty, last_path_segment}; +use utils::{snippet, span_lint, get_parent_expr, match_trait_method, match_type, multispan_sugg, in_external_macro, + is_refutable, span_help_and_lint, is_integer_literal, get_enclosing_block, span_lint_and_then, higher, + walk_ptrs_ty, last_path_segment}; use utils::paths; /// **What it does:** Checks for looping over the range of `0..len` of some @@ -334,8 +334,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { match *source { MatchSource::Normal | MatchSource::IfLetDesugar { .. } => { - if arms.len() == 2 && - arms[0].pats.len() == 1 && arms[0].guard.is_none() && + if arms.len() == 2 && arms[0].pats.len() == 1 && arms[0].guard.is_none() && arms[1].pats.len() == 1 && arms[1].guard.is_none() && is_break_expr(&arms[1].body) { if in_external_macro(cx, expr.span) { @@ -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, "_"); @@ -382,10 +379,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { expr.span, "this loop could be written as a `for` loop", |db| { - db.span_suggestion(expr.span, - "try", - format!("for {} in {} {{ .. }}", loop_var, iterator)); - }); + db.span_suggestion(expr.span, + "try", + format!("for {} in {} {{ .. }}", loop_var, iterator)); + }); } } } @@ -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 { @@ -444,9 +431,9 @@ fn check_for_loop_range<'a, 'tcx>( // linting condition: we only indexed one variable if visitor.indexed.len() == 1 { let (indexed, indexed_extent) = visitor.indexed - .into_iter() - .next() - .unwrap_or_else(|| unreachable!() /* len == 1 */); + .into_iter() + .next() + .unwrap_or_else(|| unreachable!() /* len == 1 */); // ensure that the indexed variable was declared before the loop, see #601 if let Some(indexed_extent) = indexed_extent { @@ -472,10 +459,8 @@ fn check_for_loop_range<'a, 'tcx>( ast::RangeLimits::Closed => { let end = sugg::Sugg::hir(cx, end, ""); format!(".take({})", end + sugg::ONE) - } - ast::RangeLimits::HalfOpen => { - format!(".take({})", snippet(cx, end.span, "..")) - } + }, + ast::RangeLimits::HalfOpen => format!(".take({})", snippet(cx, end.span, "..")), } } } else { @@ -488,11 +473,11 @@ fn check_for_loop_range<'a, 'tcx>( expr.span, &format!("the loop variable `{}` is used to index `{}`", ident.node, indexed), |db| { - multispan_sugg(db, "consider using an iterator".to_string(), &[ + multispan_sugg(db, "consider using an iterator".to_string(), &[ (pat.span, &format!("({}, )", ident.node)), (arg.span, &format!("{}.iter().enumerate(){}{}", indexed, take, skip)), ]); - }); + }); } else { let repl = if starts_at_zero && take.is_empty() { format!("&{}", indexed) @@ -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), }; @@ -562,15 +547,14 @@ fn check_for_loop_reverse_range(cx: &LateContext, arg: &Expr, expr: &Expr) { expr.span, "this range is empty so this for loop will never run", |db| { - db.span_suggestion(arg.span, - "consider using the following if \ - you are attempting to iterate \ - over this range in reverse", - format!("({end}{dots}{start}).rev()", + db.span_suggestion(arg.span, + "consider using the following if you are attempting to iterate over this \ + range in reverse", + format!("({end}{dots}{start}).rev()", end=end_snippet, dots=dots, start=start_snippet)); - }); + }); } else if eq && limits != ast::RangeLimits::Closed { // if they are equal, it's also problematic - this loop // will never run. @@ -608,11 +592,11 @@ fn check_for_loop_arg(cx: &LateContext, pat: &Pat, arg: &Expr, expr: &Expr) { method_name)); } } else if &*method_name.as_str() == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) { - let object = snippet(cx, args[0].span, "_"); - span_lint(cx, - EXPLICIT_INTO_ITER_LOOP, - expr.span, - &format!("it is more idiomatic to loop over `{}` instead of `{}.{}()`", + let object = snippet(cx, args[0].span, "_"); + span_lint(cx, + EXPLICIT_INTO_ITER_LOOP, + expr.span, + &format!("it is more idiomatic to loop over `{}` instead of `{}.{}()`", object, object, method_name)); @@ -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, _ => (), } diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs index 4539c3c8c105..f04a4b32de2b 100644 --- a/clippy_lints/src/map_clone.rs +++ b/clippy_lints/src/map_clone.rs @@ -63,7 +63,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } } }} - } + }, ExprPath(ref path) => { if match_path(path, &paths::CLONE) { let type_name = get_type_name(cx, expr, &args[0]).unwrap_or("_"); @@ -75,7 +75,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { type_name), &format!("try\n{}.cloned()", snippet(cx, args[0].span, ".."))); } - } + }, _ => (), } } @@ -91,7 +91,7 @@ fn expr_eq_name(expr: &Expr, id: ast::Name) -> bool { parameters: PathParameters::none(), }]; !path.global && path.segments[..] == arg_segment - } + }, _ => false, } } diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index 1d59afd9eace..e1216c8493ba 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -125,7 +125,11 @@ pub struct MatchPass; impl LintPass for MatchPass { fn get_lints(&self) -> LintArray { - lint_array!(SINGLE_MATCH, MATCH_REF_PATS, MATCH_BOOL, SINGLE_MATCH_ELSE, MATCH_OVERLAPPING_ARM) + lint_array!(SINGLE_MATCH, + MATCH_REF_PATS, + MATCH_BOOL, + SINGLE_MATCH_ELSE, + MATCH_OVERLAPPING_ARM) } } @@ -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, }; @@ -291,7 +293,7 @@ fn check_match_bool(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr) { } } - }); + }); } } @@ -320,10 +322,10 @@ fn check_match_ref_pats(cx: &LateContext, ex: &Expr, arms: &[Arm], source: Match expr.span, "you don't need to add `&` to both the expression and the patterns", |db| { - let inner = Sugg::hir(cx, inner, ".."); - let template = match_template(expr.span, source, inner); - db.span_suggestion(expr.span, "try", template); - }); + let inner = Sugg::hir(cx, inner, ".."); + let template = match_template(expr.span, source, inner); + db.span_suggestion(expr.span, "try", template); + }); } else { span_lint_and_then(cx, MATCH_REF_PATS, @@ -346,11 +348,12 @@ fn all_ranges(cx: &LateContext, arms: &[Arm]) -> Vec> { arms.iter() .flat_map(|arm| { if let Arm { ref pats, guard: None, .. } = *arm { - pats.iter() - } else { - [].iter() - }.filter_map(|pat| { - if_let_chain! {[ + pats.iter() + } else { + [].iter() + } + .filter_map(|pat| { + if_let_chain! {[ let PatKind::Range(ref lhs, ref rhs) = pat.node, let Ok(lhs) = eval_const_expr_partial(cx.tcx, lhs, ExprTypeChecked, None), let Ok(rhs) = eval_const_expr_partial(cx.tcx, rhs, ExprTypeChecked, None) @@ -358,15 +361,15 @@ fn all_ranges(cx: &LateContext, arms: &[Arm]) -> Vec> { return Some(SpannedRange { span: pat.span, node: (lhs, rhs) }); }} - if_let_chain! {[ + if_let_chain! {[ let PatKind::Lit(ref value) = pat.node, let Ok(value) = eval_const_expr_partial(cx.tcx, value, ExprTypeChecked, None) ], { return Some(SpannedRange { span: pat.span, node: (value.clone(), value) }); }} - None - }) + None + }) }) .collect() } @@ -383,17 +386,17 @@ type TypedRanges = Vec>; /// `Uint` and `Int` probably don't make sense. fn type_ranges(ranges: &[SpannedRange]) -> TypedRanges { ranges.iter() - .filter_map(|range| { - if let (ConstVal::Integral(start), ConstVal::Integral(end)) = range.node { - Some(SpannedRange { - span: range.span, - node: (start, end), - }) - } else { - None - } - }) - .collect() + .filter_map(|range| { + if let (ConstVal::Integral(start), ConstVal::Integral(end)) = range.node { + Some(SpannedRange { + span: range.span, + node: (start, end), + }) + } else { + None + } + }) + .collect() } fn is_unit_expr(expr: &Expr) -> bool { @@ -406,15 +409,15 @@ fn is_unit_expr(expr: &Expr) -> bool { fn has_only_ref_pats(arms: &[Arm]) -> bool { let mapped = arms.iter() - .flat_map(|a| &a.pats) - .map(|p| { - match p.node { - PatKind::Ref(..) => Some(true), // &-patterns - PatKind::Wild => Some(false), // an "anything" wildcard is also fine - _ => None, // any other pattern is not fine - } - }) - .collect::>>(); + .flat_map(|a| &a.pats) + .map(|p| { + match p.node { + PatKind::Ref(..) => Some(true), // &-patterns + PatKind::Wild => Some(false), // an "anything" wildcard is also fine + _ => None, // any other pattern is not fine + } + }) + .collect::>>(); // look for Some(v) where there's at least one true element mapped.map_or(false, |v| v.iter().any(|el| *el)) } @@ -481,7 +484,7 @@ pub fn overlapping(ranges: &[SpannedRange]) -> Option<(&SpannedRange, & if ra.node != rb.node { return Some((ra, rb)); } - } + }, (&Kind::End(a, _), &Kind::Start(b, _)) if a != b => (), _ => return Some((a.range(), b.range())), } diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index cb8fd62961d8..d6f33cb1c855 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -9,10 +9,10 @@ use rustc_const_eval::eval_const_expr_partial; use std::borrow::Cow; use std::fmt; use syntax::codemap::Span; -use utils::{get_trait_def_id, implements_trait, in_external_macro, in_macro, is_copy, match_path, - match_trait_method, match_type, method_chain_args, return_ty, same_tys, snippet, - span_lint, span_lint_and_then, span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth, - last_path_segment, single_segment_path, match_def_path}; +use utils::{get_trait_def_id, implements_trait, in_external_macro, in_macro, is_copy, match_path, match_trait_method, + match_type, method_chain_args, return_ty, same_tys, snippet, span_lint, span_lint_and_then, + span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth, last_path_segment, single_segment_path, + match_def_path}; use utils::paths; use utils::sugg; @@ -616,15 +616,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { lint_single_char_pattern(cx, expr, &args[pos]); } } - } + }, _ => (), } - } + }, hir::ExprBinary(op, ref lhs, ref rhs) if op.node == hir::BiEq || op.node == hir::BiNe => { if !lint_chars_next(cx, expr, lhs, rhs, op.node == hir::BiEq) { lint_chars_next(cx, expr, rhs, lhs, op.node == hir::BiEq); } - } + }, _ => (), } } @@ -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; @@ -716,13 +717,15 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir: if implements_trait(cx, arg_ty, default_trait_id, Vec::new()) { span_lint_and_then(cx, - OR_FUN_CALL, - span, - &format!("use of `{}` followed by a call to `{}`", name, path), - |db| { - db.span_suggestion(span, "try this", - format!("{}.unwrap_or_default()", snippet(cx, self_expr.span, "_"))); - }); + OR_FUN_CALL, + span, + &format!("use of `{}` followed by a call to `{}`", name, path), + |db| { + db.span_suggestion(span, + "try this", + format!("{}.unwrap_or_default()", + snippet(cx, self_expr.span, "_"))); + }); return true; } } @@ -733,8 +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,18 +746,16 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir: } } // (path, fn_has_argument, methods, suffix) - let know_types: &[(&[_], _, &[_], _)] = &[(&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"), - (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"), - (&paths::OPTION, - false, - &["map_or", "ok_or", "or", "unwrap_or"], - "else"), - (&paths::RESULT, true, &["or", "unwrap_or"], "else")]; + let know_types: &[(&[_], _, &[_], _)] = + &[(&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"), + (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"), + (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"), + (&paths::RESULT, true, &["or", "unwrap_or"], "else")]; let self_ty = cx.tcx.tables().expr_ty(self_expr); let (fn_has_arguments, poss, suffix) = if let Some(&(_, fn_has_arguments, poss, suffix)) = - know_types.iter().find(|&&i| match_type(cx, self_ty, i.0)) { + know_types.iter().find(|&&i| match_type(cx, self_ty, i.0)) { (fn_has_arguments, poss, suffix) } else { return; @@ -770,7 +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,18 +856,14 @@ fn lint_string_extend(cx: &LateContext, expr: &hir::Expr, args: &[hir::Expr]) { return; }; - span_lint_and_then( - cx, - STRING_EXTEND_CHARS, - expr.span, - "calling `.extend(_.chars())`", - |db| { - db.span_suggestion(expr.span, "try this", - format!("{}.push_str({}{})", - snippet(cx, args[0].span, "_"), - ref_str, - snippet(cx, target.span, "_"))); - }); + span_lint_and_then(cx, STRING_EXTEND_CHARS, expr.span, "calling `.extend(_.chars())`", |db| { + db.span_suggestion(expr.span, + "try this", + format!("{}.push_str({}{})", + snippet(cx, args[0].span, "_"), + ref_str, + snippet(cx, target.span, "_"))); + }); } } @@ -888,28 +893,24 @@ fn lint_cstring_as_ptr(cx: &LateContext, expr: &hir::Expr, new: &hir::Expr, unwr }} } -fn lint_iter_nth(cx: &LateContext, expr: &hir::Expr, iter_args: &[hir::Expr], is_mut: bool){ - let mut_str = if is_mut { "_mut" } else {""}; +fn lint_iter_nth(cx: &LateContext, expr: &hir::Expr, iter_args: &[hir::Expr], is_mut: bool) { + let mut_str = if is_mut { "_mut" } else { "" }; let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.tcx.tables().expr_ty(&iter_args[0])).is_some() { "slice" - } - else if match_type(cx, cx.tcx.tables().expr_ty(&iter_args[0]), &paths::VEC) { + } else if match_type(cx, cx.tcx.tables().expr_ty(&iter_args[0]), &paths::VEC) { "Vec" - } - else if match_type(cx, cx.tcx.tables().expr_ty(&iter_args[0]), &paths::VEC_DEQUE) { + } else if match_type(cx, cx.tcx.tables().expr_ty(&iter_args[0]), &paths::VEC_DEQUE) { "VecDeque" - } - else { + } else { return; // caller is not a type that we want to lint }; - span_lint( - cx, - ITER_NTH, - expr.span, - &format!("called `.iter{0}().nth()` on a {1}. Calling `.get{0}()` is both faster and more readable", - mut_str, caller_type) - ); + span_lint(cx, + ITER_NTH, + expr.span, + &format!("called `.iter{0}().nth()` on a {1}. Calling `.get{0}()` is both faster and more readable", + mut_str, + caller_type)); } fn lint_get_unwrap(cx: &LateContext, expr: &hir::Expr, get_args: &[hir::Expr], is_mut: bool) { @@ -932,32 +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, - GET_UNWRAP, - expr.span, - &format!("called `.get{0}().unwrap()` on a {1}. Using `[]` is more clear and more concise", - mut_str, caller_type), - |db| { - db.span_suggestion( - expr.span, - "try this", - format!("{}{}[{}]", borrow_str, snippet(cx, get_args[0].span, "_"), - snippet(cx, get_args[1].span, "_")) - ); - } - ); + span_lint_and_then(cx, + GET_UNWRAP, + expr.span, + &format!("called `.get{0}().unwrap()` on a {1}. Using `[]` is more clear and more concise", + mut_str, + caller_type), + |db| { + db.span_suggestion(expr.span, + "try this", + format!("{}{}[{}]", + borrow_str, + snippet(cx, get_args[0].span, "_"), + snippet(cx, get_args[1].span, "_"))); + }); } -fn lint_iter_skip_next(cx: &LateContext, expr: &hir::Expr){ +fn lint_iter_skip_next(cx: &LateContext, expr: &hir::Expr) { // lint if caller of skip is an Iterator if match_trait_method(cx, expr, &paths::ITERATOR) { - span_lint( - cx, - ITER_SKIP_NEXT, - expr.span, - "called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)`" - ); + span_lint(cx, + ITER_SKIP_NEXT, + expr.span, + "called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)`"); } } @@ -975,9 +973,7 @@ fn derefs_to_slice(cx: &LateContext, expr: &hir::Expr, ty: ty::Ty) -> Option Option 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 { diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs index ccfc01a00030..d4198c97d13f 100644 --- a/clippy_lints/src/minmax.rs +++ b/clippy_lints/src/minmax.rs @@ -46,7 +46,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MinMaxPass { (MinMax::Min, Some(Ordering::Greater)) => (), _ => { span_lint(cx, MIN_MAX, expr.span, "this min/max combination leads to constant result"); - } + }, } } } diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index 0680f6b41a16..f1bce029e395 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -8,10 +8,8 @@ use rustc_const_eval::EvalHint::ExprTypeChecked; use rustc_const_eval::eval_const_expr_partial; use rustc_const_math::ConstFloat; use syntax::codemap::{Span, Spanned, ExpnFormat}; -use utils::{ - get_item_name, get_parent_expr, implements_trait, in_macro, is_integer_literal, match_path, - snippet, span_lint, span_lint_and_then, walk_ptrs_ty, last_path_segment -}; +use utils::{get_item_name, get_parent_expr, implements_trait, in_macro, is_integer_literal, match_path, snippet, + span_lint, span_lint_and_then, walk_ptrs_ty, last_path_segment}; use utils::sugg::Sugg; /// **What it does:** Checks for function arguments and let bindings denoted as `ref`. @@ -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; @@ -236,23 +235,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { if let Some(name) = get_item_name(cx, expr) { let name = &*name.as_str(); if name == "eq" || name == "ne" || name == "is_nan" || name.starts_with("eq_") || - name.ends_with("_eq") { + name.ends_with("_eq") { return; } } - span_lint_and_then(cx, - FLOAT_CMP, - expr.span, - "strict comparison of f32 or f64", - |db| { - let lhs = Sugg::hir(cx, left, ".."); - let rhs = Sugg::hir(cx, right, ".."); + span_lint_and_then(cx, FLOAT_CMP, expr.span, "strict comparison of f32 or f64", |db| { + let lhs = Sugg::hir(cx, left, ".."); + let rhs = Sugg::hir(cx, right, ".."); - db.span_suggestion(expr.span, - "consider comparing them within some error", - format!("({}).abs() < error", lhs - rhs)); - db.span_note(expr.span, "std::f32::EPSILON and std::f64::EPSILON are available."); - }); + db.span_suggestion(expr.span, + "consider comparing them within some error", + format!("({}).abs() < error", lhs - rhs)); + db.span_note(expr.span, "std::f32::EPSILON and std::f64::EPSILON are available."); + }); } else if op == BiRem && is_integer_literal(right, 1) { span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0"); } @@ -274,7 +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, } } diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs index abb9d0fcb49a..9d9f30c820c9 100644 --- a/clippy_lints/src/misc_early.rs +++ b/clippy_lints/src/misc_early.rs @@ -168,9 +168,14 @@ pub struct MiscEarly; impl LintPass for MiscEarly { fn get_lints(&self) -> LintArray { - lint_array!(UNNEEDED_FIELD_PATTERN, DUPLICATE_UNDERSCORE_ARGUMENT, REDUNDANT_CLOSURE_CALL, - DOUBLE_NEG, MIXED_CASE_HEX_LITERALS, UNSEPARATED_LITERAL_SUFFIX, - ZERO_PREFIXED_LITERAL, BUILTIN_TYPE_SHADOW) + lint_array!(UNNEEDED_FIELD_PATTERN, + DUPLICATE_UNDERSCORE_ARGUMENT, + REDUNDANT_CLOSURE_CALL, + DOUBLE_NEG, + MIXED_CASE_HEX_LITERALS, + UNSEPARATED_LITERAL_SUFFIX, + ZERO_PREFIXED_LITERAL, + BUILTIN_TYPE_SHADOW) } } @@ -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; } }} - } - _ => () + }, + _ => (), } } diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs index 2f3bdeb053c8..403c6ddcbdf7 100644 --- a/clippy_lints/src/missing_doc.rs +++ b/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 or the MIT license - * , 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 or the MIT license +// , 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 { diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs index 40bb77871dbc..7d4326828cb1 100644 --- a/clippy_lints/src/mut_mut.rs +++ b/clippy_lints/src/mut_mut.rs @@ -64,7 +64,10 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> { intravisit::walk_expr(self, body); } else if let hir::ExprAddrOf(hir::MutMutable, ref e) = expr.node { if let hir::ExprAddrOf(hir::MutMutable, _) = e.node { - span_lint(self.cx, MUT_MUT, expr.span, "generally you want to avoid `&mut &mut _` if possible"); + span_lint(self.cx, + MUT_MUT, + expr.span, + "generally you want to avoid `&mut &mut _` if possible"); } else if let TyRef(_, TypeAndMut { mutbl: hir::MutMutable, .. }) = self.cx.tcx.tables().expr_ty(e).sty { span_lint(self.cx, MUT_MUT, @@ -77,7 +80,10 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> { fn visit_ty(&mut self, ty: &'tcx hir::Ty) { if let hir::TyRptr(_, hir::MutTy { ty: ref pty, mutbl: hir::MutMutable }) = ty.node { if let hir::TyRptr(_, hir::MutTy { mutbl: hir::MutMutable, .. }) = pty.node { - span_lint(self.cx, MUT_MUT, ty.span, "generally you want to avoid `&mut &mut _` if possible"); + span_lint(self.cx, + MUT_MUT, + ty.span, + "generally you want to avoid `&mut &mut _` if possible"); } } diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs index d2cd0a329143..7e7733bed80c 100644 --- a/clippy_lints/src/mut_reference.rs +++ b/clippy_lints/src/mut_reference.rs @@ -38,19 +38,18 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnecessaryMutPassed { match e.node { ExprCall(ref fn_expr, ref arguments) => { let function_type = borrowed_table.node_types - .get(&fn_expr.id) - .expect("A function with an unknown type is called. \ - If this happened, the compiler would have \ - aborted the compilation long ago"); + .get(&fn_expr.id) + .expect("A function with an unknown type is called. If this happened, the compiler would have \ + aborted the compilation long ago"); if let ExprPath(ref path) = fn_expr.node { check_arguments(cx, arguments, function_type, &path.to_string()); } - } + }, ExprMethodCall(ref name, _, ref arguments) => { let method_call = MethodCall::expr(e.id); let method_type = borrowed_table.method_map.get(&method_call).expect("This should never happen."); check_arguments(cx, arguments, method_type.ty, &name.node.as_str()) - } + }, _ => (), } } @@ -71,11 +70,11 @@ fn check_arguments(cx: &LateContext, arguments: &[Expr], type_definition: &TyS, argument.span, &format!("The function/method \"{}\" doesn't need a mutable reference", name)); } - } + }, _ => (), } } - } + }, _ => (), } } diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs index 3b08ebdbc8e0..9a0d5f1bb36b 100644 --- a/clippy_lints/src/needless_bool.rs +++ b/clippy_lints/src/needless_bool.rs @@ -62,11 +62,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool { if let ExprIf(ref pred, ref then_block, Some(ref else_expr)) = e.node { let reduce = |ret, not| { let snip = Sugg::hir(cx, pred, ""); - 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, } } diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs index 935e0da8c3ed..f05fdaab1764 100644 --- a/clippy_lints/src/needless_borrow.rs +++ b/clippy_lints/src/needless_borrow.rs @@ -41,7 +41,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrow { } if let ExprAddrOf(MutImmutable, ref inner) = e.node { if let ty::TyRef(..) = cx.tcx.tables().expr_ty(inner).sty { - if let Some(&ty::adjustment::Adjust::DerefRef { autoderefs, autoref, .. }) = cx.tcx.tables.borrow().adjustments.get(&e.id).map(|a| &a.kind) { + if let Some(&ty::adjustment::Adjust::DerefRef { autoderefs, autoref, .. }) = + cx.tcx.tables.borrow().adjustments.get(&e.id).map(|a| &a.kind) { if autoderefs > 1 && autoref.is_some() { span_lint(cx, NEEDLESS_BORROW, @@ -61,10 +62,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrow { if let ty::TyRef(_, ref tam) = cx.tcx.tables().pat_ty(pat).sty { if tam.mutbl == MutImmutable { if let ty::TyRef(..) = tam.ty.sty { - span_lint(cx, - NEEDLESS_BORROW, - pat.span, - "this pattern creates a reference to a reference") + span_lint(cx, NEEDLESS_BORROW, pat.span, "this pattern creates a reference to a reference") } } } diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs index f4a7ebee590f..4c9ff3288962 100644 --- a/clippy_lints/src/new_without_default.rs +++ b/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, } } diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs index 4a4b73b697f8..a87c9d0f7365 100644 --- a/clippy_lints/src/no_effect.rs +++ b/clippy_lints/src/no_effect.rs @@ -66,7 +66,7 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool { Some(ref base) => has_no_effect(cx, base), None => true, } - } + }, Expr_::ExprCall(ref callee, ref args) => { if let Expr_::ExprPath(ref qpath) = callee.node { let def = cx.tcx.tables().qpath_def(qpath, callee.id); @@ -80,7 +80,7 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool { } else { false } - } + }, Expr_::ExprBlock(ref block) => { block.stmts.is_empty() && if let Some(ref expr) = block.expr { @@ -88,7 +88,7 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool { } else { false } - } + }, _ => false, } } @@ -148,7 +148,7 @@ fn reduce_expression<'a>(cx: &LateContext, expr: &'a Expr) -> Option 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 { 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 None, } } diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs index 6ccdb6ee1459..f7005b6169b0 100644 --- a/clippy_lints/src/non_expressive_names.rs +++ b/clippy_lints/src/non_expressive_names.rs @@ -88,7 +88,7 @@ impl<'a, 'tcx: 'a, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> { self.visit_pat(&field.node.pat); } } - } + }, _ => walk_pat(self, pat), } } diff --git a/clippy_lints/src/ok_if_let.rs b/clippy_lints/src/ok_if_let.rs index 6ac49c1f575d..65b13688ff62 100644 --- a/clippy_lints/src/ok_if_let.rs +++ b/clippy_lints/src/ok_if_let.rs @@ -15,7 +15,7 @@ use utils::{paths, method_chain_args, span_help_and_lint, match_type, snippet}; /// vec.push(bench) /// } /// } -///``` +/// ``` /// Could be written: /// /// ```rust diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs index f102bdcab33d..4216345e48e7 100644 --- a/clippy_lints/src/open_options.rs +++ b/clippy_lints/src/open_options.rs @@ -71,36 +71,32 @@ fn get_open_options(cx: &LateContext, argument: &Expr, options: &mut Vec<(OpenOp let argument_option = match arguments[1].node { ExprLit(ref span) => { if let Spanned { node: LitKind::Bool(lit), .. } = **span { - if lit { - Argument::True - } else { - Argument::False - } + if lit { Argument::True } else { Argument::False } } else { return; // The function is called with a literal // which is not a boolean literal. This is theoretically // possible, but not very likely. } - } + }, _ => Argument::Unknown, }; match &*name.node.as_str() { "create" => { options.push((OpenOption::Create, argument_option)); - } + }, "append" => { options.push((OpenOption::Append, argument_option)); - } + }, "truncate" => { options.push((OpenOption::Truncate, argument_option)); - } + }, "read" => { options.push((OpenOption::Read, argument_option)); - } + }, "write" => { options.push((OpenOption::Write, argument_option)); - } + }, _ => (), } @@ -111,11 +107,8 @@ fn get_open_options(cx: &LateContext, argument: &Expr, options: &mut Vec<(OpenOp fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span: Span) { let (mut create, mut append, mut truncate, mut read, mut write) = (false, false, false, false, false); - let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) = (false, - false, - false, - false, - false); + let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) = + (false, false, false, false, false); // This code is almost duplicated (oh, the irony), but I haven't found a way to unify it. for option in options { @@ -130,7 +123,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span create = true } create_arg = create_arg || (arg == Argument::True);; - } + }, (OpenOption::Append, arg) => { if append { span_lint(cx, @@ -141,7 +134,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span append = true } append_arg = append_arg || (arg == Argument::True);; - } + }, (OpenOption::Truncate, arg) => { if truncate { span_lint(cx, @@ -152,7 +145,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span truncate = true } truncate_arg = truncate_arg || (arg == Argument::True); - } + }, (OpenOption::Read, arg) => { if read { span_lint(cx, @@ -163,7 +156,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span read = true } read_arg = read_arg || (arg == Argument::True);; - } + }, (OpenOption::Write, arg) => { if write { span_lint(cx, @@ -174,7 +167,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span write = true } write_arg = write_arg || (arg == Argument::True);; - } + }, } } diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs index 1d10fb19c733..146706646ae4 100644 --- a/clippy_lints/src/precedence.rs +++ b/clippy_lints/src/precedence.rs @@ -49,7 +49,7 @@ impl EarlyLintPass for Precedence { snippet(cx, left.span, ".."), op.to_string(), snippet(cx, right.span, ".."))); - } + }, (true, false) => { span_lint(cx, PRECEDENCE, @@ -59,7 +59,7 @@ impl EarlyLintPass for Precedence { snippet(cx, left.span, ".."), op.to_string(), snippet(cx, right.span, ".."))); - } + }, (false, true) => { span_lint(cx, PRECEDENCE, @@ -69,7 +69,7 @@ impl EarlyLintPass for Precedence { snippet(cx, left.span, ".."), op.to_string(), snippet(cx, right.span, ".."))); - } + }, _ => (), } } @@ -88,7 +88,7 @@ impl EarlyLintPass for Precedence { &format!("unary minus has lower precedence than method call. Consider \ adding parentheses to clarify your intent: -({})", snippet(cx, rhs.span, ".."))); - } + }, _ => (), } } diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index 1461189946c1..2f74390cc73e 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -117,7 +117,7 @@ fn is_null_path(expr: &Expr) -> bool { if let ExprCall(ref pathexp, ref args) = expr.node { if args.is_empty() { if let ExprPath(ref path) = pathexp.node { - return match_path(path, &paths::PTR_NULL) || match_path(path, &paths::PTR_NULL_MUT) + return match_path(path, &paths::PTR_NULL) || match_path(path, &paths::PTR_NULL_MUT); } } } diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs index 78f097002039..01829ffea45b 100644 --- a/clippy_lints/src/ranges.rs +++ b/clippy_lints/src/ranges.rs @@ -52,8 +52,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StepByZero { let name = &*name.as_str(); // Range with step_by(0). - if name == "step_by" && args.len() == 2 && has_step_by(cx, &args[0]) && - is_integer_literal(&args[1], 0) { + if name == "step_by" && args.len() == 2 && has_step_by(cx, &args[0]) && is_integer_literal(&args[1], 0) { span_lint(cx, RANGE_STEP_BY_ZERO, expr.span, @@ -94,7 +93,6 @@ fn has_step_by(cx: &LateContext, expr: &Expr) -> bool { let ty = cx.tcx.tables().expr_ty(expr); // Note: `RangeTo`, `RangeToInclusive` and `RangeFull` don't have step_by - match_type(cx, ty, &paths::RANGE) - || match_type(cx, ty, &paths::RANGE_FROM) - || match_type(cx, ty, &paths::RANGE_INCLUSIVE) + match_type(cx, ty, &paths::RANGE) || match_type(cx, ty, &paths::RANGE_FROM) || + match_type(cx, ty, &paths::RANGE_INCLUSIVE) } diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs index 19e8a3c7d146..7c5c5713550a 100644 --- a/clippy_lints/src/reference.rs +++ b/clippy_lints/src/reference.rs @@ -1,4 +1,4 @@ -use syntax::ast::{Expr,ExprKind,UnOp}; +use syntax::ast::{Expr, ExprKind, UnOp}; use rustc::lint::*; use utils::{span_lint_and_then, snippet}; @@ -40,15 +40,9 @@ impl EarlyLintPass for Pass { fn check_expr(&mut self, cx: &EarlyContext, e: &Expr) { if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.node { if let ExprKind::AddrOf(_, ref addrof_target) = without_parens(deref_target).node { - span_lint_and_then( - cx, - DEREF_ADDROF, - e.span, - "immediately dereferencing a reference", - |db| { - db.span_suggestion(e.span, "try this", - format!("{}", snippet(cx, addrof_target.span, "_"))); - }); + span_lint_and_then(cx, DEREF_ADDROF, e.span, "immediately dereferencing a reference", |db| { + db.span_suggestion(e.span, "try this", format!("{}", snippet(cx, addrof_target.span, "_"))); + }); } } } diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs index 6e6b6156d6e6..a390a8ee47c4 100644 --- a/clippy_lints/src/regex.rs +++ b/clippy_lints/src/regex.rs @@ -145,7 +145,7 @@ fn str_span(base: Span, s: &str, c: usize) -> Span { hi: base.lo + BytePos(h as u32), ..base } - } + }, _ => base, } } @@ -172,17 +172,18 @@ fn is_trivial_regex(s: ®ex_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())); - } + }, } } } diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs index d79913b2c15b..b9054f72164b 100644 --- a/clippy_lints/src/returns.rs +++ b/clippy_lints/src/returns.rs @@ -48,9 +48,10 @@ impl ReturnPass { fn check_block_return(&mut self, cx: &EarlyContext, block: &ast::Block) { if let Some(stmt) = block.stmts.last() { match stmt.node { - ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => { + ast::StmtKind::Expr(ref expr) | + ast::StmtKind::Semi(ref expr) => { self.check_final_expr(cx, expr, Some(stmt.span)); - } + }, _ => (), } } @@ -65,24 +66,24 @@ impl ReturnPass { if !expr.attrs.iter().any(attr_is_cfg) { self.emit_return_lint(cx, span.expect("`else return` is not possible"), inner.span); } - } + }, // a whole block? check it! ast::ExprKind::Block(ref block) => { self.check_block_return(cx, block); - } + }, // an if/if let expr, check both exprs // note, if without else is going to be a type checking error anyways // (except for unit type functions) so we don't match it ast::ExprKind::If(_, ref ifblock, Some(ref elsexpr)) => { self.check_block_return(cx, ifblock); self.check_final_expr(cx, elsexpr, None); - } + }, // a match expr, check all arms ast::ExprKind::Match(_, ref arms) => { for arm in arms { self.check_final_expr(cx, &arm.body, Some(arm.body.span)); } - } + }, _ => (), } } @@ -135,7 +136,8 @@ impl LintPass for ReturnPass { impl EarlyLintPass for ReturnPass { fn check_fn(&mut self, cx: &EarlyContext, kind: FnKind, _: &ast::FnDecl, _: Span, _: ast::NodeId) { match kind { - FnKind::ItemFn(.., block) | FnKind::Method(.., block) => self.check_block_return(cx, block), + FnKind::ItemFn(.., block) | + FnKind::Method(.., block) => self.check_block_return(cx, block), FnKind::Closure(body) => self.check_final_expr(cx, body, None), } } @@ -152,4 +154,3 @@ fn attr_is_cfg(attr: &ast::Attribute) -> bool { false } } - diff --git a/clippy_lints/src/serde.rs b/clippy_lints/src/serde.rs index ec4bce557061..02faf7a204fb 100644 --- a/clippy_lints/src/serde.rs +++ b/clippy_lints/src/serde.rs @@ -46,8 +46,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Serde { span_lint(cx, SERDE_API_MISUSE, span, - "you should not implement `visit_string` without also implementing `visit_str`", - ); + "you should not implement `visit_string` without also implementing `visit_str`"); } } } diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs index 2d32a8792741..9961a26b5c49 100644 --- a/clippy_lints/src/shadow.rs +++ b/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,15 +166,15 @@ fn check_pat<'a, 'tcx>( if let Some(ref p) = *inner { check_pat(cx, p, init, span, bindings); } - } + }, PatKind::Struct(_, ref pfields, _) => { if let Some(init_struct) = init { if let ExprStruct(_, ref efields, _) = init_struct.node { for field in pfields { let name = field.node.name; let efield = efields.iter() - .find(|f| f.name.node == name) - .map(|f| &*f.expr); + .find(|f| f.name.node == name) + .map(|f| &*f.expr); check_pat(cx, &field.node.pat, efield, span, bindings); } } else { @@ -199,7 +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>, Option>, Vec>), _ => (), } } -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, diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs index 01f2f66c2fde..844fd9482ff9 100644 --- a/clippy_lints/src/strings.rs +++ b/clippy_lints/src/strings.rs @@ -122,7 +122,7 @@ fn is_add(cx: &LateContext, src: &Expr, target: &Expr) -> bool { ExprBinary(Spanned { node: BiAdd, .. }, ref left, _) => SpanlessEq::new(cx).eq_expr(target, left), ExprBlock(ref block) => { block.stmts.is_empty() && block.expr.as_ref().map_or(false, |expr| is_add(cx, expr, target)) - } + }, _ => false, } } diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs index 2f6e6d97fbf7..1669b2d65572 100644 --- a/clippy_lints/src/temporary_assignment.rs +++ b/clippy_lints/src/temporary_assignment.rs @@ -46,7 +46,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { if is_temporary(base) && !is_adjusted(cx, base) { span_lint(cx, TEMPORARY_ASSIGNMENT, expr.span, "assignment to temporary"); } - } + }, _ => (), } } diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index b6731db93839..7364e798ddba 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -95,18 +95,18 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute { let to_ty = cx.tcx.tables().expr_ty(e); match (&from_ty.sty, &to_ty.sty) { - _ if from_ty == to_ty => span_lint( - cx, - USELESS_TRANSMUTE, - e.span, - &format!("transmute from a type (`{}`) to itself", from_ty), - ), - (&TyRef(_, rty), &TyRawPtr(ptr_ty)) => span_lint_and_then( - cx, - USELESS_TRANSMUTE, - e.span, - "transmute from a reference to a pointer", - |db| { + _ if from_ty == to_ty => { + span_lint(cx, + USELESS_TRANSMUTE, + e.span, + &format!("transmute from a type (`{}`) to itself", from_ty)) + }, + (&TyRef(_, rty), &TyRawPtr(ptr_ty)) => { + span_lint_and_then(cx, + USELESS_TRANSMUTE, + e.span, + "transmute from a reference to a pointer", + |db| { if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) { let sugg = if ptr_ty == rty { arg.as_ty(to_ty) @@ -116,45 +116,45 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute { db.span_suggestion(e.span, "try", sugg.to_string()); } - }, - ), + }) + }, (&ty::TyInt(_), &TyRawPtr(_)) | - (&ty::TyUint(_), &TyRawPtr(_)) => span_lint_and_then( - cx, - USELESS_TRANSMUTE, - e.span, - "transmute from an integer to a pointer", - |db| { + (&ty::TyUint(_), &TyRawPtr(_)) => { + span_lint_and_then(cx, + USELESS_TRANSMUTE, + e.span, + "transmute from an integer to a pointer", + |db| { if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) { db.span_suggestion(e.span, "try", arg.as_ty(&to_ty.to_string()).to_string()); } - }, - ), + }) + }, (&ty::TyFloat(_), &TyRef(..)) | (&ty::TyFloat(_), &TyRawPtr(_)) | (&ty::TyChar, &TyRef(..)) | - (&ty::TyChar, &TyRawPtr(_)) => span_lint( - cx, - WRONG_TRANSMUTE, - e.span, - &format!("transmute from a `{}` to a pointer", from_ty), - ), - (&TyRawPtr(from_ptr), _) if from_ptr.ty == to_ty => span_lint( - cx, - CROSSPOINTER_TRANSMUTE, - e.span, - &format!("transmute from a type (`{}`) to the type that it points to (`{}`)", + (&ty::TyChar, &TyRawPtr(_)) => { + span_lint(cx, + WRONG_TRANSMUTE, + e.span, + &format!("transmute from a `{}` to a pointer", from_ty)) + }, + (&TyRawPtr(from_ptr), _) if from_ptr.ty == to_ty => { + span_lint(cx, + CROSSPOINTER_TRANSMUTE, + e.span, + &format!("transmute from a type (`{}`) to the type that it points to (`{}`)", from_ty, - to_ty), - ), - (_, &TyRawPtr(to_ptr)) if to_ptr.ty == from_ty => span_lint( - cx, - CROSSPOINTER_TRANSMUTE, - e.span, - &format!("transmute from a type (`{}`) to a pointer to that type (`{}`)", + 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, diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 930c44c88633..50f3529d6787 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -6,8 +6,8 @@ use rustc::ty; use std::cmp::Ordering; use syntax::ast::{IntTy, UintTy, FloatTy}; use syntax::codemap::Span; -use utils::{comparisons, higher, in_external_macro, in_macro, match_def_path, snippet, - span_help_and_lint, span_lint, opt_def_id, last_path_segment}; +use utils::{comparisons, higher, in_external_macro, in_macro, match_def_path, snippet, span_help_and_lint, span_lint, + opt_def_id, last_path_segment}; use utils::paths; /// Handles all the linting of funky types @@ -95,10 +95,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypePass { }} } else if match_def_path(cx, def_id, &paths::LINKED_LIST) { span_help_and_lint(cx, - LINKEDLIST, - ast_ty.span, - "I see you're using a LinkedList! Perhaps you meant some other data structure?", - "a VecDeque might work"); + LINKEDLIST, + ast_ty.span, + "I see you're using a LinkedList! Perhaps you meant some other data structure?", + "a VecDeque might work"); } } } @@ -141,7 +141,7 @@ fn check_let_unit(cx: &LateContext, decl: &Decl) { decl.span, &format!("this let-binding has unit value. Consider omitting `let {} =`", snippet(cx, local.pat.span, ".."))); - } + }, _ => (), } } @@ -211,8 +211,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitCmp { &format!("{}-comparison of unit values detected. This will always be {}", op.as_str(), result)); - } - _ => () + }, + _ => (), } } } @@ -336,11 +336,7 @@ fn is_isize_or_usize(typ: &ty::TyS) -> bool { } fn span_precision_loss_lint(cx: &LateContext, expr: &Expr, cast_from: &ty::TyS, cast_to_f64: bool) { - let mantissa_nbits = if cast_to_f64 { - 52 - } else { - 23 - }; + let mantissa_nbits = if cast_to_f64 { 52 } else { 23 }; let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64; let arch_dependent_str = "on targets with 64-bit wide pointers "; let from_nbits_str = if arch_dependent { @@ -388,27 +384,27 @@ fn check_truncation_and_wrapping(cx: &LateContext, expr: &Expr, cast_from: &ty:: ArchSuffix::None, to_nbits == from_nbits && cast_unsigned_to_signed, ArchSuffix::None) - } + }, (true, false) => { (to_nbits <= 32, if to_nbits == 32 { - ArchSuffix::_64 - } else { - ArchSuffix::None - }, + ArchSuffix::_64 + } else { + ArchSuffix::None + }, to_nbits <= 32 && cast_unsigned_to_signed, ArchSuffix::_32) - } + }, (false, true) => { (from_nbits == 64, ArchSuffix::_32, cast_unsigned_to_signed, if from_nbits == 64 { - ArchSuffix::_64 - } else { - ArchSuffix::_32 - }) - } + ArchSuffix::_64 + } else { + ArchSuffix::_32 + }) + }, }; if span_truncation { span_lint(cx, @@ -463,7 +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 { } 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) diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs index 341848a868cd..07afc55ae7f1 100644 --- a/clippy_lints/src/unsafe_removed_from_name.rs +++ b/clippy_lints/src/unsafe_removed_from_name.rs @@ -38,15 +38,14 @@ impl EarlyLintPass for UnsafeNameRemoval { if let ItemKind::Use(ref item_use) = item.node { match item_use.node { ViewPath_::ViewPathSimple(ref name, ref path) => { - unsafe_to_safe_check( - path.segments - .last() - .expect("use paths cannot be empty") - .identifier, - *name, - cx, &item.span - ); - } + unsafe_to_safe_check(path.segments + .last() + .expect("use paths cannot be empty") + .identifier, + *name, + cx, + &item.span); + }, ViewPath_::ViewPathList(_, ref path_list_items) => { for path_list_item in path_list_items.iter() { let plid = path_list_item.node; @@ -54,8 +53,8 @@ impl EarlyLintPass for UnsafeNameRemoval { unsafe_to_safe_check(plid.name, rename, cx, &item.span); }; } - } - ViewPath_::ViewPathGlob(_) => {} + }, + ViewPath_::ViewPathGlob(_) => {}, } } } @@ -68,11 +67,7 @@ fn unsafe_to_safe_check(old_name: Ident, new_name: Ident, cx: &EarlyContext, spa span_lint(cx, UNSAFE_REMOVED_FROM_NAME, *span, - &format!( - "removed \"unsafe\" from the name of `{}` in use as `{}`", - old_str, - new_str - )); + &format!("removed \"unsafe\" from the name of `{}` in use as `{}`", old_str, new_str)); } } diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs index 4f1e01af6e9f..b58456ce85ed 100644 --- a/clippy_lints/src/unused_label.rs +++ b/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); - } + }, _ => (), } diff --git a/clippy_lints/src/utils/comparisons.rs b/clippy_lints/src/utils/comparisons.rs index a277226eb67c..f973c2afd27a 100644 --- a/clippy_lints/src/utils/comparisons.rs +++ b/clippy_lints/src/utils/comparisons.rs @@ -18,8 +18,7 @@ pub enum Rel { } /// Put the expression in the form `lhs < rhs`, `lhs <= rhs`, `lhs == rhs` or `lhs != rhs`. -pub fn normalize_comparison<'a>(op: BinOp_, lhs: &'a Expr, rhs: &'a Expr) - -> Option<(Rel, &'a Expr, &'a Expr)> { +pub fn normalize_comparison<'a>(op: BinOp_, lhs: &'a Expr, rhs: &'a Expr) -> Option<(Rel, &'a Expr, &'a Expr)> { match op { BinOp_::BiLt => Some((Rel::Lt, lhs, rhs)), BinOp_::BiLe => Some((Rel::Le, lhs, rhs)), diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs index 9a1753d511ce..0ba86ff55dc1 100644 --- a/clippy_lints/src/utils/conf.rs +++ b/clippy_lints/src/utils/conf.rs @@ -8,21 +8,20 @@ use syntax::{ast, codemap}; use toml; /// Get the configuration file from arguments. -pub fn file_from_args(args: &[codemap::Spanned]) -> Result, (&'static str, codemap::Span)> { +pub fn file_from_args(args: &[codemap::Spanned]) + -> Result, (&'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), /// Type error. - Type( - /// The name of the key. - &'static str, - /// The expected type. - &'static str, - /// The type we got instead. - &'static str - ), + Type(/// The name of the key. + &'static str, + /// The expected type. + &'static str, + /// The type we got instead. + &'static str), /// There is an unknown key is the file. UnknownKey(String), } @@ -66,10 +63,10 @@ impl fmt::Display for Error { } Ok(()) - } + }, Error::Type(key, expected, got) => { write!(f, "`{}` is expected to be a `{}` but is a `{}`", key, expected, got) - } + }, Error::UnknownKey(ref key) => write!(f, "unknown key `{}`", key), } } @@ -196,7 +193,7 @@ pub fn lookup_conf_file() -> io::Result> { if e.kind() != io::ErrorKind::NotFound { return Err(e); } - } + }, _ => (), } } @@ -231,11 +228,11 @@ pub fn read(path: Option<&path::Path>) -> (Conf, Vec) { } buf - } + }, Err(err) => { errors.push(err.into()); return (conf, errors); - } + }, }; let mut parser = toml::Parser::new(&file); diff --git a/clippy_lints/src/utils/constants.rs b/clippy_lints/src/utils/constants.rs index 179c251e3228..87008307c5f6 100644 --- a/clippy_lints/src/utils/constants.rs +++ b/clippy_lints/src/utils/constants.rs @@ -7,15 +7,5 @@ /// See also [the reference][reference-types] for a list of such types. /// /// [reference-types]: https://doc.rust-lang.org/reference.html#types -pub const BUILTIN_TYPES: &'static [&'static str] = &[ - "i8", "u8", - "i16", "u16", - "i32", "u32", - "i64", "u64", - "isize", "usize", - "f32", - "f64", - "bool", - "str", - "char", -]; +pub const BUILTIN_TYPES: &'static [&'static str] = &["i8", "u8", "i16", "u16", "i32", "u32", "i64", "u64", "isize", + "usize", "f32", "f64", "bool", "str", "char"]; diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs index 6ae4743a368c..c83dae26fdaa 100644 --- a/clippy_lints/src/utils/higher.rs +++ b/clippy_lints/src/utils/higher.rs @@ -47,9 +47,9 @@ pub fn range(expr: &hir::Expr) -> Option { /// Find the field named `name` in the field. Always return `Some` for convenience. fn get_field<'a>(name: &str, fields: &'a [hir::Field]) -> Option<&'a hir::Expr> { let expr = &fields.iter() - .find(|field| field.name.node == name) - .unwrap_or_else(|| panic!("missing {} field for range", name)) - .expr; + .find(|field| field.name.node == name) + .unwrap_or_else(|| panic!("missing {} field for range", name)) + .expr; Some(expr) } @@ -68,7 +68,7 @@ pub fn range(expr: &hir::Expr) -> Option { } else { None } - } + }, hir::ExprStruct(ref path, ref fields, None) => { if match_path(path, &paths::RANGE_FROM_STD) || match_path(path, &paths::RANGE_FROM) { Some(Range { @@ -77,7 +77,7 @@ pub fn range(expr: &hir::Expr) -> Option { limits: ast::RangeLimits::HalfOpen, }) } else if match_path(path, &paths::RANGE_INCLUSIVE_NON_EMPTY_STD) || - match_path(path, &paths::RANGE_INCLUSIVE_NON_EMPTY) { + match_path(path, &paths::RANGE_INCLUSIVE_NON_EMPTY) { Some(Range { start: get_field("start", fields), end: get_field("end", fields), @@ -104,7 +104,7 @@ pub fn range(expr: &hir::Expr) -> Option { } else { None } - } + }, _ => None, } } diff --git a/clippy_lints/src/utils/hir.rs b/clippy_lints/src/utils/hir.rs index e01feb3fcae2..80399825b6d1 100644 --- a/clippy_lints/src/utils/hir.rs +++ b/clippy_lints/src/utils/hir.rs @@ -38,12 +38,11 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { match (&left.node, &right.node) { (&StmtDecl(ref l, _), &StmtDecl(ref r, _)) => { if let (&DeclLocal(ref l), &DeclLocal(ref r)) = (&l.node, &r.node) { - both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) && - both(&l.init, &r.init, |l, r| self.eq_expr(l, r)) + both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) && both(&l.init, &r.init, |l, r| self.eq_expr(l, r)) } else { false } - } + }, (&StmtExpr(ref l, _), &StmtExpr(ref r, _)) | (&StmtSemi(ref l, _), &StmtSemi(ref r, _)) => self.eq_expr(l, r), _ => false, @@ -73,64 +72,60 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { (&ExprAssign(ref ll, ref lr), &ExprAssign(ref rl, ref rr)) => self.eq_expr(ll, rl) && self.eq_expr(lr, rr), (&ExprAssignOp(ref lo, ref ll, ref lr), &ExprAssignOp(ref ro, ref rl, ref rr)) => { lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) - } + }, (&ExprBlock(ref l), &ExprBlock(ref r)) => self.eq_block(l, r), (&ExprBinary(l_op, ref ll, ref lr), &ExprBinary(r_op, ref rl, ref rr)) => { l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) || swap_binop(l_op.node, ll, lr).map_or(false, |(l_op, ll, lr)| { l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) }) - } - (&ExprBreak(li, ref le), &ExprBreak(ri, ref re)) => - both(&li, &ri, |l, r| l.name.as_str() == r.name.as_str()) - && both(le, re, |l, r| self.eq_expr(l, r)), + }, + (&ExprBreak(li, ref le), &ExprBreak(ri, ref re)) => { + both(&li, &ri, |l, r| l.name.as_str() == r.name.as_str()) && both(le, re, |l, r| self.eq_expr(l, r)) + }, (&ExprBox(ref l), &ExprBox(ref r)) => self.eq_expr(l, r), (&ExprCall(ref l_fun, ref l_args), &ExprCall(ref r_fun, ref r_args)) => { !self.ignore_fn && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args) - } + }, (&ExprCast(ref lx, ref lt), &ExprCast(ref rx, ref rt)) | - (&ExprType(ref lx, ref lt), &ExprType(ref rx, ref rt)) => { - self.eq_expr(lx, rx) && self.eq_ty(lt, rt) - } + (&ExprType(ref lx, ref lt), &ExprType(ref rx, ref rt)) => self.eq_expr(lx, rx) && self.eq_ty(lt, rt), (&ExprField(ref l_f_exp, ref l_f_ident), &ExprField(ref r_f_exp, ref r_f_ident)) => { l_f_ident.node == r_f_ident.node && self.eq_expr(l_f_exp, r_f_exp) - } + }, (&ExprIndex(ref la, ref li), &ExprIndex(ref ra, ref ri)) => self.eq_expr(la, ra) && self.eq_expr(li, ri), (&ExprIf(ref lc, ref lt, ref le), &ExprIf(ref rc, ref rt, ref re)) => { self.eq_expr(lc, rc) && self.eq_block(lt, rt) && both(le, re, |l, r| self.eq_expr(l, r)) - } + }, (&ExprLit(ref l), &ExprLit(ref r)) => l.node == r.node, (&ExprLoop(ref lb, ref ll, ref lls), &ExprLoop(ref rb, ref rl, ref rls)) => { lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str()) - } + }, (&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => { ls == rs && self.eq_expr(le, re) && over(la, ra, |l, r| { - self.eq_expr(&l.body, &r.body) && - both(&l.guard, &r.guard, |l, r| self.eq_expr(l, r)) && + self.eq_expr(&l.body, &r.body) && both(&l.guard, &r.guard, |l, r| self.eq_expr(l, r)) && over(&l.pats, &r.pats, |l, r| self.eq_pat(l, r)) }) - } + }, (&ExprMethodCall(ref l_name, ref l_tys, ref l_args), &ExprMethodCall(ref r_name, ref r_tys, ref r_args)) => { - !self.ignore_fn && l_name.node == r_name.node && - over(l_tys, r_tys, |l, r| self.eq_ty(l, r)) && + !self.ignore_fn && l_name.node == r_name.node && over(l_tys, r_tys, |l, r| self.eq_ty(l, r)) && self.eq_exprs(l_args, r_args) - } + }, (&ExprRepeat(ref le, ref ll), &ExprRepeat(ref re, ref rl)) => self.eq_expr(le, re) && self.eq_expr(ll, rl), (&ExprRet(ref l), &ExprRet(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)), (&ExprPath(ref l), &ExprPath(ref r)) => self.eq_qpath(l, r), (&ExprStruct(ref l_path, ref lf, ref lo), &ExprStruct(ref r_path, ref rf, ref ro)) => { self.eq_qpath(l_path, r_path) && both(lo, ro, |l, r| self.eq_expr(l, r)) && over(lf, rf, |l, r| self.eq_field(l, r)) - } + }, (&ExprTup(ref l_tup), &ExprTup(ref r_tup)) => self.eq_exprs(l_tup, r_tup), (&ExprTupField(ref le, li), &ExprTupField(ref re, ri)) => li.node == ri.node && self.eq_expr(le, re), (&ExprUnary(l_op, ref le), &ExprUnary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re), (&ExprArray(ref l), &ExprArray(ref r)) => self.eq_exprs(l, r), (&ExprWhile(ref lc, ref lb, ref ll), &ExprWhile(ref rc, ref rb, ref rl)) => { self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str()) - } + }, _ => false, } } @@ -153,23 +148,23 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r), (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => { self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs - } + }, (&PatKind::Binding(ref lb, _, ref li, ref lp), &PatKind::Binding(ref rb, _, ref ri, ref rp)) => { lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r)) - } + }, (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r), (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r), (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => { ls == rs && over(l, r, |l, r| self.eq_pat(l, r)) - } + }, (&PatKind::Range(ref ls, ref le), &PatKind::Range(ref rs, ref re)) => { self.eq_expr(ls, rs) && self.eq_expr(le, re) - } + }, (&PatKind::Ref(ref le, ref lm), &PatKind::Ref(ref re, ref rm)) => lm == rm && self.eq_pat(le, re), (&PatKind::Slice(ref ls, ref li, ref le), &PatKind::Slice(ref rs, ref ri, ref re)) => { over(ls, rs, |l, r| self.eq_pat(l, r)) && over(le, re, |l, r| self.eq_pat(l, r)) && both(li, ri, |l, r| self.eq_pat(l, r)) - } + }, (&PatKind::Wild, &PatKind::Wild) => true, _ => false, } @@ -188,8 +183,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } fn eq_path(&self, left: &Path, right: &Path) -> bool { - left.global == right.global && - over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)) + left.global == right.global && over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)) } fn eq_path_parameters(&self, left: &PathParameters, right: &PathParameters) -> bool { @@ -198,35 +192,30 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { over(&left.lifetimes, &right.lifetimes, |l, r| self.eq_lifetime(l, r)) && over(&left.types, &right.types, |l, r| self.eq_ty(l, r)) && over(&left.bindings, &right.bindings, |l, r| self.eq_type_binding(l, r)) - } + }, (&ParenthesizedParameters(ref left), &ParenthesizedParameters(ref right)) => { over(&left.inputs, &right.inputs, |l, r| self.eq_ty(l, r)) && both(&left.output, &right.output, |l, r| self.eq_ty(l, r)) - } + }, (&AngleBracketedParameters(_), &ParenthesizedParameters(_)) | - (&ParenthesizedParameters(_), &AngleBracketedParameters(_)) => { - false - } + (&ParenthesizedParameters(_), &AngleBracketedParameters(_)) => false, } } fn eq_path_segment(&self, left: &PathSegment, right: &PathSegment) -> bool { // The == of idents doesn't work with different contexts, // we have to be explicit about hygiene - left.name.as_str() == right.name.as_str() && - self.eq_path_parameters(&left.parameters, &right.parameters) + left.name.as_str() == right.name.as_str() && self.eq_path_parameters(&left.parameters, &right.parameters) } fn eq_ty(&self, left: &Ty, right: &Ty) -> bool { match (&left.node, &right.node) { (&TySlice(ref l_vec), &TySlice(ref r_vec)) => self.eq_ty(l_vec, r_vec), - (&TyArray(ref lt, ref ll), &TyArray(ref rt, ref rl)) => { - self.eq_ty(lt, rt) && self.eq_expr(ll, rl) - } + (&TyArray(ref lt, ref ll), &TyArray(ref rt, ref rl)) => self.eq_ty(lt, rt) && self.eq_expr(ll, rl), (&TyPtr(ref l_mut), &TyPtr(ref r_mut)) => l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty), (&TyRptr(_, ref l_rmut), &TyRptr(_, ref r_rmut)) => { l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty) - } + }, (&TyPath(ref l), &TyPath(ref r)) => self.eq_qpath(l, r), (&TyTup(ref l), &TyTup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)), (&TyInfer, &TyInfer) => true, @@ -241,13 +230,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { fn swap_binop<'a>(binop: BinOp_, lhs: &'a Expr, rhs: &'a Expr) -> Option<(BinOp_, &'a Expr, &'a Expr)> { match binop { - BiAdd | - BiMul | - BiBitXor | - BiBitAnd | - BiEq | - BiNe | - BiBitOr => Some((binop, rhs, lhs)), + BiAdd | BiMul | BiBitXor | BiBitAnd | BiEq | BiNe | BiBitOr => Some((binop, rhs, lhs)), BiLt => Some((BiGt, rhs, lhs)), BiLe => Some((BiGe, rhs, lhs)), BiGe => Some((BiLe, rhs, lhs)), @@ -316,39 +299,39 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { c.hash(&mut self.s); m.hash(&mut self.s); self.hash_expr(e); - } + }, ExprAgain(i) => { let c: fn(_) -> _ = ExprAgain; c.hash(&mut self.s); if let Some(i) = i { self.hash_name(&i.name); } - } + }, ExprAssign(ref l, ref r) => { let c: fn(_, _) -> _ = ExprAssign; c.hash(&mut self.s); self.hash_expr(l); self.hash_expr(r); - } + }, ExprAssignOp(ref o, ref l, ref r) => { let c: fn(_, _, _) -> _ = ExprAssignOp; c.hash(&mut self.s); o.hash(&mut self.s); self.hash_expr(l); self.hash_expr(r); - } + }, ExprBlock(ref b) => { let c: fn(_) -> _ = ExprBlock; c.hash(&mut self.s); self.hash_block(b); - } + }, ExprBinary(op, ref l, ref r) => { let c: fn(_, _, _) -> _ = ExprBinary; c.hash(&mut self.s); op.node.hash(&mut self.s); self.hash_expr(l); self.hash_expr(r); - } + }, ExprBreak(i, ref j) => { let c: fn(_, _) -> _ = ExprBreak; c.hash(&mut self.s); @@ -358,46 +341,46 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { if let Some(ref j) = *j { self.hash_expr(&*j); } - } + }, ExprBox(ref e) => { let c: fn(_) -> _ = ExprBox; c.hash(&mut self.s); self.hash_expr(e); - } + }, ExprCall(ref fun, ref args) => { let c: fn(_, _) -> _ = ExprCall; c.hash(&mut self.s); self.hash_expr(fun); self.hash_exprs(args); - } + }, ExprCast(ref e, ref _ty) => { let c: fn(_, _) -> _ = ExprCast; c.hash(&mut self.s); self.hash_expr(e); // TODO: _ty - } + }, ExprClosure(cap, _, eid, _) => { let c: fn(_, _, _, _) -> _ = ExprClosure; c.hash(&mut self.s); cap.hash(&mut self.s); self.hash_expr(self.cx.tcx.map.expr(eid)); - } + }, ExprField(ref e, ref f) => { let c: fn(_, _) -> _ = ExprField; c.hash(&mut self.s); self.hash_expr(e); self.hash_name(&f.node); - } + }, ExprIndex(ref a, ref i) => { let c: fn(_, _) -> _ = ExprIndex; c.hash(&mut self.s); self.hash_expr(a); self.hash_expr(i); - } + }, ExprInlineAsm(..) => { let c: fn(_, _, _) -> _ = ExprInlineAsm; c.hash(&mut self.s); - } + }, ExprIf(ref cond, ref t, ref e) => { let c: fn(_, _, _) -> _ = ExprIf; c.hash(&mut self.s); @@ -406,12 +389,12 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { if let Some(ref e) = *e { self.hash_expr(e); } - } + }, ExprLit(ref l) => { let c: fn(_) -> _ = ExprLit; c.hash(&mut self.s); l.hash(&mut self.s); - } + }, ExprLoop(ref b, ref i, _) => { let c: fn(_, _, _) -> _ = ExprLoop; c.hash(&mut self.s); @@ -419,7 +402,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { if let Some(i) = *i { self.hash_name(&i.node); } - } + }, ExprMatch(ref e, ref arms, ref s) => { let c: fn(_, _, _) -> _ = ExprMatch; c.hash(&mut self.s); @@ -434,31 +417,31 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { } s.hash(&mut self.s); - } + }, ExprMethodCall(ref name, ref _tys, ref args) => { let c: fn(_, _, _) -> _ = ExprMethodCall; c.hash(&mut self.s); self.hash_name(&name.node); self.hash_exprs(args); - } + }, ExprRepeat(ref e, ref l) => { let c: fn(_, _) -> _ = ExprRepeat; c.hash(&mut self.s); self.hash_expr(e); self.hash_expr(l); - } + }, ExprRet(ref e) => { let c: fn(_) -> _ = ExprRet; c.hash(&mut self.s); if let Some(ref e) = *e { self.hash_expr(e); } - } + }, ExprPath(ref qpath) => { let c: fn(_) -> _ = ExprPath; c.hash(&mut self.s); self.hash_qpath(qpath); - } + }, ExprStruct(ref path, ref fields, ref expr) => { let c: fn(_, _, _) -> _ = ExprStruct; c.hash(&mut self.s); @@ -473,38 +456,38 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { if let Some(ref e) = *expr { self.hash_expr(e); } - } + }, ExprTup(ref tup) => { let c: fn(_) -> _ = ExprTup; c.hash(&mut self.s); self.hash_exprs(tup); - } + }, ExprTupField(ref le, li) => { let c: fn(_, _) -> _ = ExprTupField; c.hash(&mut self.s); self.hash_expr(le); li.node.hash(&mut self.s); - } + }, ExprType(ref e, ref _ty) => { let c: fn(_, _) -> _ = ExprType; c.hash(&mut self.s); self.hash_expr(e); // TODO: _ty - } + }, ExprUnary(lop, ref le) => { let c: fn(_, _) -> _ = ExprUnary; c.hash(&mut self.s); lop.hash(&mut self.s); self.hash_expr(le); - } + }, ExprArray(ref v) => { let c: fn(_) -> _ = ExprArray; c.hash(&mut self.s); self.hash_exprs(v); - } + }, ExprWhile(ref cond, ref b, l) => { let c: fn(_, _, _) -> _ = ExprWhile; c.hash(&mut self.s); @@ -514,7 +497,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { if let Some(l) = l { self.hash_name(&l.node); } - } + }, } } @@ -532,12 +515,12 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { match *p { QPath::Resolved(_, ref path) => { self.hash_path(path); - } + }, QPath::TypeRelative(_, ref path) => { self.hash_name(&path.name); - } + }, } - //self.cx.tcx.tables().qpath_def(p, id).hash(&mut self.s); + // self.cx.tcx.tables().qpath_def(p, id).hash(&mut self.s); } pub fn hash_path(&mut self, p: &Path) { @@ -558,17 +541,17 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { self.hash_expr(init); } } - } + }, StmtExpr(ref expr, _) => { let c: fn(_, _) -> _ = StmtExpr; c.hash(&mut self.s); self.hash_expr(expr); - } + }, StmtSemi(ref expr, _) => { let c: fn(_, _) -> _ = StmtSemi; c.hash(&mut self.s); self.hash_expr(expr); - } + }, } } } diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index b2900c5691c7..83d96b8db61a 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/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)), diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index 91961f906919..cf9e90d62bd4 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -75,8 +75,8 @@ impl EarlyLintPass for Clippy { span_lint(cx, CLIPPY_LINTS_INTERNAL, item.span, - "this constant should be before the previous constant due to lexical ordering", - ); + "this constant should be before the previous constant due to lexical \ + ordering"); } } last_name = Some(name); @@ -110,7 +110,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LintWithoutLintPass { if is_lint_ref_type(ty) { self.declared_lints.insert(item.name, item.span); } else if is_lint_array_type(ty) && item.vis == Visibility::Inherited && item.name == "ARRAY" { - let mut collector = LintCollector { output: &mut self.registered_lints, cx: cx }; + let mut collector = LintCollector { + output: &mut self.registered_lints, + cx: cx, + }; collector.visit_expr(expr); } } diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index d8afb96298d4..ec98bfb3d680 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -95,15 +95,17 @@ pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool { } /// Returns true if this `expn_info` was expanded by any macro. pub fn in_macro<'a, T: LintContext<'a>>(cx: &T, span: Span) -> bool { - cx.sess().codemap().with_expn_info(span.expn_id, |info| match info { - Some(info) => { - match info.callee.format { - // don't treat range expressions desugared to structs as "in_macro" - ExpnFormat::CompilerDesugaring(name) => name != "...", - _ => true, - } - }, - None => false, + cx.sess().codemap().with_expn_info(span.expn_id, |info| { + match info { + Some(info) => { + match info.callee.format { + // don't treat range expressions desugared to structs as "in_macro" + ExpnFormat::CompilerDesugaring(name) => name != "...", + _ => true, + } + }, + None => false, + } }) } @@ -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. @@ -177,11 +178,11 @@ pub fn match_impl_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool { let method_call = ty::MethodCall::expr(expr.id); let trt_id = cx.tcx - .tables - .borrow() - .method_map - .get(&method_call) - .and_then(|callee| cx.tcx.impl_of_method(callee.def_id)); + .tables + .borrow() + .method_map + .get(&method_call) + .and_then(|callee| cx.tcx.impl_of_method(callee.def_id)); if let Some(trt_id) = trt_id { match_def_path(cx, trt_id, path) } else { @@ -194,11 +195,11 @@ pub fn match_trait_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool let method_call = ty::MethodCall::expr(expr.id); let trt_id = cx.tcx - .tables - .borrow() - .method_map - .get(&method_call) - .and_then(|callee| cx.tcx.trait_of_item(callee.def_id)); + .tables + .borrow() + .method_map + .get(&method_call) + .and_then(|callee| cx.tcx.trait_of_item(callee.def_id)); if let Some(trt_id) = trt_id { match_def_path(cx, trt_id, path) } else { @@ -208,9 +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 - .last() - .expect("A path must have at least one segment"), + QPath::Resolved(_, ref path) => { + path.segments + .last() + .expect("A path must have at least one segment") + }, QPath::TypeRelative(_, ref seg) => seg, } } @@ -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 { - TyPath(ref inner_path) => { - segments.len() > 0 && - match_path(inner_path, &segments[..(segments.len() - 1)]) && - segment.name == segments[segments.len() - 1] - }, - _ => false, + QPath::TypeRelative(ref ty, ref segment) => { + match ty.node { + TyPath(ref inner_path) => { + segments.len() > 0 && match_path(inner_path, &segments[..(segments.len() - 1)]) && + segment.name == segments[segments.len() - 1] + }, + _ => false, + } }, } } @@ -265,7 +269,10 @@ pub fn path_to_def(cx: &LateContext, path: &[&str]) -> Option { 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` which can be put inside the braces. -pub fn expr_block<'a, 'b, T: LintContext<'b>>(cx: &T, expr: &Expr, option: Option, default: &'a str) -> Cow<'a, str> { +pub fn expr_block<'a, 'b, T: LintContext<'b>>(cx: &T, expr: &Expr, option: Option, default: &'a str) + -> Cow<'a, str> { let code = snippet_block(cx, expr.span, default); let string = option.unwrap_or_default(); if let ExprBlock(_) = expr.node { @@ -416,32 +420,32 @@ pub fn trim_multiline(s: Cow, ignore_first: bool) -> Cow { fn trim_multiline_inner(s: Cow, ignore_first: bool, ch: char) -> Cow { let x = s.lines() - .skip(ignore_first as usize) - .filter_map(|l| { - if l.is_empty() { - None - } else { - // ignore empty lines - Some(l.char_indices() - .find(|&(_, x)| x != ch) - .unwrap_or((l.len(), ch)) - .0) - } - }) - .min() - .unwrap_or(0); + .skip(ignore_first as usize) + .filter_map(|l| { + if l.is_empty() { + None + } else { + // ignore empty lines + Some(l.char_indices() + .find(|&(_, x)| x != ch) + .unwrap_or((l.len(), ch)) + .0) + } + }) + .min() + .unwrap_or(0); if x > 0 { Cow::Owned(s.lines() - .enumerate() - .map(|(i, l)| { - if (ignore_first && i == 0) || l.is_empty() { - l - } else { - l.split_at(x).1 - } - }) - .collect::>() - .join("\n")) + .enumerate() + .map(|(i, l)| { + if (ignore_first && i == 0) || l.is_empty() { + l + } else { + l.split_at(x).1 + } + }) + .collect::>() + .join("\n")) } else { s } @@ -467,7 +471,7 @@ pub fn get_parent_expr<'c>(cx: &'c LateContext, e: &Expr) -> Option<&'c Expr> { pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, node: NodeId) -> Option<&'tcx Block> { let map = &cx.tcx.map; let enclosing_node = map.get_enclosing_scope(node) - .and_then(|enclosing_id| map.find(enclosing_id)); + .and_then(|enclosing_id| map.find(enclosing_id)); if let Some(node) = enclosing_node { match node { Node::NodeBlock(block) => Some(block), @@ -476,7 +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)); @@ -652,9 +652,9 @@ fn parse_attrs(sess: &Session, attrs: &[ast::Attribute], name: &' pub fn is_expn_of(cx: &LateContext, mut span: Span, name: &str) -> Option { loop { let span_name_span = cx.tcx - .sess - .codemap() - .with_expn_info(span.expn_id, |expn| expn.map(|ei| (ei.callee.name(), ei.call_site))); + .sess + .codemap() + .with_expn_info(span.expn_id, |expn| expn.map(|ei| (ei.callee.name(), ei.call_site))); match span_name_span { Some((mac_name, new_span)) if mac_name == name => return Some(new_span), @@ -673,9 +673,9 @@ pub fn is_expn_of(cx: &LateContext, mut span: Span, name: &str) -> Option /// `is_direct_expn_of`. pub fn is_direct_expn_of(cx: &LateContext, span: Span, name: &str) -> Option { let span_name_span = cx.tcx - .sess - .codemap() - .with_expn_info(span.expn_id, |expn| expn.map(|ei| (ei.callee.name(), ei.call_site))); + .sess + .codemap() + .with_expn_info(span.expn_id, |expn| expn.map(|ei| (ei.callee.name(), ei.call_site))); match span_name_span { Some((mac_name, new_span)) if mac_name == name => Some(new_span), @@ -709,11 +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); @@ -786,14 +783,17 @@ pub fn is_refutable(cx: &LateContext, pat: &Pat) -> bool { matches!(cx.tcx.tables().qpath_def(qpath, did), def::Def::Variant(..) | def::Def::VariantCtor(..)) } - fn are_refutable<'a, I: Iterator>(cx: &LateContext, mut i: I) -> bool { + fn are_refutable<'a, I: Iterator>(cx: &LateContext, mut i: I) -> bool { i.any(|pat| is_refutable(cx, pat)) } match pat.node { - PatKind::Binding(..) | PatKind::Wild => false, - PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => is_refutable(cx, pat), - PatKind::Lit(..) | PatKind::Range(..) => true, + PatKind::Binding(..) | + PatKind::Wild => false, + PatKind::Box(ref pat) | + PatKind::Ref(ref pat, _) => is_refutable(cx, pat), + PatKind::Lit(..) | + PatKind::Range(..) => true, PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.id), PatKind::Tuple(ref pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)), PatKind::Struct(ref qpath, ref fields, _) => { @@ -802,17 +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 { match def { - Def::Fn(id) | Def::Mod(id) | Def::Static(id, _) | - Def::Variant(id) | Def::VariantCtor(id, ..) | Def::Enum(id) | Def::TyAlias(id) | - Def::AssociatedTy(id) | Def::TyParam(id) | Def::Struct(id) | Def::StructCtor(id, ..) | - Def::Union(id) | Def::Trait(id) | Def::Method(id) | Def::Const(id) | - Def::AssociatedConst(id) | Def::Local(id) | Def::Upvar(id, ..) | Def::Macro(id) => { - Some(id) - } + Def::Fn(id) | + Def::Mod(id) | + Def::Static(id, _) | + Def::Variant(id) | + Def::VariantCtor(id, ..) | + Def::Enum(id) | + Def::TyAlias(id) | + Def::AssociatedTy(id) | + Def::TyParam(id) | + Def::Struct(id) | + Def::StructCtor(id, ..) | + Def::Union(id) | + Def::Trait(id) | + Def::Method(id) | + Def::Const(id) | + Def::AssociatedConst(id) | + Def::Local(id) | + Def::Upvar(id, ..) | + Def::Macro(id) => Some(id), - Def::Label(..) | - Def::PrimTy(..) | - Def::SelfTy(..) | - Def::Err => None, + Def::Label(..) | Def::PrimTy(..) | Def::SelfTy(..) | Def::Err => None, } } diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs index 347834a062a7..85f8623ab578 100644 --- a/clippy_lints/src/utils/sugg.rs +++ b/clippy_lints/src/utils/sugg.rs @@ -29,9 +29,9 @@ pub const ONE: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("1")); impl<'a> Display for Sugg<'a> { fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { match *self { - Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) | Sugg::BinOp(_, ref s) => { - s.fmt(f) - } + Sugg::NonParen(ref s) | + Sugg::MaybeParen(ref s) | + Sugg::BinOp(_, ref s) => s.fmt(f), } } } @@ -168,10 +168,12 @@ impl<'a> Sugg<'a> { match self { Sugg::NonParen(..) => self, // (x) and (x).y() both don't need additional parens - Sugg::MaybeParen(sugg) => if sugg.starts_with('(') && sugg.ends_with(')') { - Sugg::MaybeParen(sugg) - } else { - Sugg::NonParen(format!("({})", sugg).into()) + Sugg::MaybeParen(sugg) => { + if sugg.starts_with('(') && sugg.ends_with(')') { + Sugg::MaybeParen(sugg) + } else { + Sugg::NonParen(format!("({})", sugg).into()) + } }, Sugg::BinOp(_, sugg) => Sugg::NonParen(format!("({})", sugg).into()), } @@ -254,11 +256,9 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg, rhs: &Sugg) -> Sugg<'static> { /// `dir`. fn needs_paren(op: &AssocOp, other: &AssocOp, dir: Associativity) -> bool { other.precedence() < op.precedence() || - (other.precedence() == op.precedence() && - ((op != other && associativity(op) != dir) || - (op == other && associativity(op) != Associativity::Both))) || - is_shift(op) && is_arith(other) || - is_shift(other) && is_arith(op) + (other.precedence() == op.precedence() && + ((op != other && associativity(op) != dir) || (op == other && associativity(op) != Associativity::Both))) || + is_shift(op) && is_arith(other) || is_shift(other) && is_arith(op) } let lhs_paren = if let Sugg::BinOp(ref lop, _) = *lhs { @@ -276,24 +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, } } @@ -413,7 +400,7 @@ pub trait DiagnosticBuilderExt<'a, T: LintContext<'a>> { /// ```rust /// db.suggest_item_with_attr(cx, item, "#[derive(Default)]"); /// ``` - fn suggest_item_with_attr(&mut self, cx: &T, item: Span, msg: &str, attr: &D); + fn suggest_item_with_attr(&mut self, cx: &T, item: Span, msg: &str, attr: &D); /// Suggest to add an item before another. /// @@ -431,12 +418,9 @@ pub trait DiagnosticBuilderExt<'a, T: LintContext<'a>> { } impl<'a, 'b, 'c, T: LintContext<'c>> DiagnosticBuilderExt<'c, T> for rustc_errors::DiagnosticBuilder<'b> { - fn suggest_item_with_attr(&mut self, cx: &T, item: Span, msg: &str, attr: &D) { + fn suggest_item_with_attr(&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| { - if first { - first = false; - format!("{}\n", l) - } else { - format!("{}{}\n", indent, l) - } - }).collect::(); + let new_item = new_item.lines() + .map(|l| { + if first { + first = false; + format!("{}\n", l) + } else { + format!("{}{}\n", indent, l) + } + }) + .collect::(); self.span_suggestion(span, msg, format!("{}\n{}", new_item, indent)); } diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs index 1cfb57496f7a..dd3d4d261d05 100644 --- a/clippy_lints/src/vec.rs +++ b/clippy_lints/src/vec.rs @@ -65,7 +65,7 @@ fn check_vec_macro(cx: &LateContext, vec_args: &higher::VecArgs, span: Span) { } else { return; } - } + }, higher::VecArgs::Vec(args) => { if let Some(last) = args.iter().last() { let span = Span { @@ -78,7 +78,7 @@ fn check_vec_macro(cx: &LateContext, vec_args: &higher::VecArgs, span: Span) { } else { "&[]".into() } - } + }, }; span_lint_and_then(cx, USELESS_VEC, span, "useless use of `vec!`", |db| { From 44533f09aaf0ed7c9dd146305dc8140476633124 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 09:45:24 +0100 Subject: [PATCH 02/11] rustfmt round n --- clippy_lints/src/approx_const.rs | 4 ++- clippy_lints/src/loops.rs | 33 ++++++++++++------------ clippy_lints/src/methods.rs | 8 +++--- clippy_lints/src/misc.rs | 14 ++++++---- clippy_lints/src/non_expressive_names.rs | 4 +-- clippy_lints/src/regex.rs | 7 ++--- clippy_lints/src/transmute.rs | 29 +++++++++++---------- clippy_lints/src/types.rs | 10 ++----- clippy_lints/src/utils/mod.rs | 5 ++-- clippy_lints/src/utils/sugg.rs | 3 ++- 10 files changed, 59 insertions(+), 58 deletions(-) diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs index 3ccb5f6ef2a0..7131e609715b 100644 --- a/clippy_lints/src/approx_const.rs +++ b/clippy_lints/src/approx_const.rs @@ -85,7 +85,9 @@ fn check_known_consts(cx: &LateContext, e: &Expr, s: &symbol::Symbol, module: &s APPROX_CONSTANT, e.span, &format!("approximate value of `{}::consts::{}` found. \ - Consider using it directly", module, &name)); + Consider using it directly", + module, + &name)); return; } } diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 8fd694a1f630..e85d0f40c4b5 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -473,10 +473,10 @@ fn check_for_loop_range<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, ar expr.span, &format!("the loop variable `{}` is used to index `{}`", ident.node, indexed), |db| { - multispan_sugg(db, "consider using an iterator".to_string(), &[ - (pat.span, &format!("({}, )", ident.node)), - (arg.span, &format!("{}.iter().enumerate(){}{}", indexed, take, skip)), - ]); + multispan_sugg(db, + "consider using an iterator".to_string(), + &[(pat.span, &format!("({}, )", ident.node)), + (arg.span, &format!("{}.iter().enumerate(){}{}", indexed, take, skip))]); }); } else { let repl = if starts_at_zero && take.is_empty() { @@ -488,13 +488,14 @@ fn check_for_loop_range<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, ar span_lint_and_then(cx, NEEDLESS_RANGE_LOOP, expr.span, - &format!("the loop variable `{}` is only used to index `{}`.", ident.node, indexed), + &format!("the loop variable `{}` is only used to index `{}`.", + ident.node, + indexed), |db| { - multispan_sugg(db, "consider using an iterator".to_string(), &[ - (pat.span, ""), - (arg.span, &repl), - ]); - }); + multispan_sugg(db, + "consider using an iterator".to_string(), + &[(pat.span, ""), (arg.span, &repl)]); + }); } } } @@ -551,9 +552,9 @@ fn check_for_loop_reverse_range(cx: &LateContext, arg: &Expr, expr: &Expr) { "consider using the following if you are attempting to iterate over this \ range in reverse", format!("({end}{dots}{start}).rev()", - end=end_snippet, - dots=dots, - start=start_snippet)); + end = end_snippet, + dots = dots, + start = start_snippet)); }); } else if eq && limits != ast::RangeLimits::Closed { // if they are equal, it's also problematic - this loop @@ -597,9 +598,9 @@ fn check_for_loop_arg(cx: &LateContext, pat: &Pat, arg: &Expr, expr: &Expr) { EXPLICIT_INTO_ITER_LOOP, expr.span, &format!("it is more idiomatic to loop over `{}` instead of `{}.{}()`", - object, - object, - method_name)); + object, + object, + method_name)); } else if &*method_name.as_str() == "next" && match_trait_method(cx, arg, &paths::ITERATOR) { span_lint(cx, diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index d6f33cb1c855..5ecd1c06a5d8 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -776,10 +776,10 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir: span, &format!("use of `{}` followed by a function call", name), |db| { - db.span_suggestion(span, + db.span_suggestion(span, "try this", format!("{}.{}_{}({})", snippet(cx, self_expr.span, "_"), name, suffix, sugg)); - }); + }); } if args.len() == 2 { @@ -836,10 +836,10 @@ fn lint_vec_extend(cx: &LateContext, expr: &hir::Expr, args: &[hir::Expr]) { expr.span, "use of `extend` to extend a Vec by a slice", |db| { - db.span_suggestion(expr.span, + db.span_suggestion(expr.span, "try this", format!("{}.extend_from_slice({})", snippet(cx, args[0].span, "_"), slice)); - }); + }); } } diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index f1bce029e395..f796207a2239 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -159,7 +159,12 @@ pub struct Pass; impl LintPass for Pass { fn get_lints(&self) -> LintArray { - lint_array!(TOPLEVEL_REF_ARG, CMP_NAN, FLOAT_CMP, CMP_OWNED, MODULO_ONE, REDUNDANT_PATTERN, + lint_array!(TOPLEVEL_REF_ARG, + CMP_NAN, + FLOAT_CMP, + CMP_OWNED, + MODULO_ONE, + REDUNDANT_PATTERN, USED_UNDERSCORE_BINDING) } } @@ -285,7 +290,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { USED_UNDERSCORE_BINDING, expr.span, &format!("used binding `{}` which is prefixed with an underscore. A leading \ - underscore signals that a binding will not be used.", binding)); + underscore signals that a binding will not be used.", + binding)); } } @@ -295,9 +301,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { span_lint(cx, REDUNDANT_PATTERN, pat.span, - &format!("the `{} @ _` pattern can be written as just `{}`", - ident.node, - ident.node)); + &format!("the `{} @ _` pattern can be written as just `{}`", ident.node, ident.node)); } } } diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs index f7005b6169b0..fd8ffb36d462 100644 --- a/clippy_lints/src/non_expressive_names.rs +++ b/clippy_lints/src/non_expressive_names.rs @@ -210,8 +210,8 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> { diag.span_help(span, &format!("separate the discriminating character by an \ underscore like: `{}_{}`", - &interned_name[..split], - &interned_name[split..])); + &interned_name[..split], + &interned_name[split..])); } }); return; diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs index a390a8ee47c4..31ac194ca7bf 100644 --- a/clippy_lints/src/regex.rs +++ b/clippy_lints/src/regex.rs @@ -219,8 +219,7 @@ fn check_regex(cx: &LateContext, expr: &Expr, utf8: bool) { span_lint(cx, INVALID_REGEX, str_span(expr.span, r, e.position()), - &format!("regex syntax error: {}", - e.description())); + &format!("regex syntax error: {}", e.description())); }, } } @@ -239,9 +238,7 @@ fn check_regex(cx: &LateContext, expr: &Expr, utf8: bool) { span_lint(cx, INVALID_REGEX, expr.span, - &format!("regex syntax error on position {}: {}", - e.position(), - e.description())); + &format!("regex syntax error on position {}: {}", e.position(), e.description())); }, } } diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index 7364e798ddba..5e01f891eb17 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -144,25 +144,26 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute { CROSSPOINTER_TRANSMUTE, e.span, &format!("transmute from a type (`{}`) to the type that it points to (`{}`)", - from_ty, - to_ty)) + from_ty, + to_ty)) }, (_, &TyRawPtr(to_ptr)) if to_ptr.ty == from_ty => { span_lint(cx, CROSSPOINTER_TRANSMUTE, e.span, &format!("transmute from a type (`{}`) to a pointer to that type (`{}`)", - from_ty, - to_ty)) + from_ty, + to_ty)) }, - (&TyRawPtr(from_pty), &TyRef(_, to_rty)) => span_lint_and_then( - cx, - TRANSMUTE_PTR_TO_REF, - e.span, - &format!("transmute from a pointer type (`{}`) to a reference type (`{}`)", - from_ty, - to_ty), - |db| { + (&TyRawPtr(from_pty), &TyRef(_, to_rty)) => { + span_lint_and_then(cx, + TRANSMUTE_PTR_TO_REF, + e.span, + &format!("transmute from a pointer type (`{}`) to a reference type \ + (`{}`)", + from_ty, + to_ty), + |db| { let arg = sugg::Sugg::hir(cx, &args[0], ".."); let (deref, cast) = if to_rty.mutbl == Mutability::MutMutable { ("&mut *", "*mut") @@ -177,8 +178,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute { }; db.span_suggestion(e.span, "try", sugg::make_unop(deref, arg).to_string()); - }, - ), + }) + }, _ => return, }; } diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 50f3529d6787..2ef66cf76447 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -352,11 +352,7 @@ fn span_precision_loss_lint(cx: &LateContext, expr: &Expr, cast_from: &ty::TyS, &format!("casting {0} to {1} causes a loss of precision {2}({0} is {3} bits wide, but {1}'s mantissa \ is only {4} bits wide)", cast_from, - if cast_to_f64 { - "f64" - } else { - "f32" - }, + if cast_to_f64 { "f64" } else { "f32" }, if arch_dependent { arch_dependent_str } else { @@ -687,9 +683,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CharLitAsU8 { let msg = "casting character literal to u8. `char`s \ are 4 bytes wide in rust, so casting to u8 \ truncates them"; - let help = format!("Consider using a byte literal \ - instead:\nb{}", - snippet(cx, e.span, "'x'")); + let help = format!("Consider using a byte literal instead:\nb{}", snippet(cx, e.span, "'x'")); span_help_and_lint(cx, CHAR_LIT_AS_U8, expr.span, msg, &help); } } diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index ec98bfb3d680..e56574c9ba93 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -500,7 +500,7 @@ impl<'a> DiagnosticWrapper<'a> { fn wiki_link(&mut self, lint: &'static Lint) { if env::var("CLIPPY_DISABLE_WIKI_LINKS").is_err() { self.0.help(&format!("for further information visit https://github.com/Manishearth/rust-clippy/wiki#{}", - lint.name_lower())); + lint.name_lower())); } } } @@ -780,7 +780,8 @@ pub fn is_copy<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, env: Node /// Return whether a pattern is refutable. pub fn is_refutable(cx: &LateContext, pat: &Pat) -> bool { fn is_enum_variant(cx: &LateContext, qpath: &QPath, did: NodeId) -> bool { - matches!(cx.tcx.tables().qpath_def(qpath, did), def::Def::Variant(..) | def::Def::VariantCtor(..)) + matches!(cx.tcx.tables().qpath_def(qpath, did), + def::Def::Variant(..) | def::Def::VariantCtor(..)) } fn are_refutable<'a, I: Iterator>(cx: &LateContext, mut i: I) -> bool { diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs index 85f8623ab578..f3f0337a017d 100644 --- a/clippy_lints/src/utils/sugg.rs +++ b/clippy_lints/src/utils/sugg.rs @@ -249,7 +249,8 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg, rhs: &Sugg) -> Sugg<'static> { /// Whether the operator is a arithmetic operator (`+`, `-`, `*`, `/`, `%`). fn is_arith(op: &AssocOp) -> bool { - matches!(*op, AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | AssocOp::Modulus) + matches!(*op, + AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | AssocOp::Modulus) } /// Whether the operator `op` needs parenthesis with the operator `other` in the direction From 299d7be132584b17c17dd72309605131a8ed9c21 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 10:00:13 +0100 Subject: [PATCH 03/11] rustfmt fallout in doc comments --- clippy_lints/src/collapsible_if.rs | 8 +++---- clippy_lints/src/utils/mod.rs | 38 +++++++++++++++++------------- clippy_lints/src/utils/sugg.rs | 4 ++-- 3 files changed, 27 insertions(+), 23 deletions(-) diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs index 83b87dc74b0f..85bd419df732 100644 --- a/clippy_lints/src/collapsible_if.rs +++ b/clippy_lints/src/collapsible_if.rs @@ -2,7 +2,7 @@ //! //! For example, the lint would catch: //! -//! ```rust +//! ```rust,ignore //! if x { //! if y { //! println!("Hello world"); @@ -28,7 +28,7 @@ use utils::sugg::Sugg; /// **Known problems:** None. /// /// **Example:** -/// ```rust +/// ```rust,ignore /// if x { /// if y { /// … @@ -48,7 +48,7 @@ use utils::sugg::Sugg; /// /// Should be written: /// -/// ```rust +/// ```rust.ignore /// if x && y { /// … /// } @@ -140,7 +140,7 @@ fn check_collapsible_no_if_let(cx: &EarlyContext, expr: &ast::Expr, check: &ast: }} } -/// If the block contains only one expression, returns it. +/// If the block contains only one expression, return it. fn expr_block(block: &ast::Block) -> Option<&ast::Expr> { let mut it = block.stmts.iter(); diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index e56574c9ba93..f31ce3706ebf 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -35,23 +35,27 @@ pub type MethodArgs = HirVec>; /// Produce a nested chain of if-lets and ifs from the patterns: /// -/// if_let_chain! {[ -/// let Some(y) = x, -/// y.len() == 2, -/// let Some(z) = y, -/// ], { -/// block -/// }} +/// ```rust,ignore +/// if_let_chain! {[ +/// let Some(y) = x, +/// y.len() == 2, +/// let Some(z) = y, +/// ], { +/// block +/// }} +/// ``` /// /// becomes /// -/// if let Some(y) = x { -/// if y.len() == 2 { -/// if let Some(z) = y { -/// block -/// } +/// ```rust,ignore +/// if let Some(y) = x { +/// if y.len() == 2 { +/// if let Some(z) = y { +/// block /// } /// } +/// } +/// ``` #[macro_export] macro_rules! if_let_chain { ([let $pat:pat = $expr:expr, $($tt:tt)+], $block:block) => { @@ -135,7 +139,7 @@ pub fn in_external_macro<'a, T: LintContext<'a>>(cx: &T, span: Span) -> bool { /// Check if a `DefId`'s path matches the given absolute type path usage. /// /// # Examples -/// ``` +/// ```rust,ignore /// match_def_path(cx, id, &["core", "option", "Option"]) /// ``` /// @@ -229,7 +233,7 @@ pub fn single_segment_path(path: &QPath) -> Option<&PathSegment> { /// Match a `Path` against a slice of segment string literals. /// /// # Examples -/// ``` +/// ```rust,ignore /// match_path(path, &["std", "rt", "begin_unwind"]) /// ``` pub fn match_path(path: &QPath, segments: &[&str]) -> bool { @@ -254,7 +258,7 @@ pub fn match_path_old(path: &Path, segments: &[&str]) -> bool { /// Match a `Path` against a slice of segment string literals, e.g. /// /// # Examples -/// ``` +/// ```rust,ignore /// match_path(path, &["std", "rt", "begin_unwind"]) /// ``` pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool { @@ -371,7 +375,7 @@ pub fn get_item_name(cx: &LateContext, expr: &Expr) -> Option { /// Convert a span to a code snippet if available, otherwise use default. /// /// # Example -/// ``` +/// ```rust,ignore /// snippet(cx, expr.span, "..") /// ``` pub fn snippet<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> { @@ -388,7 +392,7 @@ pub fn snippet_opt<'a, T: LintContext<'a>>(cx: &T, span: Span) -> Option /// things which need to be printed as such. /// /// # Example -/// ``` +/// ```rust,ignore /// snippet(cx, expr.span, "..") /// ``` pub fn snippet_block<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> { diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs index f3f0337a017d..e4938f1c1edc 100644 --- a/clippy_lints/src/utils/sugg.rs +++ b/clippy_lints/src/utils/sugg.rs @@ -398,7 +398,7 @@ pub trait DiagnosticBuilderExt<'a, T: LintContext<'a>> { /// /// # Example /// - /// ```rust + /// ```rust,ignore /// db.suggest_item_with_attr(cx, item, "#[derive(Default)]"); /// ``` fn suggest_item_with_attr(&mut self, cx: &T, item: Span, msg: &str, attr: &D); @@ -409,7 +409,7 @@ pub trait DiagnosticBuilderExt<'a, T: LintContext<'a>> { /// /// # Example /// - /// ```rust + /// ```rust,ignore /// db.suggest_prepend_item(cx, item, /// "fn foo() { /// bar(); From ed9d71f2c9ff058f1b3ae02b8b7351dcace97190 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 10:25:14 +0100 Subject: [PATCH 04/11] remove nondeterminism by adjusting thresholds --- clippy_lints/src/array_indexing.rs | 5 ++- clippy_lints/src/attrs.rs | 14 ++++---- clippy_lints/src/copies.rs | 3 +- clippy_lints/src/derive.rs | 4 +-- clippy_lints/src/doc.rs | 4 ++- clippy_lints/src/entry.rs | 2 +- clippy_lints/src/enum_variants.rs | 12 ++++--- clippy_lints/src/escape.rs | 6 ++-- clippy_lints/src/eval_order_dependence.rs | 3 +- clippy_lints/src/functions.rs | 12 ++++--- clippy_lints/src/let_if_seq.rs | 2 +- clippy_lints/src/lifetimes.rs | 6 ++-- clippy_lints/src/loops.rs | 28 +++++++-------- clippy_lints/src/matches.rs | 11 +++--- clippy_lints/src/methods.rs | 34 ++++++++++--------- clippy_lints/src/misc_early.rs | 10 +++--- clippy_lints/src/missing_doc.rs | 5 ++- clippy_lints/src/needless_bool.rs | 24 ++++++------- clippy_lints/src/new_without_default.rs | 6 ++-- clippy_lints/src/non_expressive_names.rs | 6 ++-- .../src/overflow_check_conditional.rs | 12 ++++--- clippy_lints/src/shadow.rs | 20 +++++------ clippy_lints/src/strings.rs | 8 ++--- clippy_lints/src/types.rs | 8 +++-- clippy_lints/src/unused_label.rs | 6 ++-- clippy_lints/src/utils/conf.rs | 2 +- clippy_lints/src/utils/inspector.rs | 3 +- clippy_lints/src/utils/mod.rs | 9 +++-- rustfmt.toml | 4 +++ src/main.rs | 21 +++++++----- 30 files changed, 157 insertions(+), 133 deletions(-) diff --git a/clippy_lints/src/array_indexing.rs b/clippy_lints/src/array_indexing.rs index 3387f68d93b6..aa9af2e681d4 100644 --- a/clippy_lints/src/array_indexing.rs +++ b/clippy_lints/src/array_indexing.rs @@ -107,9 +107,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing { } /// Returns an option containing a tuple with the start and end (exclusive) of the range. -fn to_const_range(start: Option>, end: Option>, limits: RangeLimits, - array_size: ConstInt) - -> Option<(ConstInt, ConstInt)> { +fn to_const_range(start: Option>, end: Option>, limits: RangeLimits, array_size: ConstInt) + -> Option<(ConstInt, ConstInt)> { let start = match start { Some(Some(ConstVal::Integral(x))) => x, Some(_) => return None, diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index 528a62d7f020..24fd5a1483da 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -36,9 +36,11 @@ declare_lint! { /// **What it does:** Checks for `extern crate` and `use` items annotated with lint attributes /// -/// **Why is this bad?** Lint attributes have no effect on crate imports. Most likely a `!` was forgotten +/// **Why is this bad?** Lint attributes have no effect on crate imports. Most likely a `!` was +/// forgotten /// -/// **Known problems:** Technically one might allow `unused_import` on a `use` item, but it's easier to remove the unused item. +/// **Known problems:** Technically one might allow `unused_import` on a `use` item, +/// but it's easier to remove the unused item. /// /// **Example:** /// ```rust @@ -125,11 +127,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass { attr.span, "useless lint attribute", |db| { - sugg.insert(1, '!'); - db.span_suggestion(attr.span, - "if you just forgot a `!`, use", - sugg); - }); + sugg.insert(1, '!'); + db.span_suggestion(attr.span, "if you just forgot a `!`, use", sugg); + }); } } }, diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs index 5ef9f67a3b89..9a9b97d0e813 100644 --- a/clippy_lints/src/copies.rs +++ b/clippy_lints/src/copies.rs @@ -204,7 +204,8 @@ 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 + // 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)); diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index 463923136ff0..8836af28d095 100644 --- a/clippy_lints/src/derive.rs +++ b/clippy_lints/src/derive.rs @@ -169,7 +169,7 @@ fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, item: &Item, trait_ref item.span, "you are implementing `Clone` explicitly on a `Copy` type", |db| { - db.span_note(item.span, "consider deriving `Clone` or removing `Copy`"); - }); + db.span_note(item.span, "consider deriving `Clone` or removing `Copy`"); + }); } } diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs index 76e8f8670402..20c82ee46607 100644 --- a/clippy_lints/src/doc.rs +++ b/clippy_lints/src/doc.rs @@ -268,7 +268,9 @@ fn check_doc(cx: &EarlyContext, valid_idents: &[String], docs: &[(String, Span)] } lookup_parser = parser.clone(); - if let (Some((false, $c)), Some((false, $c))) = (lookup_parser.next(), lookup_parser.next()) { + let a = lookup_parser.next(); + let b = lookup_parser.next(); + if let (Some((false, $c)), Some((false, $c))) = (a, b) { let mut close_count = 3; while let Some((false, $c)) = lookup_parser.next() { close_count += 1; diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs index 657018a0ab97..2ff31b3a4fec 100644 --- a/clippy_lints/src/entry.rs +++ b/clippy_lints/src/entry.rs @@ -79,7 +79,7 @@ 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)> { + -> Option<(&'static str, &'b Expr, &'b Expr)> { if_let_chain! {[ let ExprMethodCall(ref name, _, ref params) = check.node, params.len() >= 2, diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs index ab47b7cffe23..e3bfca0b2f52 100644 --- a/clippy_lints/src/enum_variants.rs +++ b/clippy_lints/src/enum_variants.rs @@ -49,10 +49,13 @@ declare_lint! { /// **What it does:** Checks for modules that have the same name as their parent module /// -/// **Why is this bad?** A typical beginner mistake is to have `mod foo;` and again `mod foo { .. }` in `foo.rs`. -/// The expectation is that items inside the inner `mod foo { .. }` are then available +/// **Why is this bad?** A typical beginner mistake is to have `mod foo;` and again `mod foo { .. +/// }` in `foo.rs`. +/// The expectation is that items inside the inner `mod foo { .. }` are then +/// available /// through `foo::x`, but they are only available through `foo::foo::x`. -/// If this is done on purpose, it would be better to choose a more representative module name. +/// If this is done on purpose, it would be better to choose a more +/// representative module name. /// /// **Known problems:** None. /// @@ -111,8 +114,7 @@ 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; } diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index 17ff2613ddae..d66c8757ef2d 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -61,8 +61,10 @@ 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); diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs index d975a88f7ab3..f83b3271d506 100644 --- a/clippy_lints/src/eval_order_dependence.rs +++ b/clippy_lints/src/eval_order_dependence.rs @@ -146,7 +146,8 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> { } }, _ => { - // do not lint expressions referencing objects of type `!`, as that required a diverging expression to begin with + // do not lint expressions referencing objects of type `!`, as that required a diverging expression + // to begin with }, } self.maybe_walk_expr(e); diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index 801532a1c3b2..58425ff2a401 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -69,8 +69,10 @@ 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)) { @@ -124,8 +126,10 @@ 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::>(); diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs index 786420bbe659..c6efc3fd736d 100644 --- a/clippy_lints/src/let_if_seq.rs +++ b/clippy_lints/src/let_if_seq.rs @@ -150,7 +150,7 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for UsedVisitor<'a, 'tcx> { } fn check_assign<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, decl: hir::def_id::DefId, block: &'tcx hir::Block) - -> Option<&'tcx hir::Expr> { + -> Option<&'tcx hir::Expr> { if_let_chain! {[ block.expr.is_none(), let Some(expr) = block.stmts.iter().last(), diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index 081345a09e69..e9f93d043604 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -116,10 +116,8 @@ fn check_fn_inner<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl, gene report_extra_lifetimes(cx, decl, generics); } -fn could_use_elision<'a, 'tcx: 'a, T: Iterator>(cx: &LateContext<'a, 'tcx>, - func: &'tcx FnDecl, - named_lts: &'tcx [LifetimeDef], bounds_lts: T) - -> bool { +fn could_use_elision<'a, 'tcx: 'a, T: Iterator>(cx: &LateContext<'a, 'tcx>, func: &'tcx FnDecl, 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 diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index e85d0f40c4b5..3a7012972ba1 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -351,11 +351,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { expr.span, "this loop could be written as a `while let` loop", |db| { - let sug = format!("while let {} = {} {{ .. }}", - snippet(cx, arms[0].pats[0].span, ".."), - snippet(cx, matchexpr.span, "..")); - db.span_suggestion(expr.span, "try", sug); - }); + let sug = format!("while let {} = {} {{ .. }}", + snippet(cx, arms[0].pats[0].span, ".."), + snippet(cx, matchexpr.span, "..")); + db.span_suggestion(expr.span, "try", sug); + }); } }, _ => (), @@ -379,10 +379,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { expr.span, "this loop could be written as a `for` loop", |db| { - db.span_suggestion(expr.span, - "try", - format!("for {} in {} {{ .. }}", loop_var, iterator)); - }); + db.span_suggestion(expr.span, "try", format!("for {} in {} {{ .. }}", loop_var, iterator)); + }); } } } @@ -473,11 +471,11 @@ fn check_for_loop_range<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, ar expr.span, &format!("the loop variable `{}` is used to index `{}`", ident.node, indexed), |db| { - multispan_sugg(db, + multispan_sugg(db, "consider using an iterator".to_string(), &[(pat.span, &format!("({}, )", ident.node)), (arg.span, &format!("{}.iter().enumerate(){}{}", indexed, take, skip))]); - }); + }); } else { let repl = if starts_at_zero && take.is_empty() { format!("&{}", indexed) @@ -492,10 +490,10 @@ fn check_for_loop_range<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, ar ident.node, indexed), |db| { - multispan_sugg(db, - "consider using an iterator".to_string(), - &[(pat.span, ""), (arg.span, &repl)]); - }); + multispan_sugg(db, + "consider using an iterator".to_string(), + &[(pat.span, ""), (arg.span, &repl)]); + }); } } } diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index e1216c8493ba..b1b52cfb0153 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -322,10 +322,10 @@ fn check_match_ref_pats(cx: &LateContext, ex: &Expr, arms: &[Arm], source: Match expr.span, "you don't need to add `&` to both the expression and the patterns", |db| { - let inner = Sugg::hir(cx, inner, ".."); - let template = match_template(expr.span, source, inner); - db.span_suggestion(expr.span, "try", template); - }); + let inner = Sugg::hir(cx, inner, ".."); + let template = match_template(expr.span, source, inner); + db.span_suggestion(expr.span, "try", template); + }); } else { span_lint_and_then(cx, MATCH_REF_PATS, @@ -335,8 +335,7 @@ fn check_match_ref_pats(cx: &LateContext, ex: &Expr, arms: &[Arm], source: Match let ex = Sugg::hir(cx, ex, ".."); let template = match_template(expr.span, source, ex.deref()); db.span_suggestion(expr.span, - "instead of prefixing all patterns with `&`, you can \ - dereference the expression", + "instead of prefixing all patterns with `&`, you can dereference the expression", template); }); } diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index 5ecd1c06a5d8..ebb90c9eef08 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -695,9 +695,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { /// Checks for the `OR_FUN_CALL` lint. fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir::Expr]) { /// Check for `unwrap_or(T::new())` or `unwrap_or(T::default())`. - fn check_unwrap_or_default(cx: &LateContext, name: &str, fun: &hir::Expr, self_expr: &hir::Expr, arg: &hir::Expr, - or_has_args: bool, span: Span) - -> bool { + fn check_unwrap_or_default( + cx: &LateContext, name: &str, fun: &hir::Expr, self_expr: &hir::Expr, arg: &hir::Expr, or_has_args: bool, + span: Span + ) -> bool { if or_has_args { return false; } @@ -721,11 +722,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; } } @@ -736,8 +736,10 @@ 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) { @@ -776,10 +778,10 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir: span, &format!("use of `{}` followed by a function call", name), |db| { - db.span_suggestion(span, + db.span_suggestion(span, "try this", format!("{}.{}_{}({})", snippet(cx, self_expr.span, "_"), name, suffix, sugg)); - }); + }); } if args.len() == 2 { @@ -836,10 +838,10 @@ fn lint_vec_extend(cx: &LateContext, expr: &hir::Expr, args: &[hir::Expr]) { expr.span, "use of `extend` to extend a Vec by a slice", |db| { - db.span_suggestion(expr.span, + db.span_suggestion(expr.span, "try this", format!("{}.extend_from_slice({})", snippet(cx, args[0].span, "_"), slice)); - }); + }); } } @@ -1223,8 +1225,8 @@ fn lint_single_char_pattern(cx: &LateContext, expr: &hir::Expr, arg: &hir::Expr) arg.span, "single-character string constant used as pattern", |db| { - db.span_suggestion(expr.span, "try using a char instead:", hint); - }); + db.span_suggestion(expr.span, "try using a char instead:", hint); + }); } } } diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs index 9d9f30c820c9..bccc11640473 100644 --- a/clippy_lints/src/misc_early.rs +++ b/clippy_lints/src/misc_early.rs @@ -277,11 +277,11 @@ impl EarlyLintPass for MiscEarly { expr.span, "Try not to call a closure in the expression where it is declared.", |db| { - if decl.inputs.is_empty() { - let hint = snippet(cx, block.span, "..").into_owned(); - db.span_suggestion(expr.span, "Try doing something like: ", hint); - } - }); + if decl.inputs.is_empty() { + let hint = snippet(cx, block.span, "..").into_owned(); + db.span_suggestion(expr.span, "Try doing something like: ", hint); + } + }); } } }, diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs index 403c6ddcbdf7..70696ea3908b 100644 --- a/clippy_lints/src/missing_doc.rs +++ b/clippy_lints/src/missing_doc.rs @@ -14,7 +14,10 @@ // 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 +// [`missing_doc`]: +// https://github. +// com/rust-lang/rust/blob/d6d05904697d89099b55da3331155392f1db9c00/src/librustc_lint/builtin. +// rs#L246 // use rustc::hir; diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs index 9a0d5f1bb36b..5eae3034aff3 100644 --- a/clippy_lints/src/needless_bool.rs +++ b/clippy_lints/src/needless_bool.rs @@ -75,8 +75,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool { e.span, "this if-then-else expression returns a bool literal", |db| { - db.span_suggestion(e.span, "you can reduce it to", hint); - }); + db.span_suggestion(e.span, "you can reduce it to", hint); + }); }; match (fetch_bool_block(then_block), fetch_bool_expr(else_expr)) { (RetBool(true), RetBool(true)) | @@ -124,8 +124,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison { e.span, "equality checks against true are unnecessary", |db| { - db.span_suggestion(e.span, "try simplifying it as shown:", hint); - }); + db.span_suggestion(e.span, "try simplifying it as shown:", hint); + }); }, (Other, Bool(true)) => { let hint = snippet(cx, left_side.span, "..").into_owned(); @@ -134,8 +134,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison { e.span, "equality checks against true are unnecessary", |db| { - db.span_suggestion(e.span, "try simplifying it as shown:", hint); - }); + db.span_suggestion(e.span, "try simplifying it as shown:", hint); + }); }, (Bool(false), Other) => { let hint = Sugg::hir(cx, right_side, ".."); @@ -144,10 +144,8 @@ 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, ".."); @@ -156,10 +154,8 @@ 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()); + }); }, _ => (), } diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs index 4c9ff3288962..2a75a19dd28c 100644 --- a/clippy_lints/src/new_without_default.rs +++ b/clippy_lints/src/new_without_default.rs @@ -90,8 +90,10 @@ 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; } diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs index fd8ffb36d462..a195673a53bc 100644 --- a/clippy_lints/src/non_expressive_names.rs +++ b/clippy_lints/src/non_expressive_names.rs @@ -241,7 +241,8 @@ impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> { if let Some(ref init) = local.init { self.apply(|this| walk_expr(this, &**init)); } - // add the pattern after the expression because the bindings aren't available yet in the init expression + // add the pattern after the expression because the bindings aren't available yet in the init + // expression SimilarNamesNameVisitor(self).visit_pat(&*local.pat); } fn visit_block(&mut self, blk: &'tcx Block) { @@ -249,7 +250,8 @@ impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> { } fn visit_arm(&mut self, arm: &'tcx Arm) { self.apply(|this| { - // just go through the first pattern, as either all patterns bind the same bindings or rustc would have errored much earlier + // just go through the first pattern, as either all patterns + // bind the same bindings or rustc would have errored much earlier SimilarNamesNameVisitor(this).visit_pat(&arm.pats[0]); this.apply(|this| walk_expr(this, &arm.body)); }); diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs index a09ff3bebf68..f2e478865497 100644 --- a/clippy_lints/src/overflow_check_conditional.rs +++ b/clippy_lints/src/overflow_check_conditional.rs @@ -44,12 +44,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OverflowCheckConditional { ], { if let BinOp_::BiLt = op.node { if let BinOp_::BiAdd = op2.node { - span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C overflow conditions that will fail in Rust."); + span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, + "You are trying to use classic C overflow conditions that will fail in Rust."); } } if let BinOp_::BiGt = op.node { if let BinOp_::BiSub = op2.node { - span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C underflow conditions that will fail in Rust."); + span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, + "You are trying to use classic C underflow conditions that will fail in Rust."); } } }} @@ -66,12 +68,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OverflowCheckConditional { ], { if let BinOp_::BiGt = op.node { if let BinOp_::BiAdd = op2.node { - span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C overflow conditions that will fail in Rust."); + span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, + "You are trying to use classic C overflow conditions that will fail in Rust."); } } if let BinOp_::BiLt = op.node { if let BinOp_::BiSub = op2.node { - span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C underflow conditions that will fail in Rust."); + span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, + "You are trying to use classic C underflow conditions that will fail in Rust."); } } }} diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs index 9961a26b5c49..36fd33b22ce4 100644 --- a/clippy_lints/src/shadow.rs +++ b/clippy_lints/src/shadow.rs @@ -233,8 +233,8 @@ fn lint_shadow<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, name: Name, span: Span, snippet(cx, pattern_span, "_"), snippet(cx, expr.span, "..")), |db| { - db.span_note(prev_span, "previous binding is here"); - }); + db.span_note(prev_span, "previous binding is here"); + }); } else if contains_self(cx, name, expr) { span_lint_and_then(cx, SHADOW_REUSE, @@ -243,9 +243,9 @@ fn lint_shadow<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, name: Name, span: Span, snippet(cx, pattern_span, "_"), snippet(cx, expr.span, "..")), |db| { - db.span_note(expr.span, "initialization happens here"); - db.span_note(prev_span, "previous binding is here"); - }); + db.span_note(expr.span, "initialization happens here"); + db.span_note(prev_span, "previous binding is here"); + }); } else { span_lint_and_then(cx, SHADOW_UNRELATED, @@ -254,9 +254,9 @@ fn lint_shadow<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, name: Name, span: Span, snippet(cx, pattern_span, "_"), snippet(cx, expr.span, "..")), |db| { - db.span_note(expr.span, "initialization happens here"); - db.span_note(prev_span, "previous binding is here"); - }); + db.span_note(expr.span, "initialization happens here"); + db.span_note(prev_span, "previous binding is here"); + }); } } else { @@ -265,8 +265,8 @@ fn lint_shadow<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, name: Name, span: Span, span, &format!("`{}` shadows a previous declaration", snippet(cx, pattern_span, "_")), |db| { - db.span_note(prev_span, "previous binding is here"); - }); + db.span_note(prev_span, "previous binding is here"); + }); } } diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs index 844fd9482ff9..195b49c72f68 100644 --- a/clippy_lints/src/strings.rs +++ b/clippy_lints/src/strings.rs @@ -152,11 +152,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StringLitAsBytes { e.span, "calling `as_bytes()` on a string literal", |db| { - let sugg = format!("b{}", snippet(cx, args[0].span, r#""foo""#)); - db.span_suggestion(e.span, - "consider using a byte string literal instead", - sugg); - }); + let sugg = format!("b{}", snippet(cx, args[0].span, r#""foo""#)); + db.span_suggestion(e.span, "consider using a byte string literal instead", sugg); + }); } } diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 2ef66cf76447..e3a9758d2b72 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -741,7 +741,7 @@ enum AbsurdComparisonResult { fn detect_absurd_comparison<'a>(cx: &LateContext, op: BinOp_, lhs: &'a Expr, rhs: &'a Expr) - -> Option<(ExtremeExpr<'a>, AbsurdComparisonResult)> { + -> Option<(ExtremeExpr<'a>, AbsurdComparisonResult)> { use types::ExtremeType::*; use types::AbsurdComparisonResult::*; use utils::comparisons::*; @@ -1007,8 +1007,10 @@ fn err_upcast_comparison(cx: &LateContext, span: &Span, expr: &Expr, always: boo } } -fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons::Rel, - lhs_bounds: Option<(FullInt, FullInt)>, lhs: &Expr, rhs: &Expr, invert: bool) { +fn upcast_comparison_bounds_err( + cx: &LateContext, span: &Span, rel: comparisons::Rel, lhs_bounds: Option<(FullInt, FullInt)>, lhs: &Expr, + rhs: &Expr, invert: bool +) { use utils::comparisons::*; if let Some((lb, ub)) = lhs_bounds { diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs index b58456ce85ed..ebb7735171ee 100644 --- a/clippy_lints/src/unused_label.rs +++ b/clippy_lints/src/unused_label.rs @@ -41,8 +41,10 @@ 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; } diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs index 0ba86ff55dc1..7c83a7f69a52 100644 --- a/clippy_lints/src/utils/conf.rs +++ b/clippy_lints/src/utils/conf.rs @@ -9,7 +9,7 @@ use toml; /// Get the configuration file from arguments. pub fn file_from_args(args: &[codemap::Spanned]) - -> Result, (&'static str, codemap::Span)> { + -> Result, (&'static str, codemap::Span)> { for arg in args.iter().filter_map(|a| a.meta_item()) { if arg.name() == "conf_file" { return match arg.node { diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index 83d96b8db61a..79cf15b6c5f5 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/clippy_lints/src/utils/inspector.rs @@ -73,7 +73,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { // } // } // - // fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, _: &hir::Generics) { + // fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, _: + // &hir::Generics) { // if !has_attr(&var.node.attrs) { // return; // } diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index f31ce3706ebf..dc25020d3fc9 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -317,9 +317,8 @@ pub fn get_trait_def_id(cx: &LateContext, path: &[&str]) -> Option { /// Check whether a type implements a trait. /// See also `get_trait_def_id`. -pub fn implements_trait<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, trait_id: DefId, - ty_params: Vec>) - -> bool { +pub fn implements_trait<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, trait_id: DefId, ty_params: Vec>) + -> bool { cx.tcx.populate_implementations_for_trait_if_necessary(trait_id); let ty = cx.tcx.erase_regions(&ty); @@ -403,7 +402,7 @@ 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` which can be put inside the braces. pub fn expr_block<'a, 'b, T: LintContext<'b>>(cx: &T, expr: &Expr, option: Option, default: &'a str) - -> Cow<'a, str> { + -> Cow<'a, str> { let code = snippet_block(cx, expr.span, default); let string = option.unwrap_or_default(); if let ExprBlock(_) = expr.node { @@ -758,7 +757,7 @@ pub fn return_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, fn_item: NodeId) -> ty::T // 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 { + -> 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); diff --git a/rustfmt.toml b/rustfmt.toml index 6daad2b65bd9..0d8362496c19 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -4,3 +4,7 @@ fn_args_density = "Compressed" fn_call_width = 80 fn_args_paren_newline = false match_block_trailing_comma = true +fn_args_layout = "Block" +closure_block_indent_threshold = 0 +fn_return_indent = "WithWhereClause" +wrap_comments = true diff --git a/src/main.rs b/src/main.rs index 89db653929c2..35153ebe8af3 100644 --- a/src/main.rs +++ b/src/main.rs @@ -38,19 +38,22 @@ impl ClippyCompilerCalls { } impl<'a> CompilerCalls<'a> for ClippyCompilerCalls { - fn early_callback(&mut self, matches: &getopts::Matches, sopts: &config::Options, cfg: &ast::CrateConfig, - descriptions: &rustc_errors::registry::Registry, output: ErrorOutputType) - -> Compilation { + fn early_callback( + &mut self, matches: &getopts::Matches, sopts: &config::Options, cfg: &ast::CrateConfig, + descriptions: &rustc_errors::registry::Registry, output: ErrorOutputType + ) -> Compilation { self.default.early_callback(matches, sopts, cfg, descriptions, output) } - fn no_input(&mut self, matches: &getopts::Matches, sopts: &config::Options, cfg: &ast::CrateConfig, - odir: &Option, ofile: &Option, descriptions: &rustc_errors::registry::Registry) - -> Option<(Input, Option)> { + fn no_input( + &mut self, matches: &getopts::Matches, sopts: &config::Options, cfg: &ast::CrateConfig, odir: &Option, + ofile: &Option, descriptions: &rustc_errors::registry::Registry + ) -> Option<(Input, Option)> { self.default.no_input(matches, sopts, cfg, odir, ofile, descriptions) } - fn late_callback(&mut self, matches: &getopts::Matches, sess: &Session, input: &Input, odir: &Option, - ofile: &Option) - -> Compilation { + fn late_callback( + &mut self, matches: &getopts::Matches, sess: &Session, input: &Input, odir: &Option, + ofile: &Option + ) -> Compilation { self.default.late_callback(matches, sess, input, odir, ofile) } fn build_controller(&mut self, sess: &Session, matches: &getopts::Matches) -> driver::CompileController<'a> { From 47eead5ada97f50af5e00426bc08f1dcbeb5d4d2 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 12:14:54 +0100 Subject: [PATCH 05/11] function definition style simplification --- clippy_lints/src/array_indexing.rs | 8 +++- clippy_lints/src/copies.rs | 6 ++- clippy_lints/src/derive.rs | 9 ++++- clippy_lints/src/entry.rs | 6 ++- clippy_lints/src/enum_variants.rs | 9 ++++- clippy_lints/src/escape.rs | 18 +++++++-- clippy_lints/src/functions.rs | 15 +++++-- clippy_lints/src/let_if_seq.rs | 7 +++- clippy_lints/src/lifetimes.rs | 8 +++- clippy_lints/src/loops.rs | 35 ++++++++++++---- clippy_lints/src/matches.rs | 9 ++++- clippy_lints/src/methods.rs | 23 +++++++++-- clippy_lints/src/misc.rs | 11 ++++- clippy_lints/src/new_without_default.rs | 9 ++++- clippy_lints/src/shadow.rs | 30 +++++++++++--- clippy_lints/src/types.rs | 28 ++++++++++--- clippy_lints/src/unused_label.rs | 9 ++++- clippy_lints/src/utils/mod.rs | 53 +++++++++++++++++++------ rustfmt.toml | 2 - 19 files changed, 231 insertions(+), 64 deletions(-) diff --git a/clippy_lints/src/array_indexing.rs b/clippy_lints/src/array_indexing.rs index aa9af2e681d4..de13c0264e50 100644 --- a/clippy_lints/src/array_indexing.rs +++ b/clippy_lints/src/array_indexing.rs @@ -107,8 +107,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing { } /// Returns an option containing a tuple with the start and end (exclusive) of the range. -fn to_const_range(start: Option>, end: Option>, limits: RangeLimits, array_size: ConstInt) - -> Option<(ConstInt, ConstInt)> { +fn to_const_range( + start: Option>, + end: Option>, + limits: RangeLimits, + array_size: ConstInt +) -> Option<(ConstInt, ConstInt)> { let start = match start { Some(Some(ConstVal::Integral(x))) => x, Some(_) => return None, diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs index 9a9b97d0e813..11b85edba3e6 100644 --- a/clippy_lints/src/copies.rs +++ b/clippy_lints/src/copies.rs @@ -248,7 +248,11 @@ fn if_sequence(mut expr: &Expr) -> (SmallVector<&Expr>, SmallVector<&Block>) { /// Return the list of bindings in a pattern. fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap> { - fn bindings_impl<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat, map: &mut HashMap>) { + fn bindings_impl<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + pat: &Pat, + map: &mut HashMap> + ) { match pat.node { PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => bindings_impl(cx, pat, map), diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index 8836af28d095..cda82f46434e 100644 --- a/clippy_lints/src/derive.rs +++ b/clippy_lints/src/derive.rs @@ -86,8 +86,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Derive { } /// Implementation of the `DERIVE_HASH_XOR_EQ` lint. -fn check_hash_peq<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, span: Span, trait_ref: &TraitRef, ty: ty::Ty<'tcx>, - hash_is_automatically_derived: bool) { +fn check_hash_peq<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + span: Span, + trait_ref: &TraitRef, + ty: ty::Ty<'tcx>, + hash_is_automatically_derived: bool +) { if_let_chain! {[ match_path_old(&trait_ref.path, &paths::HASH), let Some(peq_trait_def_id) = cx.tcx.lang_items.eq_trait() diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs index 2ff31b3a4fec..2fe53d8cacf4 100644 --- a/clippy_lints/src/entry.rs +++ b/clippy_lints/src/entry.rs @@ -78,8 +78,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for HashMapLint { } } -fn check_cond<'a, 'tcx, 'b>(cx: &'a LateContext<'a, 'tcx>, check: &'b Expr) - -> Option<(&'static str, &'b Expr, &'b Expr)> { +fn check_cond<'a, 'tcx, 'b>( + cx: &'a LateContext<'a, 'tcx>, + check: &'b Expr +) -> Option<(&'static str, &'b Expr, &'b Expr)> { if_let_chain! {[ let ExprMethodCall(ref name, _, ref params) = check.node, params.len() >= 2, diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs index e3bfca0b2f52..5ae3fcbb2a1e 100644 --- a/clippy_lints/src/enum_variants.rs +++ b/clippy_lints/src/enum_variants.rs @@ -114,7 +114,14 @@ fn partial_rmatch(post: &str, name: &str) -> usize { // FIXME: #600 #[allow(while_let_on_iterator)] -fn check_variant(cx: &EarlyContext, threshold: u64, def: &EnumDef, item_name: &str, item_name_chars: usize, span: Span) { +fn check_variant( + cx: &EarlyContext, + threshold: u64, + def: &EnumDef, + item_name: &str, + item_name_chars: usize, + span: Span +) { if (def.variants.len() as u64) < threshold { return; } diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index d66c8757ef2d..ee415b363824 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -62,7 +62,12 @@ 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, + &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); @@ -146,8 +151,15 @@ impl<'a, 'tcx: 'a + 'gcx, 'gcx: 'a> Delegate<'tcx> for EscapeDelegate<'a, 'tcx, } } - fn borrow(&mut self, borrow_id: NodeId, _: Span, cmt: cmt<'tcx>, _: &ty::Region, _: ty::BorrowKind, - loan_cause: LoanCause) { + fn borrow( + &mut self, + borrow_id: NodeId, + _: Span, + cmt: cmt<'tcx>, + _: &ty::Region, + _: ty::BorrowKind, + loan_cause: LoanCause + ) { use rustc::ty::adjustment::Adjust; if let Categorization::Local(lid) = cmt.cat { diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index 58425ff2a401..5ad676e57a08 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -70,8 +70,13 @@ 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 + &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::*; @@ -127,7 +132,11 @@ impl<'a, 'tcx> Functions { } fn check_raw_ptr( - &self, cx: &LateContext<'a, 'tcx>, unsafety: hir::Unsafety, decl: &'tcx hir::FnDecl, expr: &'tcx hir::Expr, + &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) { diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs index c6efc3fd736d..88d74b018863 100644 --- a/clippy_lints/src/let_if_seq.rs +++ b/clippy_lints/src/let_if_seq.rs @@ -149,8 +149,11 @@ 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(), diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index e9f93d043604..ba705a84089c 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -116,8 +116,12 @@ fn check_fn_inner<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl, gene report_extra_lifetimes(cx, decl, generics); } -fn could_use_elision<'a, 'tcx: 'a, T: Iterator>(cx: &LateContext<'a, 'tcx>, func: &'tcx FnDecl, named_lts: &'tcx [LifetimeDef], bounds_lts: T) - -> bool { +fn could_use_elision<'a, 'tcx: 'a, T: Iterator>( + cx: &LateContext<'a, 'tcx>, + func: &'tcx FnDecl, + 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 diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 3a7012972ba1..9a3defec72df 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -402,8 +402,13 @@ 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); @@ -413,8 +418,13 @@ fn check_for_loop<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, arg: &'t /// 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 { @@ -641,8 +651,12 @@ 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, @@ -687,8 +701,13 @@ fn check_for_loop_explicit_counter<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arg: &' } /// 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 { diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index b1b52cfb0153..978e9f5a029f 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -196,7 +196,14 @@ fn check_single_match_single_pattern(cx: &LateContext, ex: &Expr, arms: &[Arm], } } -fn check_single_match_opt_like(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr, ty: ty::Ty, els: Option<&Expr>) { +fn check_single_match_opt_like( + cx: &LateContext, + ex: &Expr, + arms: &[Arm], + expr: &Expr, + ty: ty::Ty, + els: Option<&Expr> +) { // list of candidate Enums we know will never get any more members let candidates = &[(&paths::COW, "Borrowed"), (&paths::COW, "Cow::Borrowed"), diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index ebb90c9eef08..591b395fe709 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -696,7 +696,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir::Expr]) { /// Check for `unwrap_or(T::new())` or `unwrap_or(T::default())`. fn check_unwrap_or_default( - cx: &LateContext, name: &str, fun: &hir::Expr, self_expr: &hir::Expr, arg: &hir::Expr, or_has_args: bool, + cx: &LateContext, + name: &str, + fun: &hir::Expr, + self_expr: &hir::Expr, + arg: &hir::Expr, + or_has_args: bool, span: Span ) -> bool { if or_has_args { @@ -737,7 +742,12 @@ 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, + 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 @@ -1157,8 +1167,13 @@ fn lint_filter_map_flat_map(cx: &LateContext, expr: &hir::Expr, _filter_args: &[ } /// lint searching an Iterator followed by `is_some()` -fn lint_search_is_some(cx: &LateContext, expr: &hir::Expr, search_method: &str, search_args: &[hir::Expr], - is_some_args: &[hir::Expr]) { +fn lint_search_is_some( + cx: &LateContext, + expr: &hir::Expr, + search_method: &str, + search_args: &[hir::Expr], + is_some_args: &[hir::Expr] +) { // lint if caller of search is an Iterator if match_trait_method(cx, &is_some_args[0], &paths::ITERATOR) { let msg = format!("called `is_some()` after searching an `Iterator` with {}. This is more succinctly \ diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index f796207a2239..409a7de86f06 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -170,8 +170,15 @@ 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; diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs index 2a75a19dd28c..9c7b132dd3d6 100644 --- a/clippy_lints/src/new_without_default.rs +++ b/clippy_lints/src/new_without_default.rs @@ -91,8 +91,13 @@ 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 + &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; diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs index 36fd33b22ce4..9c5b032f6251 100644 --- a/clippy_lints/src/shadow.rs +++ b/clippy_lints/src/shadow.rs @@ -80,8 +80,15 @@ 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; } @@ -143,8 +150,13 @@ 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) => { @@ -222,8 +234,14 @@ fn check_pat<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, init: Option< } } -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, diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index e3a9758d2b72..89bc46074fda 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -528,8 +528,15 @@ impl LintPass for TypeComplexityPass { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeComplexityPass { - fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, _: FnKind<'tcx>, decl: &'tcx FnDecl, _: &'tcx Expr, _: Span, - _: NodeId) { + fn check_fn( + &mut self, + cx: &LateContext<'a, 'tcx>, + _: FnKind<'tcx>, + decl: &'tcx FnDecl, + _: &'tcx Expr, + _: Span, + _: NodeId + ) { self.check_fndecl(cx, decl); } @@ -740,8 +747,12 @@ enum AbsurdComparisonResult { -fn detect_absurd_comparison<'a>(cx: &LateContext, op: BinOp_, lhs: &'a Expr, rhs: &'a Expr) - -> Option<(ExtremeExpr<'a>, AbsurdComparisonResult)> { +fn detect_absurd_comparison<'a>( + cx: &LateContext, + op: BinOp_, + lhs: &'a Expr, + rhs: &'a Expr +) -> Option<(ExtremeExpr<'a>, AbsurdComparisonResult)> { use types::ExtremeType::*; use types::AbsurdComparisonResult::*; use utils::comparisons::*; @@ -1008,8 +1019,13 @@ fn err_upcast_comparison(cx: &LateContext, span: &Span, expr: &Expr, always: boo } fn upcast_comparison_bounds_err( - cx: &LateContext, span: &Span, rel: comparisons::Rel, lhs_bounds: Option<(FullInt, FullInt)>, lhs: &Expr, - rhs: &Expr, invert: bool + cx: &LateContext, + span: &Span, + rel: comparisons::Rel, + lhs_bounds: Option<(FullInt, FullInt)>, + lhs: &Expr, + rhs: &Expr, + invert: bool ) { use utils::comparisons::*; diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs index ebb7735171ee..9017fd6933e8 100644 --- a/clippy_lints/src/unused_label.rs +++ b/clippy_lints/src/unused_label.rs @@ -42,8 +42,13 @@ 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 + &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; diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index dc25020d3fc9..77b33d7b5893 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -317,8 +317,12 @@ pub fn get_trait_def_id(cx: &LateContext, path: &[&str]) -> Option { /// Check whether a type implements a trait. /// See also `get_trait_def_id`. -pub fn implements_trait<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, trait_id: DefId, ty_params: Vec>) - -> bool { +pub fn implements_trait<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + ty: ty::Ty<'tcx>, + trait_id: DefId, + ty_params: Vec> +) -> bool { cx.tcx.populate_implementations_for_trait_if_necessary(trait_id); let ty = cx.tcx.erase_regions(&ty); @@ -401,8 +405,12 @@ pub fn snippet_block<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &' /// Like `snippet_block`, but add braces if the expr is not an `ExprBlock`. /// Also takes an `Option` which can be put inside the braces. -pub fn expr_block<'a, 'b, T: LintContext<'b>>(cx: &T, expr: &Expr, option: Option, default: &'a str) - -> Cow<'a, str> { +pub fn expr_block<'a, 'b, T: LintContext<'b>>( + cx: &T, + expr: &Expr, + option: Option, + 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 { @@ -515,8 +523,13 @@ pub fn span_lint<'a, T: LintContext<'a>>(cx: &T, lint: &'static Lint, sp: Span, } } -pub fn span_help_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(cx: &'a T, lint: &'static Lint, span: Span, msg: &str, - help: &str) { +pub fn span_help_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>( + cx: &'a T, + lint: &'static Lint, + span: Span, + msg: &str, + help: &str +) { let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, span, msg)); if cx.current_level(lint) != Level::Allow { db.0.help(help); @@ -524,8 +537,14 @@ 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 { @@ -537,9 +556,13 @@ pub fn span_note_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(cx: &'a T, lint: & } } -pub fn span_lint_and_then<'a, 'tcx: 'a, T: LintContext<'tcx>, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, - f: F) - where F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>) +pub fn span_lint_and_then<'a, 'tcx: 'a, T: LintContext<'tcx>, F>( + cx: &'a T, + lint: &'static Lint, + sp: Span, + msg: &str, + f: F +) where F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>) { let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, sp, msg)); if cx.current_level(lint) != Level::Allow { @@ -756,8 +779,12 @@ pub fn return_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, fn_item: NodeId) -> ty::T /// Check if two types are the same. // FIXME: this works correctly for lifetimes bounds (`for <'a> Foo<'a>` == `for <'b> Foo<'b>` but // not for type parameters. -pub fn same_tys<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, a: ty::Ty<'tcx>, b: ty::Ty<'tcx>, parameter_item: NodeId) - -> bool { +pub fn same_tys<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + a: ty::Ty<'tcx>, + b: ty::Ty<'tcx>, + parameter_item: NodeId +) -> bool { let parameter_env = ty::ParameterEnvironment::for_item(cx.tcx, parameter_item); cx.tcx.infer_ctxt(None, Some(parameter_env), Reveal::All).enter(|infcx| { let new_a = a.subst(infcx.tcx, infcx.parameter_environment.free_substs); diff --git a/rustfmt.toml b/rustfmt.toml index 0d8362496c19..18d146d49173 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -1,8 +1,6 @@ max_width = 120 ideal_width = 100 -fn_args_density = "Compressed" fn_call_width = 80 -fn_args_paren_newline = false match_block_trailing_comma = true fn_args_layout = "Block" closure_block_indent_threshold = 0 From 009c6d95d78e2bc852375a06fa13b59a0ea72534 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 12:30:41 +0100 Subject: [PATCH 06/11] manually fix the overlong lines --- clippy_lints/src/assign_ops.rs | 21 +++++++------- clippy_lints/src/lib.rs | 10 +++++-- clippy_lints/src/misc_early.rs | 19 ++++++++++-- clippy_lints/src/swap.rs | 15 ++++++++-- clippy_lints/src/utils/conf.rs | 29 ++++++++++++++----- .../absurd-extreme-comparisons.rs | 6 ++-- tests/compile-fail/block_in_if_condition.rs | 12 ++++---- 7 files changed, 77 insertions(+), 35 deletions(-) diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs index d42880f8b9fd..122a600d7d38 100644 --- a/clippy_lints/src/assign_ops.rs +++ b/clippy_lints/src/assign_ops.rs @@ -126,7 +126,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { return; // implements_trait does not work with generics } macro_rules! ops { - ($op:expr, $cx:expr, $ty:expr, $rty:expr, $($trait_name:ident:$full_trait_name:ident),+) => { + ($op:expr, + $cx:expr, + $ty:expr, + $rty:expr, + $($trait_name:ident:$full_trait_name:ident),+) => { match $op { $(hir::$full_trait_name => { let [krate, module] = ::utils::paths::OPS_MODULE; @@ -140,15 +144,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { let parent_fn = cx.tcx.map.get_parent(e.id); let parent_impl = cx.tcx.map.get_parent(parent_fn); // the crate node is the only one that is not in the map - if parent_impl != ast::CRATE_NODE_ID { - if let hir::map::Node::NodeItem(item) = cx.tcx.map.get(parent_impl) { - if let hir::Item_::ItemImpl(_, _, _, Some(ref trait_ref), _, _) = item.node { - if trait_ref.path.def.def_id() == trait_id { - return; - } - } - } - } + if_let_chain!{[ + parent_impl != ast::CRATE_NODE_ID, + let hir::map::Node::NodeItem(item) = cx.tcx.map.get(parent_impl), + let hir::Item_::ItemImpl(_, _, _, Some(ref trait_ref), _, _) = item.node, + trait_ref.path.def.def_id() == trait_id + ], { return; }} implements_trait($cx, $ty, trait_id, vec![$rty]) },)* _ => false, diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index c6852477a11a..e1d7e2e9e2c2 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -175,8 +175,10 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) { let mut store = reg.sess.lint_store.borrow_mut(); store.register_removed("unstable_as_slice", "`Vec::as_slice` has been stabilized in 1.7"); store.register_removed("unstable_as_mut_slice", "`Vec::as_mut_slice` has been stabilized in 1.7"); - store.register_removed("str_to_string", "using `str::to_string` is common even today and specialization will likely happen soon"); - store.register_removed("string_to_string", "using `string::to_string` is common even today and specialization will likely happen soon"); + store.register_removed("str_to_string", + "using `str::to_string` is common even today and specialization will likely happen soon"); + store.register_removed("string_to_string", + "using `string::to_string` is common even today and specialization will likely happen soon"); // end deprecated lints, do not remove this comment, it’s used in `update_lints` reg.register_late_lint_pass(box serde::Serde); @@ -229,7 +231,9 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) { reg.register_late_lint_pass(box map_clone::Pass); reg.register_late_lint_pass(box temporary_assignment::Pass); reg.register_late_lint_pass(box transmute::Transmute); - reg.register_late_lint_pass(box cyclomatic_complexity::CyclomaticComplexity::new(conf.cyclomatic_complexity_threshold)); + reg.register_late_lint_pass( + box cyclomatic_complexity::CyclomaticComplexity::new(conf.cyclomatic_complexity_threshold) + ); reg.register_late_lint_pass(box escape::Pass{too_large_for_stack: conf.too_large_for_stack}); reg.register_early_lint_pass(box misc_early::MiscEarly); reg.register_late_lint_pass(box array_indexing::ArrayIndexing); diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs index bccc11640473..e6f044ae9b6a 100644 --- a/clippy_lints/src/misc_early.rs +++ b/clippy_lints/src/misc_early.rs @@ -333,8 +333,16 @@ impl EarlyLintPass for MiscEarly { lit.span, "this is a decimal constant", |db| { - db.span_suggestion(lit.span, "if you mean to use a decimal constant, remove the `0` to remove confusion:", src[1..].to_string()); - db.span_suggestion(lit.span, "if you mean to use an octal constant, use `0o`:", format!("0o{}", &src[1..])); + db.span_suggestion( + lit.span, + "if you mean to use a decimal constant, remove the `0` to remove confusion:", + src[1..].to_string(), + ); + db.span_suggestion( + lit.span, + "if you mean to use an octal constant, use `0o`:", + format!("0o{}", &src[1..]), + ); }); } }} @@ -374,7 +382,12 @@ impl EarlyLintPass for MiscEarly { let ExprKind::Path(_, ref path) = closure.node ], { if sp_ident.node == (&path.segments[0]).identifier { - span_lint(cx, REDUNDANT_CLOSURE_CALL, second.span, "Closure called just once immediately after it was declared"); + span_lint( + cx, + REDUNDANT_CLOSURE_CALL, + second.span, + "Closure called just once immediately after it was declared", + ); } }} } diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs index 7393ee3890e5..8ed7e3558797 100644 --- a/clippy_lints/src/swap.rs +++ b/clippy_lints/src/swap.rs @@ -81,7 +81,11 @@ fn check_manual_swap(cx: &LateContext, block: &Block) { SpanlessEq::new(cx).ignore_fn().eq_expr(tmp_init, lhs1), SpanlessEq::new(cx).ignore_fn().eq_expr(rhs1, lhs2) ], { - fn check_for_slice<'a>(cx: &LateContext, lhs1: &'a Expr, lhs2: &'a Expr) -> Option<(&'a Expr, &'a Expr, &'a Expr)> { + fn check_for_slice<'a>( + cx: &LateContext, + lhs1: &'a Expr, + lhs2: &'a Expr, + ) -> Option<(&'a Expr, &'a Expr, &'a Expr)> { if let ExprIndex(ref lhs1, ref idx1) = lhs1.node { if let ExprIndex(ref lhs2, ref idx2) = lhs2.node { if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, lhs2) { @@ -104,7 +108,10 @@ fn check_manual_swap(cx: &LateContext, block: &Block) { if let Some(slice) = Sugg::hir_opt(cx, slice) { (false, format!(" elements of `{}`", slice), - format!("{}.swap({}, {})", slice.maybe_par(), snippet(cx, idx1.span, ".."), snippet(cx, idx2.span, ".."))) + format!("{}.swap({}, {})", + slice.maybe_par(), + snippet(cx, idx1.span, ".."), + snippet(cx, idx2.span, ".."))) } else { (false, "".to_owned(), "".to_owned()) } @@ -148,7 +155,9 @@ fn check_suspicious_swap(cx: &LateContext, block: &Block) { SpanlessEq::new(cx).ignore_fn().eq_expr(lhs0, rhs1), SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, rhs0) ], { - let (what, lhs, rhs) = if let (Some(first), Some(second)) = (Sugg::hir_opt(cx, lhs0), Sugg::hir_opt(cx, rhs0)) { + let lhs0 = Sugg::hir_opt(cx, lhs0); + let rhs0 = Sugg::hir_opt(cx, rhs0); + let (what, lhs, rhs) = if let (Some(first), Some(second)) = (lhs0, rhs0) { (format!(" `{}` and `{}`", first, second), first.mut_addr().to_string(), second.mut_addr().to_string()) } else { ("".to_owned(), "".to_owned(), "".to_owned()) diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs index 7c83a7f69a52..d80fa17e29f7 100644 --- a/clippy_lints/src/utils/conf.rs +++ b/clippy_lints/src/utils/conf.rs @@ -131,7 +131,12 @@ macro_rules! define_Conf { // how to read the value? (CONV i64, $value: expr) => { $value.as_integer() }; - (CONV u64, $value: expr) => { $value.as_integer().iter().filter_map(|&i| if i >= 0 { Some(i as u64) } else { None }).next() }; + (CONV u64, $value: expr) => { + $value.as_integer() + .iter() + .filter_map(|&i| if i >= 0 { Some(i as u64) } else { None }) + .next() + }; (CONV String, $value: expr) => { $value.as_str().map(Into::into) }; (CONV Vec, $value: expr) => {{ let slice = $value.as_slice(); @@ -139,12 +144,10 @@ macro_rules! define_Conf { if let Some(slice) = slice { if slice.iter().any(|v| v.as_str().is_none()) { None + } else { + Some(slice.iter().map(|v| v.as_str().expect("already checked").to_owned()).collect()) } - else { - Some(slice.iter().map(|v| v.as_str().unwrap_or_else(|| unreachable!()).to_owned()).collect()) - } - } - else { + } else { None } }}; @@ -160,7 +163,19 @@ define_Conf! { /// Lint: CYCLOMATIC_COMPLEXITY. The maximum cyclomatic complexity a function can have ("cyclomatic-complexity-threshold", cyclomatic_complexity_threshold, 25 => u64), /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks - ("doc-valid-idents", doc_valid_idents, ["MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "GPLv2", "GPLv3", "GitHub", "IPv4", "IPv6", "JavaScript", "NaN", "OAuth", "OpenGL", "TrueType", "iOS", "macOS"] => Vec), + ("doc-valid-idents", doc_valid_idents, [ + "MiB", "GiB", "TiB", "PiB", "EiB", + "DirectX", + "GPLv2", "GPLv3", + "GitHub", + "IPv4", "IPv6", + "JavaScript", + "NaN", + "OAuth", + "OpenGL", + "TrueType", + "iOS", "macOS", + ] => Vec), /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have ("too-many-arguments-threshold", too_many_arguments_threshold, 7 => u64), /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have diff --git a/tests/compile-fail/absurd-extreme-comparisons.rs b/tests/compile-fail/absurd-extreme-comparisons.rs index 627cd888aac1..81cb658df8de 100644 --- a/tests/compile-fail/absurd-extreme-comparisons.rs +++ b/tests/compile-fail/absurd-extreme-comparisons.rs @@ -9,7 +9,7 @@ fn main() { let u: u32 = 42; u <= 0; - //~^ ERROR this comparison involving the minimum or maximum element for this type contains a case that is always true or always false + //~^ ERROR this comparison involving the minimum or maximum element for this type contains a //~| HELP using u == 0 instead u <= Z; //~^ ERROR this comparison involving @@ -41,10 +41,10 @@ fn main() { //~| HELP because 1-1 is the minimum value for this type, this comparison is always false u >= !0; //~^ ERROR this comparison involving - //~| HELP because !0 is the maximum value for this type, the case where the two sides are not equal never occurs, consider using u == !0 instead + //~| HELP consider using u == !0 instead u <= 12 - 2*6; //~^ ERROR this comparison involving - //~| HELP because 12 - 2*6 is the minimum value for this type, the case where the two sides are not equal never occurs, consider using u == 12 - 2*6 instead + //~| HELP consider using u == 12 - 2*6 instead let i: i8 = 0; i < -127 - 1; diff --git a/tests/compile-fail/block_in_if_condition.rs b/tests/compile-fail/block_in_if_condition.rs index 43216754f753..090c39abc926 100644 --- a/tests/compile-fail/block_in_if_condition.rs +++ b/tests/compile-fail/block_in_if_condition.rs @@ -21,13 +21,13 @@ macro_rules! blocky_too { fn macro_if() { if blocky!() { } - + if blocky_too!() { } } fn condition_has_block() -> i32 { - if { //~ERROR in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let' + if { //~ERROR in an 'if' condition, avoid complex blocks or closures with blocks; let x = 3; x == 3 } { @@ -55,12 +55,12 @@ fn pred_test() { // this is a sneaky case, where the block isn't directly in the condition, but is actually // inside a closure that the condition is using. same principle applies. add some extra // expressions to make sure linter isn't confused by them. - if v == 3 && sky == "blue" && predicate(|x| { let target = 3; x == target }, v) { //~ERROR in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let' - + if v == 3 && sky == "blue" && predicate(|x| { let target = 3; x == target }, v) { + //~^ERROR in an 'if' condition, avoid complex blocks or closures with blocks; } - if predicate(|x| { let target = 3; x == target }, v) { //~ERROR in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let' - + if predicate(|x| { let target = 3; x == target }, v) { + //~^ERROR in an 'if' condition, avoid complex blocks or closures with blocks; } } From 0553de85738f67cdb760c170e013599449a9613d Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 12:36:25 +0100 Subject: [PATCH 07/11] run rustfmt on clippy, not only on clippy_lints --- src/main.rs | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/src/main.rs b/src/main.rs index 35153ebe8af3..0b91c79d21bc 100644 --- a/src/main.rs +++ b/src/main.rs @@ -39,19 +39,32 @@ impl ClippyCompilerCalls { impl<'a> CompilerCalls<'a> for ClippyCompilerCalls { fn early_callback( - &mut self, matches: &getopts::Matches, sopts: &config::Options, cfg: &ast::CrateConfig, - descriptions: &rustc_errors::registry::Registry, output: ErrorOutputType + &mut self, + matches: &getopts::Matches, + sopts: &config::Options, + cfg: &ast::CrateConfig, + descriptions: &rustc_errors::registry::Registry, + output: ErrorOutputType ) -> Compilation { self.default.early_callback(matches, sopts, cfg, descriptions, output) } fn no_input( - &mut self, matches: &getopts::Matches, sopts: &config::Options, cfg: &ast::CrateConfig, odir: &Option, - ofile: &Option, descriptions: &rustc_errors::registry::Registry + &mut self, + matches: &getopts::Matches, + sopts: &config::Options, + cfg: &ast::CrateConfig, + odir: &Option, + ofile: &Option, + descriptions: &rustc_errors::registry::Registry ) -> Option<(Input, Option)> { self.default.no_input(matches, sopts, cfg, odir, ofile, descriptions) } fn late_callback( - &mut self, matches: &getopts::Matches, sess: &Session, input: &Input, odir: &Option, + &mut self, + matches: &getopts::Matches, + sess: &Session, + input: &Input, + odir: &Option, ofile: &Option ) -> Compilation { self.default.late_callback(matches, sess, input, odir, ofile) From 53fc09ec460f3ac3760006d8a02c77370f1c4eb3 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 12:40:56 +0100 Subject: [PATCH 08/11] autogenerated functions are ignored by rustfmt --- clippy_lints/src/lib.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index e1d7e2e9e2c2..053be5d4c26e 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -175,10 +175,8 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) { let mut store = reg.sess.lint_store.borrow_mut(); store.register_removed("unstable_as_slice", "`Vec::as_slice` has been stabilized in 1.7"); store.register_removed("unstable_as_mut_slice", "`Vec::as_mut_slice` has been stabilized in 1.7"); - store.register_removed("str_to_string", - "using `str::to_string` is common even today and specialization will likely happen soon"); - store.register_removed("string_to_string", - "using `string::to_string` is common even today and specialization will likely happen soon"); + store.register_removed("str_to_string", "using `str::to_string` is common even today and specialization will likely happen soon"); + store.register_removed("string_to_string", "using `string::to_string` is common even today and specialization will likely happen soon"); // end deprecated lints, do not remove this comment, it’s used in `update_lints` reg.register_late_lint_pass(box serde::Serde); From 49e3419b87eb086ec2ef3133163efdec5af3733d Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 12:50:39 +0100 Subject: [PATCH 09/11] shorten deprecated lints line length --- clippy_lints/src/lib.rs | 20 ++++++++++++++++---- util/update_lints.py | 2 +- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index 053be5d4c26e..3641b476c5fb 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -173,10 +173,22 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) { }; let mut store = reg.sess.lint_store.borrow_mut(); - store.register_removed("unstable_as_slice", "`Vec::as_slice` has been stabilized in 1.7"); - store.register_removed("unstable_as_mut_slice", "`Vec::as_mut_slice` has been stabilized in 1.7"); - store.register_removed("str_to_string", "using `str::to_string` is common even today and specialization will likely happen soon"); - store.register_removed("string_to_string", "using `string::to_string` is common even today and specialization will likely happen soon"); + store.register_removed( + "unstable_as_slice", + "`Vec::as_slice` has been stabilized in 1.7", + ); + store.register_removed( + "unstable_as_mut_slice", + "`Vec::as_mut_slice` has been stabilized in 1.7", + ); + store.register_removed( + "str_to_string", + "using `str::to_string` is common even today and specialization will likely happen soon", + ); + store.register_removed( + "string_to_string", + "using `string::to_string` is common even today and specialization will likely happen soon", + ); // end deprecated lints, do not remove this comment, it’s used in `update_lints` reg.register_late_lint_pass(box serde::Serde); diff --git a/util/update_lints.py b/util/update_lints.py index 965d7e272c5b..b32cdce2cd0b 100755 --- a/util/update_lints.py +++ b/util/update_lints.py @@ -98,7 +98,7 @@ def gen_deprecated(lints): """Declare deprecated lints""" for lint in lints: - yield ' store.register_removed("%s", "%s");\n' % (lint[1], lint[2]) + yield ' store.register_removed(\n "%s",\n "%s",\n );\n' % (lint[1], lint[2]) def replace_region(fn, region_start, region_end, callback, From 6d3841e69de6ba93e3ff68649bda46b094be5ff9 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 13:12:17 +0100 Subject: [PATCH 10/11] every line needs to be its own string --- util/update_lints.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/util/update_lints.py b/util/update_lints.py index b32cdce2cd0b..ddb5d3ab32fd 100755 --- a/util/update_lints.py +++ b/util/update_lints.py @@ -98,7 +98,10 @@ def gen_deprecated(lints): """Declare deprecated lints""" for lint in lints: - yield ' store.register_removed(\n "%s",\n "%s",\n );\n' % (lint[1], lint[2]) + yield ' store.register_removed(\n' + yield ' "%s",\n' % lint[1] + yield ' "%s",\n' % lint[2] + yield ' );\n' def replace_region(fn, region_start, region_end, callback, From 55c0c9da8dece23a2b0f690a0cb3670b23aa6391 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 21 Dec 2016 13:21:35 +0100 Subject: [PATCH 11/11] fix travis --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index f6810698570f..3c226c879f26 100644 --- a/.travis.yml +++ b/.travis.yml @@ -24,9 +24,9 @@ install: script: - remark -f README.md > /dev/null - python util/update_lints.py -c - - PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff - - cd clippy_lints && PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff - set -e + - PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff + - cd clippy_lints && PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff && cd .. - cargo build --features debugging - cargo test --features debugging - mkdir -p ~/rust/cargo/bin