X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fneedless_bool.rs;h=7e8540ffd3592674225d52aacf05c9511b9779d4;hb=e5a5b0a0774625eebbe7b29c67b49dc6431544d1;hp=ec9e0bb169441bfce2515b0db5400daef5e1ad14;hpb=76f9c22fde8f62547f17fd15c3664b74798686d3;p=rust.git diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs index ec9e0bb1694..7e8540ffd35 100644 --- a/clippy_lints/src/needless_bool.rs +++ b/clippy_lints/src/needless_bool.rs @@ -3,74 +3,68 @@ //! This lint is **warn** by default use crate::utils::sugg::Sugg; -use crate::utils::{in_macro, span_lint, span_lint_and_sugg}; +use crate::utils::{higher, parent_node_is_if_expr, span_lint, span_lint_and_sugg}; +use rustc::declare_lint_pass; use rustc::hir::*; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::{declare_tool_lint, lint_array}; use rustc_errors::Applicability; +use rustc_session::declare_tool_lint; use syntax::ast::LitKind; use syntax::source_map::Spanned; -/// **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. -/// -/// **Example:** -/// ```rust -/// if x { -/// false -/// } else { -/// true -/// } -/// ``` declare_clippy_lint! { + /// **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. + /// + /// **Example:** + /// ```rust,ignore + /// if x { + /// false + /// } else { + /// true + /// } + /// ``` + /// Could be written as + /// ```rust,ignore + /// !x + /// ``` pub NEEDLESS_BOOL, complexity, - "if-statements with plain booleans in the then- and else-clause, e.g. `if p { true } else { false }`" + "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`, -/// `x != true` and order comparisons such as `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 { }` -/// ``` declare_clippy_lint! { + /// **What it does:** Checks for expressions of the form `x == true`, + /// `x != true` and order comparisons such as `x < true` (or vice versa) and + /// suggest using the variable directly. + /// + /// **Why is this bad?** Unnecessary code. + /// + /// **Known problems:** None. + /// + /// **Example:** + /// ```rust,ignore + /// if x == true {} // could be `if x { }` + /// ``` pub BOOL_COMPARISON, complexity, - "comparing a variable to a boolean, e.g. `if x == true` or `if x != true`" + "comparing a variable to a boolean, e.g., `if x == true` or `if x != true`" } -#[derive(Copy, Clone)] -pub struct NeedlessBool; - -impl LintPass for NeedlessBool { - fn get_lints(&self) -> LintArray { - lint_array!(NEEDLESS_BOOL) - } - - fn name(&self) -> &'static str { - "NeedlessBool" - } -} +declare_lint_pass!(NeedlessBool => [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 ExprKind::If(ref pred, ref then_block, Some(ref else_expr)) = e.node { + if let Some((ref pred, ref then_block, Some(ref else_expr))) = higher::if_block(&e) { let reduce = |ret, not| { let mut applicability = Applicability::MachineApplicable; let snip = Sugg::hir_with_applicability(cx, pred, "", &mut applicability); @@ -94,7 +88,7 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { applicability, ); }; - if let ExprKind::Block(ref then_block, _) = then_block.node { + if let ExprKind::Block(ref then_block, _) = then_block.kind { match (fetch_bool_block(then_block), fetch_bool_expr(else_expr)) { (RetBool(true), RetBool(true)) | (Bool(true), Bool(true)) => { span_lint( @@ -125,39 +119,15 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { } } -fn parent_node_is_if_expr<'a, 'b>(expr: &Expr, cx: &LateContext<'a, 'b>) -> bool { - let parent_id = cx.tcx.hir().get_parent_node_by_hir_id(expr.hir_id); - let parent_node = cx.tcx.hir().get_by_hir_id(parent_id); - - if let rustc::hir::Node::Expr(e) = parent_node { - if let ExprKind::If(_, _, _) = e.node { - return true; - } - } - - false -} - -#[derive(Copy, Clone)] -pub struct BoolComparison; - -impl LintPass for BoolComparison { - fn get_lints(&self) -> LintArray { - lint_array!(BOOL_COMPARISON) - } - - fn name(&self) -> &'static str { - "BoolComparison" - } -} +declare_lint_pass!(BoolComparison => [BOOL_COMPARISON]); impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { - if in_macro(e.span) { + if e.span.from_expansion() { return; } - if let ExprKind::Binary(Spanned { node, .. }, ..) = e.node { + if let ExprKind::Binary(Spanned { node, .. }, ..) = e.kind { let ignore_case = None::<(fn(_) -> _, &str)>; let ignore_no_literal = None::<(fn(_, _) -> _, &str)>; match node { @@ -224,7 +194,7 @@ fn check_comparison<'a, 'tcx>( ) { use self::Expression::*; - if let ExprKind::Binary(_, ref left_side, ref right_side) = e.node { + if let ExprKind::Binary(_, ref left_side, ref right_side) = e.kind { let (l_ty, r_ty) = (cx.tables.expr_ty(left_side), cx.tables.expr_ty(right_side)); if l_ty.is_bool() && r_ty.is_bool() { let mut applicability = Applicability::MachineApplicable; @@ -290,8 +260,8 @@ 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 StmtKind::Semi(ref e) = e.node { - if let ExprKind::Ret(_) = e.node { + if let StmtKind::Semi(ref e) = e.kind { + if let ExprKind::Ret(_) = e.kind { fetch_bool_expr(&**e) } else { Expression::Other @@ -305,7 +275,7 @@ fn fetch_bool_block(block: &Block) -> Expression { } fn fetch_bool_expr(expr: &Expr) -> Expression { - match expr.node { + match expr.kind { ExprKind::Block(ref block, _) => fetch_bool_block(block), ExprKind::Lit(ref lit_ptr) => { if let LitKind::Bool(value) = lit_ptr.node {