//! Lint on unnecessary double comparisons. Some examples:
-use rustc::hir::*;
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
-use rustc::{declare_lint_pass, declare_tool_lint};
use rustc_errors::Applicability;
-use syntax::source_map::Span;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{eq_expr_value, snippet_with_applicability, span_lint_and_sugg};
declare_clippy_lint! {
/// **What it does:** Checks for double comparisons that could be simplified to a single expression.
declare_lint_pass!(DoubleComparisons => [DOUBLE_COMPARISONS]);
-impl<'a, 'tcx> DoubleComparisons {
+impl<'tcx> DoubleComparisons {
#[allow(clippy::similar_names)]
- fn check_binop(self, cx: &LateContext<'a, 'tcx>, op: BinOpKind, lhs: &'tcx Expr, rhs: &'tcx Expr, span: Span) {
- let (lkind, llhs, lrhs, rkind, rlhs, rrhs) = match (&lhs.node, &rhs.node) {
+ fn check_binop(cx: &LateContext<'tcx>, op: BinOpKind, lhs: &'tcx Expr<'_>, rhs: &'tcx Expr<'_>, span: Span) {
+ let (lkind, llhs, lrhs, rkind, rlhs, rrhs) = match (&lhs.kind, &rhs.kind) {
(ExprKind::Binary(lb, llhs, lrhs), ExprKind::Binary(rb, rlhs, rrhs)) => {
(lb.node, llhs, lrhs, rb.node, rlhs, rrhs)
},
_ => return,
};
- let mut spanless_eq = SpanlessEq::new(cx).ignore_fn();
- if !(spanless_eq.eq_expr(&llhs, &rlhs) && spanless_eq.eq_expr(&lrhs, &rrhs)) {
+ if !(eq_expr_value(cx, &llhs, &rlhs) && eq_expr_value(cx, &lrhs, &rrhs)) {
return;
}
macro_rules! lint_double_comparison {
cx,
DOUBLE_COMPARISONS,
span,
- "This binary expression can be simplified",
+ "this binary expression can be simplified",
"try",
sugg,
applicability,
}
}
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DoubleComparisons {
- fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
- if let ExprKind::Binary(ref kind, ref lhs, ref rhs) = expr.node {
- self.check_binop(cx, kind.node, lhs, rhs, expr.span);
+impl<'tcx> LateLintPass<'tcx> for DoubleComparisons {
+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ if let ExprKind::Binary(ref kind, ref lhs, ref rhs) = expr.kind {
+ Self::check_binop(cx, kind.node, lhs, rhs, expr.span);
}
}
}