src/tools/clippy/clippy_lints/src/float_equality_without_abs.rs

   1 use clippy_utils::diagnostics::span_lint_and_then;
   2 use clippy_utils::{match_def_path, paths, sugg};
   3 use if_chain::if_chain;
   4 use rustc_ast::util::parser::AssocOp;
   5 use rustc_errors::Applicability;
   6 use rustc_hir::def::{DefKind, Res};
   7 use rustc_hir::{BinOpKind, Expr, ExprKind};
   8 use rustc_lint::{LateContext, LateLintPass};
   9 use rustc_middle::ty;
  10 use rustc_session::{declare_lint_pass, declare_tool_lint};
  11 use rustc_span::source_map::Spanned;
  12
  13 declare_clippy_lint! {
  14     /// ### What it does
  15     /// Checks for statements of the form `(a - b) < f32::EPSILON` or
  16     /// `(a - b) < f64::EPSILON`. Notes the missing `.abs()`.
  17     ///
  18     /// ### Why is this bad?
  19     /// The code without `.abs()` is more likely to have a bug.
  20     ///
  21     /// ### Known problems
  22     /// If the user can ensure that b is larger than a, the `.abs()` is
  23     /// technically unnecessary. However, it will make the code more robust and doesn't have any
  24     /// large performance implications. If the abs call was deliberately left out for performance
  25     /// reasons, it is probably better to state this explicitly in the code, which then can be done
  26     /// with an allow.
  27     ///
  28     /// ### Example
  29     /// ```rust
  30     /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
  31     ///     (a - b) < f32::EPSILON
  32     /// }
  33     /// ```
  34     /// Use instead:
  35     /// ```rust
  36     /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
  37     ///     (a - b).abs() < f32::EPSILON
  38     /// }
  39     /// ```
  40     #[clippy::version = "1.48.0"]
  41     pub FLOAT_EQUALITY_WITHOUT_ABS,
  42     suspicious,
  43     "float equality check without `.abs()`"
  44 }
  45
  46 declare_lint_pass!(FloatEqualityWithoutAbs => [FLOAT_EQUALITY_WITHOUT_ABS]);
  47
  48 impl<'tcx> LateLintPass<'tcx> for FloatEqualityWithoutAbs {
  49     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  50         let lhs;
  51         let rhs;
  52
  53         // check if expr is a binary expression with a lt or gt operator
  54         if let ExprKind::Binary(op, left, right) = expr.kind {
  55             match op.node {
  56                 BinOpKind::Lt => {
  57                     lhs = left;
  58                     rhs = right;
  59                 },
  60                 BinOpKind::Gt => {
  61                     lhs = right;
  62                     rhs = left;
  63                 },
  64                 _ => return,
  65             };
  66         } else {
  67             return;
  68         }
  69
  70         if_chain! {
  71
  72             // left hand side is a subtraction
  73             if let ExprKind::Binary(
  74                 Spanned {
  75                     node: BinOpKind::Sub,
  76                     ..
  77                 },
  78                 val_l,
  79                 val_r,
  80             ) = lhs.kind;
  81
  82             // right hand side matches either f32::EPSILON or f64::EPSILON
  83             if let ExprKind::Path(ref epsilon_path) = rhs.kind;
  84             if let Res::Def(DefKind::AssocConst, def_id) = cx.qpath_res(epsilon_path, rhs.hir_id);
  85             if match_def_path(cx, def_id, &paths::F32_EPSILON) || match_def_path(cx, def_id, &paths::F64_EPSILON);
  86
  87             // values of the subtractions on the left hand side are of the type float
  88             let t_val_l = cx.typeck_results().expr_ty(val_l);
  89             let t_val_r = cx.typeck_results().expr_ty(val_r);
  90             if let ty::Float(_) = t_val_l.kind();
  91             if let ty::Float(_) = t_val_r.kind();
  92
  93             then {
  94                 let sug_l = sugg::Sugg::hir(cx, val_l, "..");
  95                 let sug_r = sugg::Sugg::hir(cx, val_r, "..");
  96                 // format the suggestion
  97                 let suggestion = format!("{}.abs()", sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par());
  98                 // spans the lint
  99                 span_lint_and_then(
 100                     cx,
 101                     FLOAT_EQUALITY_WITHOUT_ABS,
 102                     expr.span,
 103                     "float equality check without `.abs()`",
 104                     | diag | {
 105                         diag.span_suggestion(
 106                             lhs.span,
 107                             "add `.abs()`",
 108                             suggestion,
 109                             Applicability::MaybeIncorrect,
 110                         );
 111                     }
 112                 );
 113             }
 114         }
 115     }
 116 }