diff --git a/clippy_lints/src/array_indexing.rs b/clippy_lints/src/array_indexing.rs
index 3387f68d93b..aa9af2e681d 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<Option<ConstVal>>, end: Option<Option<ConstVal>>, limits: RangeLimits,
- array_size: ConstInt)
- -> Option<(ConstInt, ConstInt)> {
+fn to_const_range(start: Option<Option<ConstVal>>, end: Option<Option<ConstVal>>, limits: RangeLimits, array_size: ConstInt)
+ -> Option<(ConstInt, ConstInt)> {
let start = match start {
Some(Some(ConstVal::Integral(x))) => x,
Some(_) => return None,
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 528a62d7f02..24fd5a1483d 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 5ef9f67a3b8..9a9b97d0e81 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 463923136ff..8836af28d09 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 76e8f867040..20c82ee4660 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 657018a0ab9..2ff31b3a4fe 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 ab47b7cffe2..e3bfca0b2f5 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 17ff2613dda..d66c8757ef2 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 d975a88f7ab..f83b3271d50 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 801532a1c3b..58425ff2a40 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::<HashSet<_>>();
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 786420bbe65..c6efc3fd736 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 081345a09e6..e9f93d04360 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<Item = &'tcx Lifetime>>(cx: &LateContext<'a, 'tcx>,
- func: &'tcx FnDecl,
- named_lts: &'tcx [LifetimeDef], bounds_lts: T)
- -> bool {
+fn could_use_elision<'a, 'tcx: 'a, T: Iterator<Item = &'tcx Lifetime>>(cx: &LateContext<'a, 'tcx>, func: &'tcx FnDecl, named_lts: &'tcx [LifetimeDef], bounds_lts: T)
+ -> bool {
// 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 e85d0f40c4b..3a7012972ba 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!("({}, <item>)", 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, "<item>"), (arg.span, &repl)]);
- });
+ multispan_sugg(db,
+ "consider using an iterator".to_string(),
+ &[(pat.span, "<item>"), (arg.span, &repl)]);
+ });
}
}
}
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index e1216c8493b..b1b52cfb015 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 5ecd1c06a5d..ebb90c9eef0 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 9d9f30c820c..bccc1164047 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 403c6ddcbdf..70696ea3908 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 9a0d5f1bb36..5eae3034aff 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 4c9ff328896..2a75a19dd28 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 fd8ffb36d46..a195673a53b 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 a09ff3bebf6..f2e47886549 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 9961a26b5c4..36fd33b22ce 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 844fd9482ff..195b49c72f6 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 2ef66cf7644..e3a9758d2b7 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 b58456ce85e..ebb7735171e 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 0ba86ff55dc..7c83a7f69a5 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<ast::NestedMetaItemKind>])
- -> Result<Option<path::PathBuf>, (&'static str, codemap::Span)> {
+ -> Result<Option<path::PathBuf>, (&'static str, codemap::Span)> {
for arg in args.iter().filter_map(|a| a.meta_item()) {
if arg.name() == "conf_file" {
return match arg.node {
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
index 83d96b8db61..79cf15b6c5f 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 f31ce3706eb..dc25020d3fc 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<DefId> {
/// Check whether a type implements a trait.
/// See also `get_trait_def_id`.
-pub fn implements_trait<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, trait_id: DefId,
- ty_params: Vec<ty::Ty<'tcx>>)
- -> bool {
+pub fn implements_trait<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, trait_id: DefId, ty_params: Vec<ty::Ty<'tcx>>)
+ -> bool {
cx.tcx.populate_implementations_for_trait_if_necessary(trait_id);
let ty = cx.tcx.erase_regions(&ty);
@@ -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<String>` which can be put inside the braces.
pub fn expr_block<'a, 'b, T: LintContext<'b>>(cx: &T, expr: &Expr, option: Option<String>, default: &'a str)
- -> Cow<'a, str> {
+ -> 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 6daad2b65bd..0d8362496c1 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 89db653929c..35153ebe8af 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<PathBuf>, ofile: &Option<PathBuf>, descriptions: &rustc_errors::registry::Registry)
- -> Option<(Input, Option<PathBuf>)> {
+ fn no_input(
+ &mut self, matches: &getopts::Matches, sopts: &config::Options, cfg: &ast::CrateConfig, odir: &Option<PathBuf>,
+ ofile: &Option<PathBuf>, descriptions: &rustc_errors::registry::Registry
+ ) -> Option<(Input, Option<PathBuf>)> {
self.default.no_input(matches, sopts, cfg, odir, ofile, descriptions)
}
- fn late_callback(&mut self, matches: &getopts::Matches, sess: &Session, input: &Input, odir: &Option<PathBuf>,
- ofile: &Option<PathBuf>)
- -> Compilation {
+ fn late_callback(
+ &mut self, matches: &getopts::Matches, sess: &Session, input: &Input, odir: &Option<PathBuf>,
+ ofile: &Option<PathBuf>
+ ) -> Compilation {
self.default.late_callback(matches, sess, input, odir, ofile)
}
fn build_controller(&mut self, sess: &Session, matches: &getopts::Matches) -> driver::CompileController<'a> {