add manual_abs_diff lint

yotamofek · yotamofek · commit dfc3d1378ee1 · 2025-03-26T22:37:13.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5784,6 +5784,7 @@ Released 2018-09-13
 [`macro_metavars_in_unsafe`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_metavars_in_unsafe
 [`macro_use_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_use_imports
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
+[`manual_abs_diff`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_abs_diff
 [`manual_assert`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
@@ -797,6 +797,7 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`iter_kv_map`](https://rust-lang.github.io/rust-clippy/master/index.html#iter_kv_map)
 * [`legacy_numeric_constants`](https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants)
 * [`lines_filter_map_ok`](https://rust-lang.github.io/rust-clippy/master/index.html#lines_filter_map_ok)
+* [`manual_abs_diff`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_abs_diff)
 * [`manual_bits`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits)
 * [`manual_c_str_literals`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_c_str_literals)
 * [`manual_clamp`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp)
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
@@ -645,6 +645,7 @@ define_Conf! {
         iter_kv_map,
         legacy_numeric_constants,
         lines_filter_map_ok,
+        manual_abs_diff,
         manual_bits,
         manual_c_str_literals,
         manual_clamp,
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
@@ -313,6 +313,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::macro_metavars_in_unsafe::MACRO_METAVARS_IN_UNSAFE_INFO,
     crate::macro_use::MACRO_USE_IMPORTS_INFO,
     crate::main_recursion::MAIN_RECURSION_INFO,
+    crate::manual_abs_diff::MANUAL_ABS_DIFF_INFO,
     crate::manual_assert::MANUAL_ASSERT_INFO,
     crate::manual_async_fn::MANUAL_ASYNC_FN_INFO,
     crate::manual_bits::MANUAL_BITS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
@@ -205,6 +205,7 @@ mod loops;
 mod macro_metavars_in_unsafe;
 mod macro_use;
 mod main_recursion;
+mod manual_abs_diff;
 mod manual_assert;
 mod manual_async_fn;
 mod manual_bits;
@@ -878,6 +879,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(std_instead_of_core::StdReexports::new(conf)));
     store.register_late_pass(move |_| Box::new(instant_subtraction::InstantSubtraction::new(conf)));
     store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));
+    store.register_late_pass(move |_| Box::new(manual_abs_diff::ManualAbsDiff::new(conf)));
     store.register_late_pass(move |_| Box::new(manual_clamp::ManualClamp::new(conf)));
     store.register_late_pass(|_| Box::new(manual_string_new::ManualStringNew));
     store.register_late_pass(|_| Box::new(unused_peekable::UnusedPeekable));
diff --git a/clippy_lints/src/manual_abs_diff.rs b/clippy_lints/src/manual_abs_diff.rs
@@ -0,0 +1,149 @@
+use clippy_config::Conf;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher::If;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{eq_expr_value, peel_blocks};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::impl_lint_pass;
+use rustc_span::Span;
+use rustc_span::source_map::Spanned;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects patterns like `if a > b { a - b } else { b - a }` and suggests using `a.abs_diff(b)`.
+    ///
+    /// ### Why is this bad?
+    /// Using `abs_diff` is shorter, more readable, and avoids control flow.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// # let (a, b) = (5_usize, 3_usize);
+    /// if a > b {
+    ///     a - b
+    /// } else {
+    ///     b - a
+    /// }
+    /// # ;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let (a, b) = (5_usize, 3_usize);
+    /// a.abs_diff(b)
+    /// # ;
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub MANUAL_ABS_DIFF,
+    complexity,
+    "using an if-else pattern instead of `abs_diff`"
+}
+
+impl_lint_pass!(ManualAbsDiff => [MANUAL_ABS_DIFF]);
+
+pub struct ManualAbsDiff {
+    msrv: Msrv,
+}
+
+impl ManualAbsDiff {
+    pub fn new(conf: &'static Conf) -> Self {
+        Self { msrv: conf.msrv }
+    }
+}
+
+#[derive(Debug)]
+struct Suggestion<'tcx> {
+    params: Input<'tcx>,
+    span: Span,
+}
+
+#[derive(Debug)]
+struct Input<'tcx> {
+    a: &'tcx Expr<'tcx>,
+    b: &'tcx Expr<'tcx>,
+}
+
+impl<'tcx> LateLintPass<'tcx> for ManualAbsDiff {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if !expr.span.from_expansion()
+            && self.msrv.meets(cx, msrvs::ABS_DIFF)
+            && let Some(suggestion) = is_manual_abs_diff_pattern(cx, expr)
+        {
+            emit_suggestion(cx, &suggestion);
+        }
+    }
+}
+
+/// Checks if the given expression is a subtraction operation between two expected expressions, i.e.
+/// if `expr` is `{expected_a} - {expected_b}`.
+fn is_sub_expr(cx: &LateContext<'_>, expr: &Expr<'_>, expected_a: &Expr<'_>, expected_b: &Expr<'_>) -> bool {
+    matches!(
+        peel_blocks(expr).kind,
+        ExprKind::Binary(
+            Spanned {
+                node: BinOpKind::Sub,
+                ..
+            },
+            a,
+            b,
+        )
+        if eq_expr_value(cx, a, expected_a) && eq_expr_value(cx, b, expected_b)
+    )
+}
+
+/// Matches a pattern such as `if a > b { a - b } else { b - a }`
+fn is_manual_abs_diff_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<Suggestion<'tcx>> {
+    if let Some(If {
+        cond,
+        then,
+        r#else: Some(r#else),
+    }) = If::hir(expr)
+        && let ExprKind::Binary(
+            Spanned {
+                node: BinOpKind::Gt, ..
+            },
+            a,
+            b,
+        )
+        | ExprKind::Binary(
+            Spanned {
+                node: BinOpKind::Lt, ..
+            },
+            b,
+            a,
+        ) = cond.kind
+        && is_sub_expr(cx, then, a, b)
+        && is_sub_expr(cx, r#else, b, a)
+    {
+        Some(Suggestion {
+            params: Input { a, b },
+            span: expr.span,
+        })
+    } else {
+        None
+    }
+}
+
+fn emit_suggestion<'tcx>(cx: &LateContext<'tcx>, suggestion: &Suggestion<'tcx>) {
+    let Suggestion {
+        params: Input { a, b, .. },
+        span,
+        ..
+    } = suggestion;
+
+    let a = Sugg::hir(cx, a, "..").maybe_paren();
+    let b = Sugg::hir(cx, b, "..");
+    let suggestion = format!("{a}.abs_diff({b})");
+    let msg = "manual absolute difference pattern without using `abs_diff`";
+    let help = "replace with `abs_diff`";
+    span_lint_and_sugg(
+        cx,
+        MANUAL_ABS_DIFF,
+        *span,
+        msg,
+        help,
+        suggestion,
+        Applicability::MachineApplicable,
+    );
+}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
@@ -40,6 +40,7 @@ msrv_aliases! {
     1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
     1,63,0 { CLONE_INTO }
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, CONST_EXTERN_C_FN }
+    1,60,0 { ABS_DIFF }
     1,59,0 { THREAD_LOCAL_CONST_INIT }
     1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY, CONST_RAW_PTR_DEREF }
     1,57,0 { MAP_WHILE }
diff --git a/tests/ui/manual_abs_diff.fixed b/tests/ui/manual_abs_diff.fixed
@@ -0,0 +1,63 @@
+#![warn(clippy::manual_abs_diff)]
+
+fn main() {
+    let a: usize = 5;
+    let b: usize = 3;
+    let c: usize = 8;
+    let d: usize = 11;
+
+    let _ = a.abs_diff(b);
+    //~^ manual_abs_diff
+    let _ = b.abs_diff(a);
+    //~^ manual_abs_diff
+
+    #[allow(arithmetic_overflow)]
+    {
+        let _ = if a > b { b - a } else { a - b };
+        let _ = if a < b { a - b } else { b - a };
+    }
+
+    let _ = (a + b).abs_diff(c + d);
+    let _ = (c + d).abs_diff(a + b);
+
+    const A: usize = 5;
+    const B: usize = 3;
+    // check const context
+    const _: usize = A.abs_diff(B);
+    //~^ manual_abs_diff
+}
+
+// FIXME: bunch of patterns that should be linted
+fn fixme() {
+    let a: usize = 5;
+    let b: usize = 3;
+    let c: usize = 8;
+    let d: usize = 11;
+
+    {
+        let out;
+        if a > b {
+            out = a - b;
+        } else {
+            out = b - a;
+        }
+    }
+
+    {
+        let mut out = 0;
+        if a > b {
+            out = a - b;
+        } else if a < b {
+            out = b - a;
+        }
+    }
+
+    #[allow(clippy::implicit_saturating_sub)]
+    let _ = if a > b {
+        a - b
+    } else if a < b {
+        b - a
+    } else {
+        0
+    };
+}
diff --git a/tests/ui/manual_abs_diff.rs b/tests/ui/manual_abs_diff.rs
@@ -0,0 +1,73 @@
+#![warn(clippy::manual_abs_diff)]
+
+fn main() {
+    let a: usize = 5;
+    let b: usize = 3;
+    let c: usize = 8;
+    let d: usize = 11;
+
+    let _ = if a > b { a - b } else { b - a };
+    //~^ manual_abs_diff
+    let _ = if a < b { b - a } else { a - b };
+    //~^ manual_abs_diff
+
+    #[allow(arithmetic_overflow)]
+    {
+        let _ = if a > b { b - a } else { a - b };
+        let _ = if a < b { a - b } else { b - a };
+    }
+
+    let _ = if (a + b) > (c + d) {
+        //~^ manual_abs_diff
+        (a + b) - (c + d)
+    } else {
+        (c + d) - (a + b)
+    };
+    let _ = if (a + b) < (c + d) {
+        //~^ manual_abs_diff
+        (c + d) - (a + b)
+    } else {
+        (a + b) - (c + d)
+    };
+
+    const A: usize = 5;
+    const B: usize = 3;
+    // check const context
+    const _: usize = if A > B { A - B } else { B - A };
+    //~^ manual_abs_diff
+}
+
+// FIXME: bunch of patterns that should be linted
+fn fixme() {
+    let a: usize = 5;
+    let b: usize = 3;
+    let c: usize = 8;
+    let d: usize = 11;
+
+    {
+        let out;
+        if a > b {
+            out = a - b;
+        } else {
+            out = b - a;
+        }
+    }
+
+    {
+        let mut out = 0;
+        if a > b {
+            out = a - b;
+        } else if a < b {
+            out = b - a;
+        }
+    }
+
+    #[allow(clippy::implicit_saturating_sub)]
+    let _ = if a > b {
+        a - b
+    } else if a < b {
+        b - a
+    } else {
+        0
+    };
+}
diff --git a/tests/ui/manual_abs_diff.stderr b/tests/ui/manual_abs_diff.stderr
@@ -0,0 +1,47 @@
+error: manual absolute difference pattern without using `abs_diff`
+  --> tests/ui/manual_abs_diff.rs:9:13
+   |
+LL |     let _ = if a > b { a - b } else { b - a };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `abs_diff`: `a.abs_diff(b)`
+   |
+   = note: `-D clippy::manual-abs-diff` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::manual_abs_diff)]`
+
+error: manual absolute difference pattern without using `abs_diff`
+  --> tests/ui/manual_abs_diff.rs:11:13
+   |
+LL |     let _ = if a < b { b - a } else { a - b };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `abs_diff`: `b.abs_diff(a)`
+
+error: manual absolute difference pattern without using `abs_diff`
+  --> tests/ui/manual_abs_diff.rs:20:13
+   |
+LL |       let _ = if (a + b) > (c + d) {
+   |  _____________^
+LL | |
+LL | |         (a + b) - (c + d)
+LL | |     } else {
+LL | |         (c + d) - (a + b)
+LL | |     };
+   | |_____^ help: replace with `abs_diff`: `(a + b).abs_diff(c + d)`
+
+error: manual absolute difference pattern without using `abs_diff`
+  --> tests/ui/manual_abs_diff.rs:26:13
+   |
+LL |       let _ = if (a + b) < (c + d) {
+   |  _____________^
+LL | |
+LL | |         (c + d) - (a + b)
+LL | |     } else {
+LL | |         (a + b) - (c + d)
+LL | |     };
+   | |_____^ help: replace with `abs_diff`: `(c + d).abs_diff(a + b)`
+
+error: manual absolute difference pattern without using `abs_diff`
+  --> tests/ui/manual_abs_diff.rs:36:22
+   |
+LL |     const _: usize = if A > B { A - B } else { B - A };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `abs_diff`: `A.abs_diff(B)`
+
+error: aborting due to 5 previous errors
+
