src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs

   1 use clippy_utils::diagnostics::span_lint;
   2 use clippy_utils::ty::implements_trait;
   3 use clippy_utils::{self, get_trait_def_id, paths};
   4 use if_chain::if_chain;
   5 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
   6 use rustc_lint::{LateContext, LateLintPass, LintContext};
   7 use rustc_middle::lint::in_external_macro;
   8 use rustc_session::{declare_lint_pass, declare_tool_lint};
   9
  10 declare_clippy_lint! {
  11     /// ### What it does
  12     /// Checks for the usage of negated comparison operators on types which only implement
  13     /// `PartialOrd` (e.g., `f64`).
  14     ///
  15     /// ### Why is this bad?
  16     /// These operators make it easy to forget that the underlying types actually allow not only three
  17     /// potential Orderings (Less, Equal, Greater) but also a fourth one (Uncomparable). This is
  18     /// especially easy to miss if the operator based comparison result is negated.
  19     ///
  20     /// ### Example
  21     /// ```rust
  22     /// use std::cmp::Ordering;
  23     ///
  24     /// // Bad
  25     /// let a = 1.0;
  26     /// let b = f64::NAN;
  27     ///
  28     /// let _not_less_or_equal = !(a <= b);
  29     ///
  30     /// // Good
  31     /// let a = 1.0;
  32     /// let b = f64::NAN;
  33     ///
  34     /// let _not_less_or_equal = match a.partial_cmp(&b) {
  35     ///     None | Some(Ordering::Greater) => true,
  36     ///     _ => false,
  37     /// };
  38     /// ```
  39     pub NEG_CMP_OP_ON_PARTIAL_ORD,
  40     complexity,
  41     "The use of negated comparison operators on partially ordered types may produce confusing code."
  42 }
  43
  44 declare_lint_pass!(NoNegCompOpForPartialOrd => [NEG_CMP_OP_ON_PARTIAL_ORD]);
  45
  46 impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
  47     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  48         if_chain! {
  49
  50             if !in_external_macro(cx.sess(), expr.span);
  51             if let ExprKind::Unary(UnOp::Not, inner) = expr.kind;
  52             if let ExprKind::Binary(ref op, left, _) = inner.kind;
  53             if let BinOpKind::Le | BinOpKind::Ge | BinOpKind::Lt | BinOpKind::Gt = op.node;
  54
  55             then {
  56
  57                 let ty = cx.typeck_results().expr_ty(left);
  58
  59                 let implements_ord = {
  60                     if let Some(id) = get_trait_def_id(cx, &paths::ORD) {
  61                         implements_trait(cx, ty, id, &[])
  62                     } else {
  63                         return;
  64                     }
  65                 };
  66
  67                 let implements_partial_ord = {
  68                     if let Some(id) = cx.tcx.lang_items().partial_ord_trait() {
  69                         implements_trait(cx, ty, id, &[])
  70                     } else {
  71                         return;
  72                     }
  73                 };
  74
  75                 if implements_partial_ord && !implements_ord {
  76                     span_lint(
  77                         cx,
  78                         NEG_CMP_OP_ON_PARTIAL_ORD,
  79                         expr.span,
  80                         "the use of negated comparison operators on partially ordered \
  81                         types produces code that is hard to read and refactor, please \
  82                         consider using the `partial_cmp` method instead, to make it \
  83                         clear that the two values could be incomparable"
  84                     );
  85                 }
  86             }
  87         }
  88     }
  89 }