avoid eq_op in test code

Author: llogiq

clippy_lints/src/eq_op.rs

@@ -4,9 +4,10 @@ use clippy_utils::ty::{implements_trait, is_copy};
 use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, StmtKind};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -68,27 +69,36 @@ declare_lint_pass!(EqOp => [EQ_OP, OP_REF]);
 
 const ASSERT_MACRO_NAMES: [&str; 4] = ["assert_eq", "assert_ne", "debug_assert_eq", "debug_assert_ne"];
 
+fn in_test_function(cx: &LateContext<'_>, elem_id: HirId) -> bool {
+    if let Some(def_id) = cx.tcx.hir().opt_local_def_id(cx.tcx.hir().get_parent_item(elem_id)) {
+        return cx.tcx.has_attr(def_id.to_def_id(), sym::test);
+    }
+    false
+}
+
 impl<'tcx> LateLintPass<'tcx> for EqOp {
     #[allow(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if let ExprKind::Block(block, _) = e.kind {
-            for stmt in block.stmts {
-                for amn in &ASSERT_MACRO_NAMES {
-                    if_chain! {
-                        if is_expn_of(stmt.span, amn).is_some();
-                        if let StmtKind::Semi(matchexpr) = stmt.kind;
-                        if let Some(macro_args) = higher::extract_assert_macro_args(matchexpr);
-                        if macro_args.len() == 2;
-                        let (lhs, rhs) = (macro_args[0], macro_args[1]);
-                        if eq_expr_value(cx, lhs, rhs);
+            if !in_test_function(cx, e.hir_id) {
+                for stmt in block.stmts {
+                    for amn in &ASSERT_MACRO_NAMES {
+                        if_chain! {
+                            if is_expn_of(stmt.span, amn).is_some();
+                            if let StmtKind::Semi(matchexpr) = stmt.kind;
+                            if let Some(macro_args) = higher::extract_assert_macro_args(matchexpr);
+                            if macro_args.len() == 2;
+                            let (lhs, rhs) = (macro_args[0], macro_args[1]);
+                            if eq_expr_value(cx, lhs, rhs);
 
-                        then {
-                            span_lint(
-                                cx,
-                                EQ_OP,
-                                lhs.span.to(rhs.span),
-                                &format!("identical args used in this `{}!` macro call", amn),
-                            );
+                            then {
+                                span_lint(
+                                    cx,
+                                    EQ_OP,
+                                    lhs.span.to(rhs.span),
+                                    &format!("identical args used in this `{}!` macro call", amn),
+                                );
+                            }
                         }
                     }
                 }
@@ -108,7 +118,10 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
             if macro_with_not_op(&left.kind) || macro_with_not_op(&right.kind) {
                 return;
             }
-            if is_useless_with_eq_exprs(op.node.into()) && eq_expr_value(cx, left, right) {
+            if is_useless_with_eq_exprs(op.node.into())
+                && !in_test_function(cx, e.hir_id)
+                && eq_expr_value(cx, left, right)
+            {
                 span_lint(
                     cx,
                     EQ_OP,

tests/ui/eq_op.rs

@@ -95,3 +95,10 @@ fn check_nested(n1: &Nested, n2: &Nested) -> bool {
     // `n2.inner.0.0` mistyped as `n1.inner.0.0`
     (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
 }
+
+#[test]
+fn eq_op_shouldnt_trigger_in_tests() {
+    let a = 1;
+    let result = a + 1 == 1 + a;
+    assert!(result);
+}

tests/ui/eq_op_macros.rs

@@ -54,3 +54,11 @@ fn main() {
     let mut my_iter = my_vec.iter();
     assert_ne!(my_iter.next(), my_iter.next());
 }
+
+#[test]
+fn eq_op_shouldnt_trigger_in_tests() {
+    let a = 1;
+    let b = 2;
+    assert_eq!(a, a);
+    assert_eq!(a + b, b + a);
+}