//! This lint is **warn** by default
use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
use rustc::hir::*;
use syntax::ast::LitKind;
use syntax::codemap::Spanned;
-use utils::{span_lint, span_lint_and_then, snippet};
-use utils::sugg::Sugg;
+use crate::utils::{snippet, span_lint, span_lint_and_sugg};
+use crate::utils::sugg::Sugg;
-/// **What it does:** This lint checks for expressions of the form `if c { true } else { false }` (or vice versa) and suggest using the condition directly.
+/// **What it does:** Checks for expressions of the form `if c { true } else {
+/// false }`
+/// (or vice versa) and suggest using the condition directly.
///
/// **Why is this bad?** Redundant code.
///
-/// **Known problems:** Maybe false positives: Sometimes, the two branches are painstakingly documented (which we of course do not detect), so they *may* have some value. Even then, the documentation can be rewritten to match the shorter code.
+/// **Known problems:** Maybe false positives: Sometimes, the two branches are
+/// painstakingly documented (which we of course do not detect), so they *may*
+/// have some value. Even then, the documentation can be rewritten to match the
+/// shorter code.
///
-/// **Example:** `if x { false } else { true }`
-declare_lint! {
+/// **Example:**
+/// ```rust
+/// if x { false } else { true }
+/// ```
+declare_clippy_lint! {
pub NEEDLESS_BOOL,
- Warn,
+ complexity,
"if-statements with plain booleans in the then- and else-clause, e.g. \
`if p { true } else { false }`"
}
-/// **What it does:** This lint checks for expressions of the form `x == true` (or vice versa) and suggest using the variable directly.
+/// **What it does:** Checks for expressions of the form `x == true` (or vice
+/// versa) and suggest using the variable directly.
///
/// **Why is this bad?** Unnecessary code.
///
/// **Known problems:** None.
///
-/// **Example:** `if x == true { }` could be `if x { }`
-declare_lint! {
+/// **Example:**
+/// ```rust
+/// if x == true { } // could be `if x { }`
+/// ```
+declare_clippy_lint! {
pub BOOL_COMPARISON,
- Warn,
- "comparing a variable to a boolean, e.g. \
- `if x == true`"
+ complexity,
+ "comparing a variable to a boolean, e.g. `if x == true`"
}
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
pub struct NeedlessBool;
impl LintPass for NeedlessBool {
}
}
-impl LateLintPass for NeedlessBool {
- fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool {
+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
use self::Expression::*;
- if let ExprIf(ref pred, ref then_block, Some(ref else_expr)) = e.node {
+ if let ExprKind::If(ref pred, ref then_block, Some(ref else_expr)) = e.node {
let reduce = |ret, not| {
let snip = Sugg::hir(cx, pred, "<predicate>");
- let snip = if not {
- !snip
- } else {
- snip
- };
+ let snip = if not { !snip } else { snip };
let hint = if ret {
format!("return {}", snip)
snip.to_string()
};
- span_lint_and_then(cx,
- NEEDLESS_BOOL,
- e.span,
- "this if-then-else expression returns a bool literal",
- |db| {
- db.span_suggestion(e.span, "you can reduce it to", hint);
- });
+ span_lint_and_sugg(
+ cx,
+ NEEDLESS_BOOL,
+ e.span,
+ "this if-then-else expression returns a bool literal",
+ "you can reduce it to",
+ hint,
+ );
};
- match (fetch_bool_block(then_block), fetch_bool_expr(else_expr)) {
- (RetBool(true), RetBool(true)) |
- (Bool(true), Bool(true)) => {
- span_lint(cx,
- 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");
+ if let ExprKind::Block(ref then_block, _) = then_block.node {
+ match (fetch_bool_block(then_block), fetch_bool_expr(else_expr)) {
+ (RetBool(true), RetBool(true)) | (Bool(true), Bool(true)) => {
+ span_lint(
+ cx,
+ 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),
+ (Bool(false), Bool(true)) => reduce(false, true),
+ _ => (),
}
- (RetBool(true), RetBool(false)) => reduce(true, false),
- (Bool(true), Bool(false)) => reduce(false, false),
- (RetBool(false), RetBool(true)) => reduce(true, true),
- (Bool(false), Bool(true)) => reduce(false, true),
- _ => (),
+ } else {
+ panic!("IfExpr 'then' node is not an ExprKind::Block");
}
}
}
}
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
pub struct BoolComparison;
impl LintPass for BoolComparison {
}
}
-impl LateLintPass for BoolComparison {
- fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison {
+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
use self::Expression::*;
- if let ExprBinary(Spanned { node: BiEq, .. }, ref left_side, ref right_side) = e.node {
+ if let ExprKind::Binary(Spanned { node: BinOpKind::Eq, .. }, ref left_side, ref right_side) = e.node {
match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
(Bool(true), Other) => {
let hint = snippet(cx, right_side.span, "..").into_owned();
- span_lint_and_then(cx,
- BOOL_COMPARISON,
- e.span,
- "equality checks against true are unnecessary",
- |db| {
- db.span_suggestion(e.span, "try simplifying it as shown:", hint);
- });
- }
+ span_lint_and_sugg(
+ cx,
+ BOOL_COMPARISON,
+ e.span,
+ "equality checks against true are unnecessary",
+ "try simplifying it as shown",
+ hint,
+ );
+ },
(Other, Bool(true)) => {
let hint = snippet(cx, left_side.span, "..").into_owned();
- span_lint_and_then(cx,
- BOOL_COMPARISON,
- e.span,
- "equality checks against true are unnecessary",
- |db| {
- db.span_suggestion(e.span, "try simplifying it as shown:", hint);
- });
- }
+ span_lint_and_sugg(
+ cx,
+ BOOL_COMPARISON,
+ e.span,
+ "equality checks against true are unnecessary",
+ "try simplifying it as shown",
+ hint,
+ );
+ },
(Bool(false), Other) => {
let hint = Sugg::hir(cx, right_side, "..");
- span_lint_and_then(cx,
- BOOL_COMPARISON,
- 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());
- });
- }
+ span_lint_and_sugg(
+ cx,
+ BOOL_COMPARISON,
+ e.span,
+ "equality checks against false can be replaced by a negation",
+ "try simplifying it as shown",
+ (!hint).to_string(),
+ );
+ },
(Other, Bool(false)) => {
let hint = Sugg::hir(cx, left_side, "..");
- span_lint_and_then(cx,
- BOOL_COMPARISON,
- 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());
- });
- }
+ span_lint_and_sugg(
+ cx,
+ BOOL_COMPARISON,
+ e.span,
+ "equality checks against false can be replaced by a negation",
+ "try simplifying it as shown",
+ (!hint).to_string(),
+ );
+ },
_ => (),
}
}
fn fetch_bool_block(block: &Block) -> Expression {
match (&*block.stmts, block.expr.as_ref()) {
(&[], Some(e)) => fetch_bool_expr(&**e),
- (&[ref e], None) => {
- if let StmtSemi(ref e, _) = e.node {
- if let ExprRet(_) = e.node {
- fetch_bool_expr(&**e)
- } else {
- Expression::Other
- }
+ (&[ref e], None) => if let StmtKind::Semi(ref e, _) = e.node {
+ if let ExprKind::Ret(_) = e.node {
+ fetch_bool_expr(&**e)
} else {
Expression::Other
}
- }
+ } else {
+ Expression::Other
+ },
_ => Expression::Other,
}
}
fn fetch_bool_expr(expr: &Expr) -> Expression {
match expr.node {
- ExprBlock(ref block) => fetch_bool_block(block),
- ExprLit(ref lit_ptr) => {
- if let LitKind::Bool(value) = lit_ptr.node {
- Expression::Bool(value)
- } else {
- Expression::Other
- }
- }
- ExprRet(Some(ref expr)) => {
- match fetch_bool_expr(expr) {
- Expression::Bool(value) => Expression::RetBool(value),
- _ => Expression::Other,
- }
- }
+ ExprKind::Block(ref block, _) => fetch_bool_block(block),
+ ExprKind::Lit(ref lit_ptr) => if let LitKind::Bool(value) = lit_ptr.node {
+ Expression::Bool(value)
+ } else {
+ Expression::Other
+ },
+ ExprKind::Ret(Some(ref expr)) => match fetch_bool_expr(expr) {
+ Expression::Bool(value) => Expression::RetBool(value),
+ _ => Expression::Other,
+ },
_ => Expression::Other,
}
}
projects / rust.git / blobdiff