2018-10-06 16:18:06 +00:00
|
|
|
// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2018-01-30 01:35:35 +00:00
|
|
|
//! Lint on unnecessary double comparisons. Some examples:
|
|
|
|
|
2018-09-15 07:21:58 +00:00
|
|
|
use crate::rustc::hir::*;
|
|
|
|
use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
|
|
|
|
use crate::rustc::{declare_tool_lint, lint_array};
|
2018-11-20 13:06:29 +00:00
|
|
|
use crate::rustc_errors::Applicability;
|
2018-09-15 07:21:58 +00:00
|
|
|
use crate::syntax::source_map::Span;
|
2018-01-30 01:35:35 +00:00
|
|
|
|
2018-11-27 14:13:57 +00:00
|
|
|
use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
|
2018-01-30 01:35:35 +00:00
|
|
|
|
|
|
|
/// **What it does:** Checks for double comparions that could be simpified to a single expression.
|
|
|
|
///
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** Readability.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// x == y || x < y
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// Could be written as:
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// x <= y
|
|
|
|
/// ```
|
2018-03-28 13:24:26 +00:00
|
|
|
declare_clippy_lint! {
|
2018-01-30 01:35:35 +00:00
|
|
|
pub DOUBLE_COMPARISONS,
|
2018-03-28 13:24:26 +00:00
|
|
|
complexity,
|
2018-01-30 01:35:35 +00:00
|
|
|
"unnecessary double comparisons that can be simplified"
|
|
|
|
}
|
|
|
|
|
2018-10-13 00:07:48 +00:00
|
|
|
pub struct Pass;
|
2018-01-30 01:35:35 +00:00
|
|
|
|
2018-10-13 00:07:48 +00:00
|
|
|
impl LintPass for Pass {
|
2018-01-30 01:35:35 +00:00
|
|
|
fn get_lints(&self) -> LintArray {
|
|
|
|
lint_array!(DOUBLE_COMPARISONS)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-13 00:07:48 +00:00
|
|
|
impl<'a, 'tcx> Pass {
|
2018-10-11 22:18:58 +00:00
|
|
|
#[allow(clippy::similar_names)]
|
2018-11-27 20:14:15 +00:00
|
|
|
fn check_binop(&self, cx: &LateContext<'a, 'tcx>, op: BinOpKind, lhs: &'tcx Expr, rhs: &'tcx Expr, span: Span) {
|
2018-01-30 01:35:35 +00:00
|
|
|
let (lkind, llhs, lrhs, rkind, rlhs, rrhs) = match (lhs.node.clone(), rhs.node.clone()) {
|
2018-07-12 07:30:57 +00:00
|
|
|
(ExprKind::Binary(lb, llhs, lrhs), ExprKind::Binary(rb, rlhs, rrhs)) => {
|
2018-01-30 01:35:35 +00:00
|
|
|
(lb.node, llhs, lrhs, rb.node, rlhs, rrhs)
|
2018-11-27 20:14:15 +00:00
|
|
|
},
|
2018-01-30 01:35:35 +00:00
|
|
|
_ => return,
|
|
|
|
};
|
2018-05-17 18:17:21 +00:00
|
|
|
let mut spanless_eq = SpanlessEq::new(cx).ignore_fn();
|
2018-01-30 01:35:35 +00:00
|
|
|
if !(spanless_eq.eq_expr(&llhs, &rlhs) && spanless_eq.eq_expr(&lrhs, &rrhs)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
macro_rules! lint_double_comparison {
|
|
|
|
($op:tt) => {{
|
2018-11-27 14:13:57 +00:00
|
|
|
let mut applicability = Applicability::MachineApplicable;
|
|
|
|
let lhs_str = snippet_with_applicability(cx, llhs.span, "", &mut applicability);
|
|
|
|
let rhs_str = snippet_with_applicability(cx, lrhs.span, "", &mut applicability);
|
2018-01-30 01:35:35 +00:00
|
|
|
let sugg = format!("{} {} {}", lhs_str, stringify!($op), rhs_str);
|
2018-11-20 13:06:29 +00:00
|
|
|
span_lint_and_sugg(
|
|
|
|
cx,
|
|
|
|
DOUBLE_COMPARISONS,
|
|
|
|
span,
|
|
|
|
"This binary expression can be simplified",
|
|
|
|
"try",
|
|
|
|
sugg,
|
2018-11-27 14:13:57 +00:00
|
|
|
applicability,
|
2018-11-20 13:06:29 +00:00
|
|
|
);
|
2018-11-27 20:14:15 +00:00
|
|
|
}};
|
2018-01-30 01:35:35 +00:00
|
|
|
}
|
|
|
|
match (op, lkind, rkind) {
|
2018-11-27 20:14:15 +00:00
|
|
|
(BinOpKind::Or, BinOpKind::Eq, BinOpKind::Lt) | (BinOpKind::Or, BinOpKind::Lt, BinOpKind::Eq) => {
|
|
|
|
lint_double_comparison!(<=)
|
|
|
|
},
|
|
|
|
(BinOpKind::Or, BinOpKind::Eq, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Eq) => {
|
|
|
|
lint_double_comparison!(>=)
|
|
|
|
},
|
|
|
|
(BinOpKind::Or, BinOpKind::Lt, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Lt) => {
|
|
|
|
lint_double_comparison!(!=)
|
|
|
|
},
|
|
|
|
(BinOpKind::And, BinOpKind::Le, BinOpKind::Ge) | (BinOpKind::And, BinOpKind::Ge, BinOpKind::Le) => {
|
|
|
|
lint_double_comparison!(==)
|
|
|
|
},
|
2018-01-30 01:35:35 +00:00
|
|
|
_ => (),
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-13 00:07:48 +00:00
|
|
|
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
|
2018-01-30 01:35:35 +00:00
|
|
|
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
|
2018-07-12 07:30:57 +00:00
|
|
|
if let ExprKind::Binary(ref kind, ref lhs, ref rhs) = expr.node {
|
2018-01-30 01:35:35 +00:00
|
|
|
self.check_binop(cx, kind.node, lhs, rhs, expr.span);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|