OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add - and / to EQ_OP

Browse Source
This commit is contained in:
mcarton 2016-02-03 20:42:05 +01:00
parent 8e22d08129
commit cd7a913200
4 changed files with 24 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/eq_op.rs
View File

@ -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 |

14
tests/compile-fail/eq_op.rs
View File

@ -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

1
tests/compile-fail/identity_op.rs
View File

@ -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;

4
tests/compile-fail/zero_div_zero.rs
View File

@ -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.