Merge pull request #726 from Manishearth/fmt

Manishearth · Manishearth · commit e4b3cbb09133 · 2016-02-29T22:14:04.000+05:30
Rustfmt everything
diff --git a/src/block_in_if_condition.rs b/src/block_in_if_condition.rs
@@ -92,8 +92,7 @@ impl LateLintPass for BlockInIfCondition {
                                                         snippet_block(cx, then.span, "..")));
                         }
                     } else {
-                        let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span,
-                                                                   |e| e.span);
+                        let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
                         if in_macro(cx, span) || differing_macro_contexts(expr.span, span) {
                             return;
                         }
diff --git a/src/collapsible_if.rs b/src/collapsible_if.rs
@@ -71,15 +71,13 @@ fn check_if(cx: &LateContext, e: &Expr) {
                 });
             }}
         } else if let Some(&Expr{ node: ExprIf(ref check_inner, ref content, None), span: sp, ..}) =
-                       single_stmt_of_block(then) {
+               single_stmt_of_block(then) {
             if e.span.expn_id != sp.expn_id {
                 return;
             }
-            span_lint_and_then(cx,
-                               COLLAPSIBLE_IF,
-                               e.span,
-                               "this if statement can be collapsed", |db| {
-                db.span_suggestion(e.span, "try",
+            span_lint_and_then(cx, COLLAPSIBLE_IF, e.span, "this if statement can be collapsed", |db| {
+                db.span_suggestion(e.span,
+                                   "try",
                                    format!("if {} && {} {}",
                                            check_to_string(cx, check),
                                            check_to_string(cx, check_inner),
diff --git a/src/copies.rs b/src/copies.rs
@@ -91,9 +91,7 @@ fn lint_same_then_else(cx: &LateContext, blocks: &[&Block]) {
         h.finish()
     };
 
-    let eq: &Fn(&&Block, &&Block) -> bool = &|&lhs, &rhs| -> bool {
-        SpanlessEq::new(cx).eq_block(lhs, rhs)
-    };
+    let eq: &Fn(&&Block, &&Block) -> bool = &|&lhs, &rhs| -> bool { SpanlessEq::new(cx).eq_block(lhs, rhs) };
 
     if let Some((i, j)) = search_same(blocks, hash, eq) {
         span_note_and_lint(cx,
diff --git a/src/derive.rs b/src/derive.rs
@@ -87,13 +87,7 @@ impl LateLintPass for Derive {
 }
 
 /// Implementation of the `DERIVE_HASH_XOR_EQ` lint.
-fn check_hash_peq(
-    cx: &LateContext,
-    span: Span,
-    trait_ref: &TraitRef,
-    ty: ty::Ty,
-    hash_is_automatically_derived: bool
-) {
+fn check_hash_peq(cx: &LateContext, span: Span, trait_ref: &TraitRef, ty: ty::Ty, hash_is_automatically_derived: bool) {
     if_let_chain! {[
         match_path(&trait_ref.path, &HASH_PATH),
         let Some(peq_trait_def_id) = cx.tcx.lang_items.eq_trait()
@@ -143,9 +137,7 @@ fn check_hash_peq(
 }
 
 /// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
-fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>,
-                              item: &Item,
-                              trait_ref: &TraitRef, ty: ty::Ty<'tcx>) {
+fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, item: &Item, trait_ref: &TraitRef, ty: ty::Ty<'tcx>) {
     if match_path(&trait_ref.path, &CLONE_TRAIT_PATH) {
         let parameter_environment = ty::ParameterEnvironment::for_item(cx.tcx, item.id);
         let subst_ty = ty.subst(cx.tcx, &parameter_environment.free_substs);
diff --git a/src/entry.rs b/src/entry.rs
@@ -48,7 +48,7 @@ impl LateLintPass for HashMapLint {
                     // in case of `if !m.contains_key(&k) { m.insert(k, v); }`
                     // we can give a better error message
                     let sole_expr = else_block.is_none() &&
-                        if then_block.expr.is_some() { 1 } else { 0 } + then_block.stmts.len() == 1;
+                        ((then_block.expr.is_some() as usize) + then_block.stmts.len() == 1);
 
                     let mut visitor = InsertVisitor {
                         cx: cx,
diff --git a/src/enum_variants.rs b/src/enum_variants.rs
@@ -31,17 +31,16 @@ fn var2str(var: &Variant) -> InternedString {
     var.node.name.name.as_str()
 }
 
-/*
-FIXME: waiting for https://github.com/rust-lang/rust/pull/31700
-fn partial_match(pre: &str, name: &str) -> usize {
-    // skip(1) to ensure that the prefix never takes the whole variant name
-    pre.chars().zip(name.chars().rev().skip(1).rev()).take_while(|&(l, r)| l == r).count()
-}
-
-fn partial_rmatch(post: &str, name: &str) -> usize {
-    // skip(1) to ensure that the postfix never takes the whole variant name
-    post.chars().rev().zip(name.chars().skip(1).rev()).take_while(|&(l, r)| l == r).count()
-}*/
+// FIXME: waiting for https://github.com/rust-lang/rust/pull/31700
+// fn partial_match(pre: &str, name: &str) -> usize {
+//    // skip(1) to ensure that the prefix never takes the whole variant name
+//     pre.chars().zip(name.chars().rev().skip(1).rev()).take_while(|&(l, r)| l == r).count()
+// }
+//
+// fn partial_rmatch(post: &str, name: &str) -> usize {
+//     // skip(1) to ensure that the postfix never takes the whole variant name
+//     post.chars().rev().zip(name.chars().skip(1).rev()).take_while(|&(l, r)| l == r).count()
+// }
 
 fn partial_match(pre: &str, name: &str) -> usize {
     let mut name_iter = name.chars();
@@ -99,7 +98,8 @@ impl EarlyLintPass for EnumVariantNames {
                                item.span,
                                &format!("All variants have the same {}fix: `{}`", what, value),
                                &format!("remove the {}fixes and use full paths to \
-                                         the variants instead of glob imports", what));
+                                         the variants instead of glob imports",
+                                        what));
         }
     }
 }
diff --git a/src/formatting.rs b/src/formatting.rs
@@ -96,9 +96,11 @@ fn check_assign(cx: &EarlyContext, expr: &ast::Expr) {
                         span_note_and_lint(cx,
                                            SUSPICIOUS_ASSIGNMENT_FORMATTING,
                                            eqop_span,
-                                           &format!("this looks like you are trying to use `.. {op}= ..`, but you really are doing `.. = ({op} ..)`", op=op),
+                                           &format!("this looks like you are trying to use `.. {op}= ..`, but you \
+                                                     really are doing `.. = ({op} ..)`",
+                                                    op = op),
                                            eqop_span,
-                                           &format!("to remove this lint, use either `{op}=` or `= {op}`", op=op));
+                                           &format!("to remove this lint, use either `{op}=` or `= {op}`", op = op));
                     }
                 }
             }
@@ -109,9 +111,7 @@ fn check_assign(cx: &EarlyContext, expr: &ast::Expr) {
 /// Implementation of the SUSPICIOUS_ELSE_FORMATTING lint for weird `else if`.
 fn check_else_if(cx: &EarlyContext, expr: &ast::Expr) {
     if let Some((then, &Some(ref else_))) = unsugar_if(expr) {
-        if unsugar_if(else_).is_some() &&
-        !differing_macro_contexts(then.span, else_.span) &&
-        !in_macro(cx, then.span) {
+        if unsugar_if(else_).is_some() && !differing_macro_contexts(then.span, else_.span) && !in_macro(cx, then.span) {
             // this will be a span from the closing ‘}’ of the “then” block (excluding) to the
             // “if” of the “else if” block (excluding)
             let else_span = mk_sp(then.span.hi, else_.span.lo);
@@ -127,7 +127,8 @@ fn check_else_if(cx: &EarlyContext, expr: &ast::Expr) {
                                        else_span,
                                        "this is an `else if` but the formatting might hide it",
                                        else_span,
-                                       "to remove this lint, remove the `else` or remove the new line between `else` and `if`");
+                                       "to remove this lint, remove the `else` or remove the new line between `else` \
+                                        and `if`");
                 }
             }
         }
@@ -136,10 +137,8 @@ fn check_else_if(cx: &EarlyContext, expr: &ast::Expr) {
 
 /// Implementation of the `SUSPICIOUS_ELSE_FORMATTING` lint for consecutive ifs.
 fn check_consecutive_ifs(cx: &EarlyContext, first: &ast::Expr, second: &ast::Expr) {
-    if !differing_macro_contexts(first.span, second.span) &&
-    !in_macro(cx, first.span) &&
-    unsugar_if(first).is_some() &&
-    unsugar_if(second).is_some() {
+    if !differing_macro_contexts(first.span, second.span) && !in_macro(cx, first.span) &&
+       unsugar_if(first).is_some() && unsugar_if(second).is_some() {
         // where the else would be
         let else_span = mk_sp(first.span.hi, second.span.lo);
 
@@ -150,14 +149,15 @@ fn check_consecutive_ifs(cx: &EarlyContext, first: &ast::Expr, second: &ast::Exp
                                    else_span,
                                    "this looks like an `else if` but the `else` is missing",
                                    else_span,
-                                   "to remove this lint, add the missing `else` or add a new line before the second `if`");
+                                   "to remove this lint, add the missing `else` or add a new line before the second \
+                                    `if`");
             }
         }
     }
 }
 
 /// Match `if` or `else if` expressions and return the `then` and `else` block.
-fn unsugar_if(expr: &ast::Expr) -> Option<(&P<ast::Block>, &Option<P<ast::Expr>>)>{
+fn unsugar_if(expr: &ast::Expr) -> Option<(&P<ast::Block>, &Option<P<ast::Expr>>)> {
     match expr.node {
         ast::ExprKind::If(_, ref then, ref else_) |
         ast::ExprKind::IfLet(_, _, ref then, ref else_) => Some((then, else_)),
diff --git a/src/len_zero.rs b/src/len_zero.rs
@@ -155,17 +155,11 @@ fn check_cmp(cx: &LateContext, span: Span, left: &Expr, right: &Expr, op: &str)
 fn check_len_zero(cx: &LateContext, span: Span, name: &Name, args: &[P<Expr>], lit: &Lit, op: &str) {
     if let Spanned{node: LitKind::Int(0, _), ..} = *lit {
         if name.as_str() == "len" && args.len() == 1 && has_is_empty(cx, &args[0]) {
-            span_lint_and_then(cx,
-                               LEN_ZERO,
-                               span,
-                               "length comparison to zero",
-                               |db| {
-                                   db.span_suggestion(span,
-                                                      "consider using `is_empty`",
-                                                       format!("{}{}.is_empty()",
-                                                               op,
-                                                               snippet(cx, args[0].span, "_")));
-                               });
+            span_lint_and_then(cx, LEN_ZERO, span, "length comparison to zero", |db| {
+                db.span_suggestion(span,
+                                   "consider using `is_empty`",
+                                   format!("{}{}.is_empty()", op, snippet(cx, args[0].span, "_")));
+            });
         }
     }
 }
diff --git a/src/loops.rs b/src/loops.rs
@@ -370,14 +370,14 @@ fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, ex
                     span_lint(cx,
                               NEEDLESS_RANGE_LOOP,
                               expr.span,
-                              &format!("the loop variable `{}` is used to index `{}`. \
-                                        Consider using `for ({}, item) in {}.iter().enumerate(){}{}` or similar iterators",
-                                        ident.node.name,
-                                        indexed,
-                                        ident.node.name,
-                                        indexed,
-                                        take,
-                                        skip));
+                              &format!("the loop variable `{}` is used to index `{}`. Consider using `for ({}, \
+                                        item) in {}.iter().enumerate(){}{}` or similar iterators",
+                                       ident.node.name,
+                                       indexed,
+                                       ident.node.name,
+                                       indexed,
+                                       take,
+                                       skip));
                 } else {
                     let repl = if starts_at_zero && take.is_empty() {
                         format!("&{}", indexed)
@@ -390,9 +390,9 @@ fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, ex
                               expr.span,
                               &format!("the loop variable `{}` is only used to index `{}`. \
                                         Consider using `for item in {}` or similar iterators",
-                                        ident.node.name,
-                                        indexed,
-                                        repl));
+                                       ident.node.name,
+                                       indexed,
+                                       repl));
                 }
             }
         }
@@ -447,9 +447,7 @@ 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!("({}..{}).rev()` ",
-                                                                       stop_snippet,
-                                                                       start_snippet));
+                                                              format!("({}..{}).rev()` ", stop_snippet, start_snippet));
                                        });
                 } else if eq {
                     // if they are equal, it's also problematic - this loop
@@ -744,6 +742,7 @@ impl<'v, 't> Visitor<'v> for VarUsedAfterLoopVisitor<'v, 't> {
 
 /// Return true if the type of expr is one that provides IntoIterator impls
 /// for &T and &mut T, such as Vec.
+#[cfg_attr(rustfmt, rustfmt_skip)]
 fn is_ref_iterable_type(cx: &LateContext, e: &Expr) -> bool {
     // no walk_ptrs_ty: calling iter() on a reference can make sense because it
     // will allow further borrows afterwards
diff --git a/src/map_clone.rs b/src/map_clone.rs
@@ -1,10 +1,8 @@
 use rustc::lint::*;
 use rustc_front::hir::*;
 use utils::{CLONE_PATH, OPTION_PATH};
-use utils::{
-    is_adjusted, match_path, match_trait_method, match_type, snippet, span_help_and_lint,
-    walk_ptrs_ty, walk_ptrs_ty_depth
-};
+use utils::{is_adjusted, match_path, match_trait_method, match_type, snippet, span_help_and_lint, walk_ptrs_ty,
+            walk_ptrs_ty_depth};
 
 /// **What it does:** This lint checks for mapping clone() over an iterator.
 ///
diff --git a/src/matches.rs b/src/matches.rs
@@ -134,10 +134,11 @@ impl LateLintPass for MatchPass {
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 fn check_single_match(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr) {
     if arms.len() == 2 &&
-       arms[0].pats.len() == 1 && arms[0].guard.is_none() &&
-       arms[1].pats.len() == 1 && arms[1].guard.is_none() {
+      arms[0].pats.len() == 1 && arms[0].guard.is_none() &&
+      arms[1].pats.len() == 1 && arms[1].guard.is_none() {
         let els = if is_unit_expr(&arms[1].body) {
             None
         } else if let ExprBlock(_) = arms[1].body.node {
@@ -167,28 +168,28 @@ fn check_single_match_single_pattern(cx: &LateContext, ex: &Expr, arms: &[Arm],
                            lint,
                            expr.span,
                            "you seem to be trying to use match for destructuring a single pattern. \
-                           Consider using `if let`", |db| {
-                db.span_suggestion(expr.span, "try this",
-                                   format!("if let {} = {} {}{}",
-                                           snippet(cx, arms[0].pats[0].span, ".."),
-                                           snippet(cx, ex.span, ".."),
-                                           expr_block(cx, &arms[0].body, None, ".."),
-                                           els_str));
-            });
+                           Consider using `if let`",
+                           |db| {
+                               db.span_suggestion(expr.span,
+                                                  "try this",
+                                                  format!("if let {} = {} {}{}",
+                                                          snippet(cx, arms[0].pats[0].span, ".."),
+                                                          snippet(cx, ex.span, ".."),
+                                                          expr_block(cx, &arms[0].body, None, ".."),
+                                                          els_str));
+                           });
     }
 }
 
 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 = &[
-        (&COW_PATH, "Borrowed"),
-        (&COW_PATH, "Cow::Borrowed"),
-        (&COW_PATH, "Cow::Owned"),
-        (&COW_PATH, "Owned"),
-        (&OPTION_PATH, "None"),
-        (&RESULT_PATH, "Err"),
-        (&RESULT_PATH, "Ok"),
-    ];
+    let candidates = &[(&COW_PATH, "Borrowed"),
+                       (&COW_PATH, "Cow::Borrowed"),
+                       (&COW_PATH, "Cow::Owned"),
+                       (&COW_PATH, "Owned"),
+                       (&OPTION_PATH, "None"),
+                       (&RESULT_PATH, "Err"),
+                       (&RESULT_PATH, "Ok")];
 
     let path = match arms[1].pats[0].node {
         PatKind::TupleStruct(ref path, Some(ref inner)) => {
diff --git a/src/methods.rs b/src/methods.rs
@@ -565,7 +565,9 @@ fn lint_clone_double_ref(cx: &LateContext, expr: &Expr, arg: &Expr) {
     let ty = cx.tcx.expr_ty(arg);
     if let ty::TyRef(_, ty::TypeAndMut { ty: ref inner, .. }) = ty.sty {
         if let ty::TyRef(..) = inner.sty {
-            let mut db = span_lint(cx, CLONE_DOUBLE_REF, expr.span,
+            let mut db = span_lint(cx,
+                                   CLONE_DOUBLE_REF,
+                                   expr.span,
                                    "using `clone` on a double-reference; \
                                     this will copy the reference instead of cloning \
                                     the inner type");
@@ -583,10 +585,7 @@ fn lint_extend(cx: &LateContext, expr: &Expr, args: &MethodArgs) {
     }
     let arg_ty = cx.tcx.expr_ty(&args[1]);
     if let Some((span, r)) = derefs_to_slice(cx, &args[1], &arg_ty) {
-        span_lint(cx,
-                  EXTEND_FROM_SLICE,
-                  expr.span,
-                  "use of `extend` to extend a Vec by a slice")
+        span_lint(cx, EXTEND_FROM_SLICE, expr.span, "use of `extend` to extend a Vec by a slice")
             .span_suggestion(expr.span,
                              "try this",
                              format!("{}.extend_from_slice({}{})",
diff --git a/src/print.rs b/src/print.rs
diff --git a/src/regex.rs b/src/regex.rs
diff --git a/src/strings.rs b/src/strings.rs
diff --git a/src/types.rs b/src/types.rs
diff --git a/src/utils/hir.rs b/src/utils/hir.rs
diff --git a/src/utils/mod.rs b/src/utils/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -92,8 +92,7 @@ impl LateLintPass for BlockInIfCondition {`
`92`	`92`	`snippet_block(cx, then.span, "..")));`
`93`	`93`	`}`
`94`	`94`	`} else {`
`95`		`- let span = block.expr.as_ref().map_or_else(\|\| block.stmts[0].span,`
`96`		`- \|e\| e.span);`
	`95`	`+ let span = block.expr.as_ref().map_or_else(\|\| block.stmts[0].span, \|e\| e.span);`
`97`	`96`	`if in_macro(cx, span) \|\| differing_macro_contexts(expr.span, span) {`
`98`	`97`	`return;`
`99`	`98`	`}`