float_cmp: Change allow_named_constants to an allow list.

Author: Jarcho

CHANGELOG.md

@@ -6045,6 +6045,9 @@ Released 2018-09-13
 [`enum-variant-name-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enum-variant-name-threshold
 [`enum-variant-size-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enum-variant-size-threshold
 [`excessive-nesting-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#excessive-nesting-threshold
+[`float-cmp-allowed-constants`]: https://doc.rust-lang.org/clippy/lint_configuration.html#float-cmp-allowed-constants
+[`float-cmp-ignore-change-detection`]: https://doc.rust-lang.org/clippy/lint_configuration.html#float-cmp-ignore-change-detection
+[`float-cmp-ignore-constant-comparisons`]: https://doc.rust-lang.org/clippy/lint_configuration.html#float-cmp-ignore-constant-comparisons
 [`future-size-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#future-size-threshold
 [`ignore-interior-mutability`]: https://doc.rust-lang.org/clippy/lint_configuration.html#ignore-interior-mutability
 [`large-error-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#large-error-threshold

book/src/lint_configuration.md

@@ -538,6 +538,59 @@ The maximum amount of nesting a block can reside in
 * [`excessive_nesting`](https://rust-lang.github.io/rust-clippy/master/index.html#excessive_nesting)
 
 
+## `float-cmp-allowed-constants`
+#### Example
+```no_run
+const VALUE: f64 = 1.0;
+fn is_value(x: f64) -> bool {
+    // Will warn unless `crate_name::VALUE` is allowed
+    x == VALUE
+}
+```
+
+**Default Value:** `[]`
+
+---
+**Affected lints:**
+* [`float_cmp`](https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp)
+
+
+## `float-cmp-ignore-change-detection`
+#### Example
+```no_run
+fn f(x: f64) -> bool {
+    // Will warn if the config is `false`
+    x == x + 1.0
+}
+```
+
+**Default Value:** `true`
+
+---
+**Affected lints:**
+* [`float_cmp`](https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp)
+
+
+## `float-cmp-ignore-constant-comparisons`
+#### Example
+```no_run
+const fn f(x: f64) -> f64 {
+    todo!()
+}
+
+// Will warn if the config is `false`
+if f(1.0) == f(2.0) {
+    // ...
+}
+```
+
+**Default Value:** `true`
+
+---
+**Affected lints:**
+* [`float_cmp`](https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp)
+
+
 ## `future-size-threshold`
 The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
 

clippy_config/src/conf.rs

@@ -647,17 +647,17 @@ define_Conf! {
     (warn_unsafe_macro_metavars_in_private_macros: bool = false),
     /// Lint: FLOAT_CMP
     ///
-    /// Whether to ignore comparisons to a named constnat
+    /// The list of constants which can be checked for exact equality.
     ///
     /// #### Example
     /// ```no_run
     /// const VALUE: f64 = 1.0;
     /// fn is_value(x: f64) -> bool {
-    ///     // Will warn if the config is `false`
+    ///     // Will warn unless `crate_name::VALUE` is allowed
     ///     x == VALUE
     /// }
     /// ```
-    (float_cmp_ignore_named_constants: bool = true),
+    (float_cmp_allowed_constants: Vec<String> = Vec::new()),
     /// Lint: FLOAT_CMP
     ///
     /// Whether to ignore comparisons which have a constant result.

clippy_lints/src/lib.rs

@@ -816,7 +816,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(manual_rem_euclid::ManualRemEuclid::new(conf)));
     store.register_late_pass(move |_| Box::new(manual_retain::ManualRetain::new(conf)));
     store.register_late_pass(move |_| Box::new(manual_rotate::ManualRotate));
-    store.register_late_pass(move |_| Box::new(operators::Operators::new(conf)));
+    store.register_late_pass(move |tcx| Box::new(operators::Operators::new(tcx, conf)));
     store.register_late_pass(|_| Box::<std_instead_of_core::StdReexports>::default());
     store.register_late_pass(move |_| Box::new(instant_subtraction::InstantSubtraction::new(conf)));
     store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));

clippy_lints/src/operators/float_cmp.rs

@@ -2,7 +2,7 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::visitors::{for_each_expr_without_closures, is_const_evaluatable};
-use clippy_utils::{get_item_name, is_expr_named_const, path_res, peel_hir_expr_while, SpanlessEq};
+use clippy_utils::{get_item_name, get_named_const_def_id, path_res, peel_hir_expr_while, SpanlessEq};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -14,7 +14,7 @@ use super::{FloatCmpConfig, FLOAT_CMP};
 
 pub(crate) fn check<'tcx>(
     cx: &LateContext<'tcx>,
-    config: FloatCmpConfig,
+    config: &FloatCmpConfig,
     expr: &'tcx Expr<'_>,
     op: BinOpKind,
     left: &'tcx Expr<'_>,
@@ -56,8 +56,8 @@ pub(crate) fn check<'tcx>(
             return;
         }
 
-        if config.ignore_named_constants
-            && (is_expr_named_const(cx, left_reduced) || is_expr_named_const(cx, right_reduced))
+        if get_named_const_def_id(cx, left_reduced).is_some_and(|id| config.allowed_constants.contains(&id))
+            || get_named_const_def_id(cx, right_reduced).is_some_and(|id| config.allowed_constants.contains(&id))
         {
             return;
         }

clippy_lints/src/operators/mod.rs

@@ -24,8 +24,11 @@ mod verbose_bit_mask;
 pub(crate) mod arithmetic_side_effects;
 
 use clippy_config::Conf;
+use clippy_utils::def_path_def_ids;
+use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TyCtxt;
 use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
@@ -774,9 +777,8 @@ declare_clippy_lint! {
     "explicit self-assignment"
 }
 
-#[derive(Clone, Copy)]
 struct FloatCmpConfig {
-    ignore_named_constants: bool,
+    allowed_constants: DefIdSet,
     ignore_constant_comparisons: bool,
     ignore_change_detection: bool,
 }
@@ -788,13 +790,17 @@ pub struct Operators {
     float_cmp_config: FloatCmpConfig,
 }
 impl Operators {
-    pub fn new(conf: &'static Conf) -> Self {
+    pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
         Self {
             arithmetic_context: numeric_arithmetic::Context::default(),
             verbose_bit_mask_threshold: conf.verbose_bit_mask_threshold,
             modulo_arithmetic_allow_comparison_to_zero: conf.allow_comparison_to_zero,
             float_cmp_config: FloatCmpConfig {
-                ignore_named_constants: conf.float_cmp_ignore_named_constants,
+                allowed_constants: conf
+                    .float_cmp_allowed_constants
+                    .iter()
+                    .flat_map(|x| def_path_def_ids(tcx, &x.split("::").collect::<Vec<_>>()))
+                    .collect(),
                 ignore_constant_comparisons: conf.float_cmp_ignore_constant_comparisons,
                 ignore_change_detection: conf.float_cmp_ignore_change_detection,
             },
@@ -854,7 +860,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 float_equality_without_abs::check(cx, e, op.node, lhs, rhs);
                 integer_division::check(cx, e, op.node, lhs, rhs);
                 cmp_owned::check(cx, op.node, lhs, rhs);
-                float_cmp::check(cx, self.float_cmp_config, e, op.node, lhs, rhs);
+                float_cmp::check(cx, &self.float_cmp_config, e, op.node, lhs, rhs);
                 modulo_one::check(cx, e, op.node, rhs);
                 modulo_arithmetic::check(
                     cx,

clippy_utils/src/lib.rs

@@ -245,14 +245,15 @@ pub fn is_inside_always_const_context(tcx: TyCtxt<'_>, hir_id: HirId) -> bool {
     }
 }
 
-/// Checks if the expression is path to either a constant or an associated constant.
-pub fn is_expr_named_const<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
-    matches!(&e.kind, ExprKind::Path(p)
-        if matches!(
-            cx.qpath_res(p, e.hir_id),
-            Res::Def(DefKind::Const | DefKind::AssocConst, _)
-        )
-    )
+/// If the expression is path to either a constant or an associated constant get the `DefId`.
+pub fn get_named_const_def_id<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option<DefId> {
+    if let ExprKind::Path(p) = &e.kind
+        && let Res::Def(DefKind::Const | DefKind::AssocConst, id) = cx.qpath_res(p, e.hir_id)
+    {
+        Some(id)
+    } else {
+        None
+    }
 }
 
 /// Checks if a `Res` refers to a constructor of a `LangItem`

tests/ui-toml/float_cmp/change_detect/clippy.toml

@@ -1 +1,6 @@
 float-cmp-ignore-change-detection = false
+float-cmp-allowed-constants = [
+    "core::f32::EPSILON",
+    "f32::EPSILON",
+    "test::F32_ARRAY",
+]

tests/ui-toml/float_cmp/const_cmp/clippy.toml

@@ -1 +1,6 @@
 float-cmp-ignore-constant-comparisons = false
+float-cmp-allowed-constants = [
+    "core::f32::EPSILON",
+    "f32::EPSILON",
+    "test::F32_ARRAY",
+]

tests/ui-toml/float_cmp/named_const/clippy.toml

@@ -1 +0,0 @@
-float-cmp-ignore-named-constants = false