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