//! 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_sugg, snippet};
-use utils::sugg::Sugg;
+use crate::utils::{snippet, span_lint, span_lint_and_sugg};
+use crate::utils::sugg::Sugg;
/// **What it does:** Checks for expressions of the form `if c { true } else {
/// false }`
/// ```rust
/// if x { false } else { true }
/// ```
-declare_lint! {
+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 }`"
}
/// ```rust
/// if x == true { } // could be `if x { }`
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub BOOL_COMPARISON,
- Warn,
+ complexity,
"comparing a variable to a boolean, e.g. `if x == true`"
}
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 };
hint,
);
};
- if let ExprBlock(ref then_block) = then_block.node {
+ 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)) => {
+ (RetBool(true), RetBool(true)) | (Bool(true), Bool(true)) => {
span_lint(
cx,
NEEDLESS_BOOL,
"this if-then-else expression will always return true",
);
},
- (RetBool(false), RetBool(false)) |
- (Bool(false), Bool(false)) => {
+ (RetBool(false), RetBool(false)) | (Bool(false), Bool(false)) => {
span_lint(
cx,
NEEDLESS_BOOL,
_ => (),
}
} else {
- panic!("IfExpr 'then' node is not an ExprBlock");
+ panic!("IfExpr 'then' node is not an ExprKind::Block");
}
}
}
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();
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
- }
+ 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
},
- ExprRet(Some(ref expr)) => {
- match fetch_bool_expr(expr) {
- Expression::Bool(value) => Expression::RetBool(value),
- _ => Expression::Other,
- }
+ ExprKind::Ret(Some(ref expr)) => match fetch_bool_expr(expr) {
+ Expression::Bool(value) => Expression::RetBool(value),
+ _ => Expression::Other,
},
_ => Expression::Other,
}