feat(manual_assert_eq): new lint

Author: ada4a

CHANGELOG.md

@@ -6526,6 +6526,7 @@ Released 2018-09-13
 [`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_assert_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert_eq
 [`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
 [`manual_c_str_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_c_str_literals

clippy_lints/src/declared_lints.rs

@@ -292,6 +292,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::main_recursion::MAIN_RECURSION_INFO,
     crate::manual_abs_diff::MANUAL_ABS_DIFF_INFO,
     crate::manual_assert::MANUAL_ASSERT_INFO,
+    crate::manual_assert_eq::MANUAL_ASSERT_EQ_INFO,
     crate::manual_async_fn::MANUAL_ASYNC_FN_INFO,
     crate::manual_bits::MANUAL_BITS_INFO,
     crate::manual_clamp::MANUAL_CLAMP_INFO,

clippy_lints/src/eta_reduction.rs

@@ -371,7 +371,7 @@ fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig: FnSig<'
         }
     }
 
-    assert!(from_sig.inputs_and_output.len() == to_sig.inputs_and_output.len());
+    assert_eq!(from_sig.inputs_and_output.len(), to_sig.inputs_and_output.len());
     from_sig
         .inputs_and_output
         .iter()

clippy_lints/src/functions/renamed_function_params.rs

@@ -57,7 +57,7 @@ impl RenamedFnArgs {
     {
         let mut renamed: Vec<(Span, String)> = vec![];
 
-        debug_assert!(default_idents.size_hint() == current_idents.size_hint());
+        debug_assert_eq!(default_idents.size_hint(), current_idents.size_hint());
         for (default_ident, current_ident) in iter::zip(default_idents, current_idents) {
             let has_name_to_check = |ident: Option<Ident>| {
                 ident

clippy_lints/src/lib.rs

@@ -195,6 +195,7 @@ mod macro_use;
 mod main_recursion;
 mod manual_abs_diff;
 mod manual_assert;
+mod manual_assert_eq;
 mod manual_async_fn;
 mod manual_bits;
 mod manual_clamp;
@@ -819,5 +820,6 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(toplevel_ref_arg::ToplevelRefArg));
     store.register_late_pass(|_| Box::new(volatile_composites::VolatileComposites));
     store.register_late_pass(|_| Box::new(replace_box::ReplaceBox::default()));
+    store.register_late_pass(|_| Box::new(manual_assert_eq::ManualAssertEq));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }

clippy_lints/src/manual_assert_eq.rs

@@ -0,0 +1,82 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::macros::{find_assert_args, root_macro_call_first_node};
+use clippy_utils::source::walk_span_to_context;
+use clippy_utils::{is_in_const_context, sym};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::declare_lint_pass;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `assert!` and `debug_assert!` that consist of only an (in)equality check
+    ///
+    /// ### Why is this bad?
+    /// `assert_{eq,ne}!` and `debug_assert_{eq,ne}!` achieves the same goal, and provides some
+    /// additional debug information
+    ///
+    /// ### Example
+    /// ```no_run
+    /// assert!(2 * 2 == 4);
+    /// assert!(2 * 2 != 5);
+    /// debug_assert!(2 * 2 == 4);
+    /// debug_assert!(2 * 2 != 5);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// assert_eq!(2 * 2, 4);
+    /// assert_ne!(2 * 2, 5);
+    /// debug_assert_eq!(2 * 2, 4);
+    /// debug_assert_ne!(2 * 2, 5);
+    /// ```
+    #[clippy::version = "1.92.0"]
+    pub MANUAL_ASSERT_EQ,
+    complexity,
+    "checks for assertions consisting of an (in)equality check"
+}
+declare_lint_pass!(ManualAssertEq => [MANUAL_ASSERT_EQ]);
+
+impl LateLintPass<'_> for ManualAssertEq {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if let Some(macro_call) = root_macro_call_first_node(cx, expr)
+            && let macro_name = cx.tcx.item_name(macro_call.def_id)
+            && matches!(macro_name, sym::assert | sym::debug_assert)
+            // `assert_eq` isn't allowed in const context because it calls non-const `core::panicking::assert_failed`
+            // XXX: this might change in the future, so might want to relax this restriction
+            && !is_in_const_context(cx)
+            && let Some((cond, _)) = find_assert_args(cx, expr, macro_call.expn)
+            && let ExprKind::Binary(op, lhs, rhs) = cond.kind
+            && matches!(op.node, BinOpKind::Eq | BinOpKind::Ne)
+            && !cond.span.from_expansion()
+        {
+            let macro_name = macro_name.as_str();
+            span_lint_and_then(
+                cx,
+                MANUAL_ASSERT_EQ,
+                macro_call.span,
+                format!("used `{macro_name}!` with an equality comparison"),
+                |diag| {
+                    let kind = if op.node == BinOpKind::Eq { "eq" } else { "ne" };
+                    let new_name = format!("{macro_name}_{kind}");
+                    let msg = format!("replace it with `{new_name}!(..)`");
+
+                    let ctxt = cond.span.ctxt();
+                    if let Some(lhs_span) = walk_span_to_context(lhs.span, ctxt)
+                        && let Some(rhs_span) = walk_span_to_context(rhs.span, ctxt)
+                    {
+                        let macro_name_span = cx.sess().source_map().span_until_char(macro_call.span, '!');
+                        let eq_span = cond.span.with_lo(lhs_span.hi()).with_hi(rhs_span.lo());
+                        let suggestions = vec![
+                            (macro_name_span.shrink_to_hi(), format!("_{kind}")),
+                            (eq_span, ", ".to_string()),
+                        ];
+
+                        diag.multipart_suggestion(msg, suggestions, Applicability::MachineApplicable);
+                    } else {
+                        diag.span_help(expr.span, msg);
+                    }
+                },
+            );
+        }
+    }
+}

clippy_utils/src/sym.rs

@@ -133,6 +133,7 @@ generate! {
     cycle,
     cyclomatic_complexity,
     de,
+    debug_assert,
     deprecated_in_future,
     diagnostics,
     disallowed_types,

clippy_utils/src/ty/mod.rs

@@ -915,14 +915,20 @@ fn assert_generic_args_match<'tcx>(tcx: TyCtxt<'tcx>, did: DefId, args: &[Generi
         .chain(&g.own_params)
         .map(|x| &x.kind);
 
-    assert!(
-        count == args.len(),
-        "wrong number of arguments for `{did:?}`: expected `{count}`, found {}\n\
+    #[expect(
+        clippy::manual_assert_eq,
+        reason = "the message contains `assert_eq!`-like formatting itself"
+    )]
+    {
+        assert!(
+            count == args.len(),
+            "wrong number of arguments for `{did:?}`: expected `{count}`, found {}\n\
             note: the expected arguments are: `[{}]`\n\
             the given arguments are: `{args:#?}`",
-        args.len(),
-        params.clone().map(ty::GenericParamDefKind::descr).format(", "),
-    );
+            args.len(),
+            params.clone().map(ty::GenericParamDefKind::descr).format(", "),
+        );
+    }
 
     if let Some((idx, (param, arg))) =
         params

lintcheck/src/output.rs

@@ -228,8 +228,8 @@ fn print_stats(old_stats: HashMap<String, usize>, new_stats: HashMap<&String, us
 
     // remove duplicates from both hashmaps
     for (k, v) in &same_in_both_hashmaps {
-        assert!(old_stats_deduped.remove(k) == Some(*v));
-        assert!(new_stats_deduped.remove(k) == Some(*v));
+        assert_eq!(old_stats_deduped.remove(k), Some(*v));
+        assert_eq!(new_stats_deduped.remove(k), Some(*v));
     }
 
     println!("\nStats:");

tests/ui/assertions_on_constants.rs

@@ -54,8 +54,11 @@ fn main() {
     const _: () = assert!(true);
     //~^ assertions_on_constants
 
-    assert!(8 == (7 + 1));
-    //~^ assertions_on_constants
+    #[allow(clippy::manual_assert_eq, reason = "tests `assert!` specifically")]
+    {
+        assert!(8 == (7 + 1));
+        //~^ assertions_on_constants
+    }
 
     // Don't lint if the value is dependent on a defined constant:
     const N: usize = 1024;
@@ -68,8 +71,11 @@ const _: () = {
     assert!(true);
     //~^ assertions_on_constants
 
-    assert!(8 == (7 + 1));
-    //~^ assertions_on_constants
+    #[allow(clippy::manual_assert_eq, reason = "tests `assert!` specifically")]
+    {
+        assert!(8 == (7 + 1));
+        //~^ assertions_on_constants
+    }
 
     assert!(C);
 };