src/tools/clippy/clippy_lints/src/unused_rounding.rs

   1 use clippy_utils::diagnostics::span_lint_and_sugg;
   2 use rustc_ast::ast::{Expr, ExprKind, LitFloatType, LitKind};
   3 use rustc_errors::Applicability;
   4 use rustc_lint::{EarlyContext, EarlyLintPass};
   5 use rustc_session::{declare_lint_pass, declare_tool_lint};
   6
   7 declare_clippy_lint! {
   8     /// ### What it does
   9     ///
  10     /// Detects cases where a whole-number literal float is being rounded, using
  11     /// the `floor`, `ceil`, or `round` methods.
  12     ///
  13     /// ### Why is this bad?
  14     ///
  15     /// This is unnecessary and confusing to the reader. Doing this is probably a mistake.
  16     ///
  17     /// ### Example
  18     /// ```rust
  19     /// let x = 1f32.ceil();
  20     /// ```
  21     /// Use instead:
  22     /// ```rust
  23     /// let x = 1f32;
  24     /// ```
  25     #[clippy::version = "1.63.0"]
  26     pub UNUSED_ROUNDING,
  27     nursery,
  28     "Uselessly rounding a whole number floating-point literal"
  29 }
  30 declare_lint_pass!(UnusedRounding => [UNUSED_ROUNDING]);
  31
  32 fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
  33     if let ExprKind::MethodCall(name_ident, receiver, _, _) = &expr.kind
  34         && let method_name = name_ident.ident.name.as_str()
  35         && (method_name == "ceil" || method_name == "round" || method_name == "floor")
  36         && let ExprKind::Lit(spanned) = &receiver.kind
  37         && let LitKind::Float(symbol, ty) = spanned.kind {
  38             let f = symbol.as_str().parse::<f64>().unwrap();
  39             let f_str = symbol.to_string() + if let LitFloatType::Suffixed(ty) = ty {
  40                 ty.name_str()
  41             } else {
  42                 ""
  43             };
  44             if f.fract() == 0.0 {
  45                 Some((method_name, f_str))
  46             } else {
  47                 None
  48             }
  49         } else {
  50             None
  51         }
  52 }
  53
  54 impl EarlyLintPass for UnusedRounding {
  55     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  56         if let Some((method_name, float)) = is_useless_rounding(expr) {
  57             span_lint_and_sugg(
  58                 cx,
  59                 UNUSED_ROUNDING,
  60                 expr.span,
  61                 &format!("used the `{method_name}` method with a whole number float"),
  62                 &format!("remove the `{method_name}` method call"),
  63                 float,
  64                 Applicability::MachineApplicable,
  65             );
  66         }
  67     }
  68 }