From cd7a9132001e0a6de7ee2f7420c63bdf98ca6eff Mon Sep 17 00:00:00 2001
From: mcarton <cartonmartin+git@gmail.com>
Date: Wed, 3 Feb 2016 20:42:05 +0100
Subject: [PATCH] Add `-` and `/` to EQ_OP

---
 src/eq_op.rs                        | 14 +++++++++-----
 tests/compile-fail/eq_op.rs         | 14 ++++++++++----
 tests/compile-fail/identity_op.rs   |  1 +
 tests/compile-fail/zero_div_zero.rs |  4 ++++
 4 files changed, 24 insertions(+), 9 deletions(-)

diff --git a/src/eq_op.rs b/src/eq_op.rs
index 06e4fdc6cb7..aecd0693ff1 100644
--- a/src/eq_op.rs
+++ b/src/eq_op.rs
@@ -4,9 +4,11 @@ use rustc_front::util as ast_util;
 
 use utils::{is_exp_equal, span_lint};
 
-/// **What it does:** This lint checks for equal operands to comparisons and bitwise binary operators (`&`, `|` and `^`).
+/// **What it does:** This lint checks for equal operands to comparison, logical and bitwise,
+/// difference and division binary operators (`==`, `>`, etc., `&&`, `||`, `&`, `|`, `^`, `-` and
+/// `/`).
 ///
-/// **Why is this bad?** This is usually just a typo.
+/// **Why is this bad?** This is usually just a typo or a copy and paste error.
 ///
 /// **Known problems:** False negatives: We had some false positives regarding calls (notably [racer](https://github.com/phildawes/racer) had one instance of `x.pop() && x.pop()`), so we removed matching any function or method calls. We may introduce a whitelist of known pure functions in the future.
 ///
@@ -29,19 +31,21 @@ impl LintPass for EqOp {
 impl LateLintPass for EqOp {
     fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
         if let ExprBinary(ref op, ref left, ref right) = e.node {
-            if is_cmp_or_bit(op) && is_exp_equal(cx, left, right, true) {
+            if is_valid_operator(op) && is_exp_equal(cx, left, right, true) {
                 span_lint(cx,
                           EQ_OP,
                           e.span,
-                          &format!("equal expressions as operands to {}", ast_util::binop_to_string(op.node)));
+                          &format!("equal expressions as operands to `{}`", ast_util::binop_to_string(op.node)));
             }
         }
     }
 }
 
 
-fn is_cmp_or_bit(op: &BinOp) -> bool {
+fn is_valid_operator(op: &BinOp) -> bool {
     match op.node {
+        BiSub |
+        BiDiv |
         BiEq |
         BiLt |
         BiLe |
diff --git a/tests/compile-fail/eq_op.rs b/tests/compile-fail/eq_op.rs
index fe74d182da1..7be5ef11ce6 100644
--- a/tests/compile-fail/eq_op.rs
+++ b/tests/compile-fail/eq_op.rs
@@ -19,9 +19,9 @@ fn main() {
     // unary and binary operators
     (-(2) < -(2));  //~ERROR equal expressions
     ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
-          //~^ ERROR equal expressions
-                    //~^^ ERROR equal expressions
-                               //~^^^ ERROR equal expressions
+          //~^ ERROR equal expressions as operands to `==`
+                    //~^^ ERROR equal expressions as operands to `&`
+                               //~^^^ ERROR equal expressions as operands to `&`
     (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4; //~ERROR equal expressions
 
     // various other things
@@ -31,7 +31,13 @@ fn main() {
 
     // const folding
     1 + 1 == 2; //~ERROR equal expressions
-    1 - 1 == 0; //~ERROR equal expressions
+    1 - 1 == 0; //~ERROR equal expressions as operands to `==`
+                //~^ ERROR equal expressions as operands to `-`
+
+    1 - 1; //~ERROR equal expressions
+    1 / 1; //~ERROR equal expressions
+    true && true; //~ERROR equal expressions
+    true || true; //~ERROR equal expressions
 
     let mut a = vec![1];
     a == a; //~ERROR equal expressions
diff --git a/tests/compile-fail/identity_op.rs b/tests/compile-fail/identity_op.rs
index 54551852d5e..c1141e0b460 100644
--- a/tests/compile-fail/identity_op.rs
+++ b/tests/compile-fail/identity_op.rs
@@ -5,6 +5,7 @@ const ONE : i64 = 1;
 const NEG_ONE : i64 = -1;
 const ZERO : i64 = 0;
 
+#[allow(eq_op)]
 #[deny(identity_op)]
 fn main() {
     let x = 0;
diff --git a/tests/compile-fail/zero_div_zero.rs b/tests/compile-fail/zero_div_zero.rs
index 8c40923d3ed..c422e83873b 100644
--- a/tests/compile-fail/zero_div_zero.rs
+++ b/tests/compile-fail/zero_div_zero.rs
@@ -5,9 +5,13 @@
 #[deny(zero_divided_by_zero)]
 fn main() {
     let nan = 0.0 / 0.0; //~ERROR constant division of 0.0 with 0.0 will always result in NaN
+                         //~^ equal expressions as operands to `/`
     let f64_nan = 0.0 / 0.0f64; //~ERROR constant division of 0.0 with 0.0 will always result in NaN
+                         //~^ equal expressions as operands to `/`
     let other_f64_nan = 0.0f64 / 0.0; //~ERROR constant division of 0.0 with 0.0 will always result in NaN
+                         //~^ equal expressions as operands to `/`
     let one_more_f64_nan = 0.0f64/0.0f64; //~ERROR constant division of 0.0 with 0.0 will always result in NaN
+                         //~^ equal expressions as operands to `/`
     let zero = 0.0;
     let other_zero = 0.0;
     let other_nan = zero / other_zero; // fine - this lint doesn't propegate constants.