fix

Author: chirizxc

crates/ruff_linter/resources/test/fixtures/ruff/RUF067.py

@@ -0,0 +1,18 @@
+a = 1.0
+b = 2.0
+x = 99
+
+if a is None: ...
+if a == 1: ...
+if a != b: ...
+if a > 1.0: ...
+
+assert x == 0.0
+print(3.14 != a)
+if x == 0.3: ...
+if x          ==       0.42: ...
+
+def foo(a, b):
+    return a == b - 0.1
+
+print(x == 3.0 == 3.0)

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -1632,6 +1632,9 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
             if checker.is_rule_enabled(Rule::YodaConditions) {
                 flake8_simplify::rules::yoda_conditions(checker, expr, left, ops, comparators);
             }
+            if checker.is_rule_enabled(Rule::FloatComparison) {
+                ruff::rules::float_comparison(checker, compare);
+            }
             if checker.is_rule_enabled(Rule::PandasNuniqueConstantSeriesCheck) {
                 pandas_vet::rules::nunique_constant_series_check(
                     checker,

crates/ruff_linter/src/codes.rs

@@ -1059,6 +1059,8 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "064") => rules::ruff::rules::NonOctalPermissions,
         (Ruff, "065") => rules::ruff::rules::LoggingEagerConversion,
 
+        (Ruff, "067") => rules::ruff::rules::FloatComparison,
+
         (Ruff, "100") => rules::ruff::rules::UnusedNOQA,
         (Ruff, "101") => rules::ruff::rules::RedirectedNOQA,
         (Ruff, "102") => rules::ruff::rules::InvalidRuleCode,

crates/ruff_linter/src/rules/ruff/mod.rs

@@ -565,6 +565,7 @@ mod tests {
     #[test_case(Rule::UnnecessaryRegularExpression, Path::new("RUF055_3.py"))]
     #[test_case(Rule::IndentedFormFeed, Path::new("RUF054.py"))]
     #[test_case(Rule::ImplicitClassVarInDataclass, Path::new("RUF045.py"))]
+    #[test_case(Rule::FloatComparison, Path::new("RUF067.py"))]
     fn preview_rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!(
             "preview__{}_{}",

crates/ruff_linter/src/rules/ruff/rules/float_comparison.rs

@@ -0,0 +1,94 @@
+use itertools::Itertools;
+use ruff_macros::{ViolationMetadata, derive_message_formats};
+use ruff_python_ast::{self as ast, CmpOp, Expr};
+use ruff_text_size::{Ranged, TextRange};
+
+use crate::checkers::ast::Checker;
+use crate::{FixAvailability, Violation};
+
+/// ## What it does
+/// Checks for comparisons between floating-point values using `==` or `!=`.
+///
+/// ## Why is this bad?
+/// Directly comparing floats can produce unreliable results due to the
+/// inherent imprecision of floating-point arithmetic.
+///
+/// ## When to use `math.isclose()` vs `numpy.isclose()`
+///
+/// **Use `math.isclose()` for scalar values:**
+/// - Comparing individual float numbers
+/// - Working with regular Python variables (not arrays)
+/// - When you need a single `True`/`False` result
+///
+/// **Use `numpy.isclose()` for array-like objects:**
+/// - Comparing `pandas` Series, `numpy` arrays, or other vectorized objects
+/// - When you need element-wise comparison of arrays
+/// - Working in data science contexts with vectorized operations
+///
+/// ## Example
+/// ```python
+/// assert 0.1 + 0.2 == 0.3  # AssertionError
+/// ```
+/// Use instead:
+/// ```python
+/// import math
+///
+/// # Scalar comparison
+/// assert math.isclose(0.1 + 0.2, 0.3, abs_tol=1e-9)
+/// ```
+/// ## References
+/// - [Python documentation: `math.isclose`](https://docs.python.org/3/library/math.html#math.isclose)
+/// - [NumPy documentation: `numpy.isclose`](https://numpy.org/doc/stable/reference/generated/numpy.isclose.html#numpy-isclose)
+#[derive(ViolationMetadata)]
+#[violation_metadata(preview_since = "0.14.3")]
+pub(crate) struct FloatComparison {
+    pub left: String,
+    pub right: String,
+    pub operand: String,
+}
+
+impl Violation for FloatComparison {
+    const FIX_AVAILABILITY: FixAvailability = FixAvailability::Sometimes;
+
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        format!(
+            "Comparison `{} {} {}` should be replaced by `math.isclose()` or `numpy.isclose()`",
+            self.left, self.operand, self.right,
+        )
+    }
+}
+
+/// RUF067
+pub(crate) fn float_comparison(checker: &Checker, compare: &ast::ExprCompare) {
+    let locator = checker.locator();
+
+    for (left, right, operand) in std::iter::once(&*compare.left)
+        .chain(&compare.comparators)
+        .tuple_windows()
+        .zip(&compare.ops)
+        .filter(|(_, op)| matches!(op, CmpOp::Eq | CmpOp::NotEq))
+        .filter(|((left, right), _)| has_float(left) || has_float(right))
+        .map(|((left, right), op)| (left, right, op))
+    {
+        checker.report_diagnostic(
+            FloatComparison {
+                left: locator.slice(left.range()).to_string(),
+                right: locator.slice(right.range()).to_string(),
+                operand: operand.to_string(),
+            },
+            TextRange::new(left.start(), right.end()),
+        );
+    }
+}
+
+fn has_float(expr: &Expr) -> bool {
+    match expr {
+        Expr::NumberLiteral(ast::ExprNumberLiteral { value, .. }) => {
+            matches!(value, ast::Number::Float(_))
+        }
+        Expr::BinOp(ast::ExprBinOp { left, right, .. }) => has_float(left) || has_float(right),
+        Expr::UnaryOp(ast::ExprUnaryOp { operand, .. }) => has_float(operand),
+        _ => false,
+    }
+}

crates/ruff_linter/src/rules/ruff/rules/mod.rs

@@ -10,6 +10,7 @@ pub(crate) use decimal_from_float_literal::*;
 pub(crate) use default_factory_kwarg::*;
 pub(crate) use explicit_f_string_type_conversion::*;
 pub(crate) use falsy_dict_get_fallback::*;
+pub(crate) use float_comparison::*;
 pub(crate) use function_call_in_dataclass_default::*;
 pub(crate) use if_key_in_dict_del::*;
 pub(crate) use implicit_classvar_in_dataclass::*;
@@ -74,6 +75,7 @@ mod decimal_from_float_literal;
 mod default_factory_kwarg;
 mod explicit_f_string_type_conversion;
 mod falsy_dict_get_fallback;
+mod float_comparison;
 mod function_call_in_dataclass_default;
 mod if_key_in_dict_del;
 mod implicit_classvar_in_dataclass;