rust/clippy_lints/src/needless_bool.rs

215 lines
7.1 KiB
Rust
Raw Normal View History

//! Checks for needless boolean results of if-else expressions
//!
//! This lint is **warn** by default
use rustc::lint::*;
use rustc::hir::*;
2016-02-12 11:35:44 -06:00
use syntax::ast::LitKind;
use syntax::codemap::Spanned;
2017-09-05 04:33:04 -05:00
use utils::{snippet, span_lint, span_lint_and_sugg};
2016-07-03 18:17:31 -05:00
use utils::sugg::Sugg;
2017-08-09 02:30:56 -05:00
/// **What it does:** Checks for expressions of the form `if c { true } else {
/// false }`
2016-07-15 17:25:44 -05:00
/// (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.
///
2016-07-15 17:25:44 -05:00
/// **Example:**
/// ```rust
/// if x { false } else { true }
/// ```
2018-03-28 08:24:26 -05:00
declare_clippy_lint! {
pub NEEDLESS_BOOL,
2018-03-28 08:24:26 -05:00
complexity,
"if-statements with plain booleans in the then- and else-clause, e.g. \
`if p { true } else { false }`"
}
/// **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:**
/// ```rust
/// if x == true { } // could be `if x { }`
/// ```
2018-03-28 08:24:26 -05:00
declare_clippy_lint! {
pub BOOL_COMPARISON,
2018-03-29 06:41:53 -05:00
complexity,
"comparing a variable to a boolean, e.g. `if x == true`"
}
2017-08-09 02:30:56 -05:00
#[derive(Copy, Clone)]
pub struct NeedlessBool;
impl LintPass for NeedlessBool {
fn get_lints(&self) -> LintArray {
lint_array!(NEEDLESS_BOOL)
}
}
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 {
2016-07-03 18:17:31 -05:00
let reduce = |ret, not| {
let snip = Sugg::hir(cx, pred, "<predicate>");
2016-12-20 11:21:30 -06:00
let snip = if not { !snip } else { snip };
2016-07-03 18:17:31 -05:00
let hint = if ret {
2016-07-06 08:36:42 -05:00
format!("return {}", snip)
2016-07-03 18:17:31 -05:00
} else {
snip.to_string()
};
2017-08-09 02:30:56 -05:00
span_lint_and_sugg(
cx,
NEEDLESS_BOOL,
e.span,
"this if-then-else expression returns a bool literal",
"you can reduce it to",
hint,
);
};
2018-05-17 04:21:15 -05:00
if let ExprBlock(ref then_block, _) = then_block.node {
2017-04-12 04:06:32 -05:00
match (fetch_bool_block(then_block), fetch_bool_expr(else_expr)) {
2017-09-05 04:33:04 -05:00
(RetBool(true), RetBool(true)) | (Bool(true), Bool(true)) => {
2017-08-09 02:30:56 -05:00
span_lint(
cx,
NEEDLESS_BOOL,
e.span,
"this if-then-else expression will always return true",
);
2017-04-12 04:06:32 -05:00
},
2017-09-05 04:33:04 -05:00
(RetBool(false), RetBool(false)) | (Bool(false), Bool(false)) => {
2017-08-09 02:30:56 -05:00
span_lint(
cx,
NEEDLESS_BOOL,
e.span,
"this if-then-else expression will always return false",
);
2017-04-12 04:06:32 -05:00
},
(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 ExprBlock");
}
}
}
}
2017-08-09 02:30:56 -05:00
#[derive(Copy, Clone)]
pub struct BoolComparison;
impl LintPass for BoolComparison {
fn get_lints(&self) -> LintArray {
lint_array!(BOOL_COMPARISON)
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
use self::Expression::*;
2016-04-14 13:14:03 -05:00
if let ExprBinary(Spanned { node: BiEq, .. }, ref left_side, ref right_side) = e.node {
match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
(Bool(true), Other) => {
2016-02-09 22:50:23 -06:00
let hint = snippet(cx, right_side.span, "..").into_owned();
2017-08-09 02:30:56 -05:00
span_lint_and_sugg(
cx,
BOOL_COMPARISON,
e.span,
"equality checks against true are unnecessary",
"try simplifying it as shown",
hint,
);
2016-12-20 11:21:30 -06:00
},
(Other, Bool(true)) => {
2016-02-09 22:50:23 -06:00
let hint = snippet(cx, left_side.span, "..").into_owned();
2017-08-09 02:30:56 -05:00
span_lint_and_sugg(
cx,
BOOL_COMPARISON,
e.span,
"equality checks against true are unnecessary",
"try simplifying it as shown",
hint,
);
2016-12-20 11:21:30 -06:00
},
(Bool(false), Other) => {
2016-07-03 18:17:31 -05:00
let hint = Sugg::hir(cx, right_side, "..");
2017-08-09 02:30:56 -05:00
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(),
);
2016-12-20 11:21:30 -06:00
},
(Other, Bool(false)) => {
2016-07-03 18:17:31 -05:00
let hint = Sugg::hir(cx, left_side, "..");
2017-08-09 02:30:56 -05:00
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(),
);
2016-12-20 11:21:30 -06:00
},
_ => (),
}
}
}
}
enum Expression {
Bool(bool),
RetBool(bool),
Other,
}
fn fetch_bool_block(block: &Block) -> Expression {
match (&*block.stmts, block.expr.as_ref()) {
(&[], Some(e)) => fetch_bool_expr(&**e),
2017-09-05 04:33:04 -05:00
(&[ref e], None) => if let StmtSemi(ref e, _) = e.node {
if let ExprRet(_) = e.node {
fetch_bool_expr(&**e)
} else {
Expression::Other
}
2017-09-05 04:33:04 -05:00
} else {
Expression::Other
2016-12-20 11:21:30 -06:00
},
_ => Expression::Other,
2016-01-03 22:26:12 -06:00
}
}
fn fetch_bool_expr(expr: &Expr) -> Expression {
2015-08-21 13:44:48 -05:00
match expr.node {
2018-05-17 04:21:15 -05:00
ExprBlock(ref block, _) => fetch_bool_block(block),
2017-09-05 04:33:04 -05:00
ExprLit(ref lit_ptr) => if let LitKind::Bool(value) = lit_ptr.node {
Expression::Bool(value)
} else {
Expression::Other
2016-12-20 11:21:30 -06:00
},
2017-09-05 04:33:04 -05:00
ExprRet(Some(ref expr)) => match fetch_bool_expr(expr) {
Expression::Bool(value) => Expression::RetBool(value),
_ => Expression::Other,
2016-12-20 11:21:30 -06:00
},
_ => Expression::Other,
}
}