From 7b074d3ac7118a3f30c1f8782f15bfb081fbcaba Mon Sep 17 00:00:00 2001 From: Georg Brandl Date: Tue, 11 Aug 2015 17:02:04 +0200 Subject: [PATCH] Remove tabs and trailing whitespace from lib and misc. --- src/lib.rs | 4 +-- src/misc.rs | 88 ++++++++++++++++++++++++++--------------------------- 2 files changed, 46 insertions(+), 46 deletions(-) mode change 100644 => 100755 src/lib.rs diff --git a/src/lib.rs b/src/lib.rs old mode 100644 new mode 100755 index d0d0b637468..54f3bb11d26 --- a/src/lib.rs +++ b/src/lib.rs @@ -53,11 +53,11 @@ pub fn plugin_registrar(reg: &mut Registry) { reg.register_lint_pass(box collapsible_if::CollapsibleIf as LintPassObject); reg.register_lint_pass(box unicode::Unicode as LintPassObject); reg.register_lint_pass(box strings::StringAdd as LintPassObject); - + reg.register_lint_group("clippy", vec![types::BOX_VEC, types::LINKEDLIST, misc::SINGLE_MATCH, misc::STR_TO_STRING, misc::TOPLEVEL_REF_ARG, eq_op::EQ_OP, - bit_mask::BAD_BIT_MASK, + bit_mask::BAD_BIT_MASK, bit_mask::INEFFECTIVE_BIT_MASK, ptr_arg::PTR_ARG, needless_bool::NEEDLESS_BOOL, diff --git a/src/misc.rs b/src/misc.rs index 0f0405a835a..ff0594b2b5a 100644 --- a/src/misc.rs +++ b/src/misc.rs @@ -41,7 +41,7 @@ impl LintPass for MiscPass { } // In some cases, an exhaustive match is preferred to catch situations when // an enum is extended. So we only consider cases where a `_` wildcard is used - if arms[1].pats[0].node == PatWild(PatWildSingle) && + if arms[1].pats[0].node == PatWild(PatWildSingle) && arms[0].pats.len() == 1 { span_help_and_lint(cx, SINGLE_MATCH, expr.span, "You seem to be trying to use match for \ @@ -80,7 +80,7 @@ impl LintPass for StrToStringPass { } fn is_str(cx: &Context, expr: &ast::Expr) -> bool { - match walk_ty(cx.tcx.expr_ty(expr)).sty { + match walk_ty(cx.tcx.expr_ty(expr)).sty { ty::TyStr => true, _ => false } @@ -102,7 +102,7 @@ impl LintPass for TopLevelRefPass { fn check_fn(&mut self, cx: &Context, _: FnKind, decl: &FnDecl, _: &Block, _: Span, _: NodeId) { for ref arg in decl.inputs.iter() { if let PatIdent(BindByRef(_), _, _) = arg.pat.node { - span_lint(cx, + span_lint(cx, TOPLEVEL_REF_ARG, arg.pat.span, "`ref` directly on a function argument is ignored. Have you considered using a reference type instead?" @@ -121,7 +121,7 @@ impl LintPass for CmpNan { fn get_lints(&self) -> LintArray { lint_array!(CMP_NAN) } - + fn check_expr(&mut self, cx: &Context, expr: &Expr) { if let ExprBinary(ref cmp, ref left, ref right) = expr.node { if is_comparison_binop(cmp.node) { @@ -137,15 +137,15 @@ impl LintPass for CmpNan { } fn check_nan(cx: &Context, path: &Path, span: Span) { - path.segments.last().map(|seg| if seg.identifier.name == "NAN" { - span_lint(cx, CMP_NAN, span, - "Doomed comparison with NAN, use std::{f32,f64}::is_nan instead"); - }); + path.segments.last().map(|seg| if seg.identifier.name == "NAN" { + span_lint(cx, CMP_NAN, span, + "Doomed comparison with NAN, use std::{f32,f64}::is_nan instead"); + }); } declare_lint!(pub FLOAT_CMP, Warn, "Warn on ==/!= comparison of floaty values"); - + #[derive(Copy,Clone)] pub struct FloatCmp; @@ -153,14 +153,14 @@ impl LintPass for FloatCmp { fn get_lints(&self) -> LintArray { lint_array!(FLOAT_CMP) } - + fn check_expr(&mut self, cx: &Context, expr: &Expr) { if let ExprBinary(ref cmp, ref left, ref right) = expr.node { let op = cmp.node; if (op == BiEq || op == BiNe) && (is_float(cx, left) || is_float(cx, right)) { span_lint(cx, FLOAT_CMP, expr.span, &format!( "{}-Comparison of f32 or f64 detected. You may want to change this to 'abs({} - {}) < epsilon' for some suitable value of epsilon", - binop_to_string(op), snippet(cx, left.span, ".."), + binop_to_string(op), snippet(cx, left.span, ".."), snippet(cx, right.span, ".."))); } } @@ -168,16 +168,16 @@ impl LintPass for FloatCmp { } fn is_float(cx: &Context, expr: &Expr) -> bool { - if let ty::TyFloat(_) = walk_ty(cx.tcx.expr_ty(expr)).sty { + if let ty::TyFloat(_) = walk_ty(cx.tcx.expr_ty(expr)).sty { true - } else { - false + } else { + false } } declare_lint!(pub PRECEDENCE, Warn, "Warn on mixing bit ops with integer arithmetic without parenthesis"); - + #[derive(Copy,Clone)] pub struct Precedence; @@ -185,11 +185,11 @@ impl LintPass for Precedence { fn get_lints(&self) -> LintArray { lint_array!(PRECEDENCE) } - + fn check_expr(&mut self, cx: &Context, expr: &Expr) { if let ExprBinary(Spanned { node: op, ..}, ref left, ref right) = expr.node { if is_bit_op(op) && (is_arith_expr(left) || is_arith_expr(right)) { - span_lint(cx, PRECEDENCE, expr.span, + span_lint(cx, PRECEDENCE, expr.span, "Operator precedence can trip the unwary. Consider adding parenthesis to the subexpression."); } } @@ -219,7 +219,7 @@ fn is_arith_op(op : BinOp_) -> bool { declare_lint!(pub CMP_OWNED, Warn, "Warn on creating an owned string just for comparison"); - + #[derive(Copy,Clone)] pub struct CmpOwned; @@ -227,7 +227,7 @@ impl LintPass for CmpOwned { fn get_lints(&self) -> LintArray { lint_array!(CMP_OWNED) } - + fn check_expr(&mut self, cx: &Context, expr: &Expr) { if let ExprBinary(ref cmp, ref left, ref right) = expr.node { if is_comparison_binop(cmp.node) { @@ -239,33 +239,33 @@ impl LintPass for CmpOwned { } fn check_to_owned(cx: &Context, expr: &Expr, other_span: Span) { - match &expr.node { - &ExprMethodCall(Spanned{node: ref ident, ..}, _, ref args) => { - let name = ident.name; - if name == "to_string" || - name == "to_owned" && is_str_arg(cx, args) { - span_lint(cx, CMP_OWNED, expr.span, &format!( - "this creates an owned instance just for comparison. \ - Consider using {}.as_slice() to compare without allocation", - snippet(cx, other_span, ".."))) - } - }, - &ExprCall(ref path, _) => { - if let &ExprPath(None, ref path) = &path.node { - if match_path(path, &["String", "from_str"]) || - match_path(path, &["String", "from"]) { - span_lint(cx, CMP_OWNED, expr.span, &format!( - "this creates an owned instance just for comparison. \ - Consider using {}.as_slice() to compare without allocation", - snippet(cx, other_span, ".."))) - } - } - }, - _ => () - } + match &expr.node { + &ExprMethodCall(Spanned{node: ref ident, ..}, _, ref args) => { + let name = ident.name; + if name == "to_string" || + name == "to_owned" && is_str_arg(cx, args) { + span_lint(cx, CMP_OWNED, expr.span, &format!( + "this creates an owned instance just for comparison. \ + Consider using {}.as_slice() to compare without allocation", + snippet(cx, other_span, ".."))) + } + }, + &ExprCall(ref path, _) => { + if let &ExprPath(None, ref path) = &path.node { + if match_path(path, &["String", "from_str"]) || + match_path(path, &["String", "from"]) { + span_lint(cx, CMP_OWNED, expr.span, &format!( + "this creates an owned instance just for comparison. \ + Consider using {}.as_slice() to compare without allocation", + snippet(cx, other_span, ".."))) + } + } + }, + _ => () + } } fn is_str_arg(cx: &Context, args: &[P]) -> bool { - args.len() == 1 && if let ty::TyStr = + args.len() == 1 && if let ty::TyStr = walk_ty(cx.tcx.expr_ty(&*args[0])).sty { true } else { false } }