9afd8abbe3
Most of these are just `#![allow]`ed, because they are things like using l vs r to differentiate left vs right. These would be made less clear by taking the advice of `similar_names`
98 lines
3.4 KiB
Rust
98 lines
3.4 KiB
Rust
// 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.
|
|
|
|
|
|
//! Lint on unnecessary double comparisons. Some examples:
|
|
|
|
use crate::rustc::hir::*;
|
|
use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
|
|
use crate::rustc::{declare_tool_lint, lint_array};
|
|
use crate::syntax::source_map::Span;
|
|
|
|
use crate::utils::{snippet, span_lint_and_sugg, SpanlessEq};
|
|
|
|
/// **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
|
|
/// ```
|
|
declare_clippy_lint! {
|
|
pub DOUBLE_COMPARISONS,
|
|
complexity,
|
|
"unnecessary double comparisons that can be simplified"
|
|
}
|
|
|
|
pub struct DoubleComparisonPass;
|
|
|
|
impl LintPass for DoubleComparisonPass {
|
|
fn get_lints(&self) -> LintArray {
|
|
lint_array!(DOUBLE_COMPARISONS)
|
|
}
|
|
}
|
|
|
|
impl<'a, 'tcx> DoubleComparisonPass {
|
|
#[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.clone(), rhs.node.clone()) {
|
|
(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)) {
|
|
return;
|
|
}
|
|
macro_rules! lint_double_comparison {
|
|
($op:tt) => {{
|
|
let lhs_str = snippet(cx, llhs.span, "");
|
|
let rhs_str = snippet(cx, lrhs.span, "");
|
|
let sugg = format!("{} {} {}", lhs_str, stringify!($op), rhs_str);
|
|
span_lint_and_sugg(cx, DOUBLE_COMPARISONS, span,
|
|
"This binary expression can be simplified",
|
|
"try", sugg);
|
|
}}
|
|
}
|
|
match (op, lkind, rkind) {
|
|
(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!(==),
|
|
_ => (),
|
|
};
|
|
}
|
|
}
|
|
|
|
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DoubleComparisonPass {
|
|
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);
|
|
}
|
|
}
|
|
}
|