clippy_lints/src/eq_op.rs

   1 use rustc::hir::*;
   2 use rustc::lint::*;
   3 use utils::{SpanlessEq, span_lint, span_lint_and_then, multispan_sugg, snippet, implements_trait};
   4 use utils::sugg::Sugg;
   5
   6 /// **What it does:** Checks for equal operands to comparison, logical and
   7 /// bitwise, difference and division binary operators (`==`, `>`, etc., `&&`,
   8 /// `||`, `&`, `|`, `^`, `-` and `/`).
   9 ///
  10 /// **Why is this bad?** This is usually just a typo or a copy and paste error.
  11 ///
  12 /// **Known problems:** False negatives: We had some false positives regarding
  13 /// calls (notably [racer](https://github.com/phildawes/racer) had one instance
  14 /// of `x.pop() && x.pop()`), so we removed matching any function or method
  15 /// calls. We may introduce a whitelist of known pure functions in the future.
  16 ///
  17 /// **Example:**
  18 /// ```rust
  19 /// x + 1 == x + 1
  20 /// ```
  21 declare_lint! {
  22     pub EQ_OP,
  23     Warn,
  24     "equal operands on both sides of a comparison or bitwise combination (e.g. `x == x`)"
  25 }
  26
  27 /// **What it does:** Checks for arguments to `==` which have their address taken to satisfy a bound
  28 /// and suggests to dereference the other argument instead
  29 ///
  30 /// **Why is this bad?** It is more idiomatic to dereference the other argument.
  31 ///
  32 /// **Known problems:** None
  33 ///
  34 /// **Example:**
  35 /// ```rust
  36 /// &x == y
  37 /// ```
  38 declare_lint! {
  39     pub OP_REF,
  40     Warn,
  41     "taking a reference to satisfy the type constraints on `==`"
  42 }
  43
  44 #[derive(Copy,Clone)]
  45 pub struct EqOp;
  46
  47 impl LintPass for EqOp {
  48     fn get_lints(&self) -> LintArray {
  49         lint_array!(EQ_OP, OP_REF)
  50     }
  51 }
  52
  53 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
  54     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
  55         if let ExprBinary(ref op, ref left, ref right) = e.node {
  56             if is_valid_operator(op) {
  57                 if SpanlessEq::new(cx).ignore_fn().eq_expr(left, right) {
  58                     span_lint(cx,
  59                               EQ_OP,
  60                               e.span,
  61                               &format!("equal expressions as operands to `{}`", op.node.as_str()));
  62                 } else {
  63                     let trait_id = match op.node {
  64                         BiAdd => cx.tcx.lang_items.add_trait(),
  65                         BiSub => cx.tcx.lang_items.sub_trait(),
  66                         BiMul => cx.tcx.lang_items.mul_trait(),
  67                         BiDiv => cx.tcx.lang_items.div_trait(),
  68                         BiRem => cx.tcx.lang_items.rem_trait(),
  69                         BiAnd | BiOr => None,
  70                         BiBitXor => cx.tcx.lang_items.bitxor_trait(),
  71                         BiBitAnd => cx.tcx.lang_items.bitand_trait(),
  72                         BiBitOr => cx.tcx.lang_items.bitor_trait(),
  73                         BiShl => cx.tcx.lang_items.shl_trait(),
  74                         BiShr => cx.tcx.lang_items.shr_trait(),
  75                         BiNe | BiEq => cx.tcx.lang_items.eq_trait(),
  76                         BiLt | BiLe | BiGe | BiGt => cx.tcx.lang_items.ord_trait(),
  77                     };
  78                     if let Some(trait_id) = trait_id {
  79                         #[allow(match_same_arms)]
  80                         match (&left.node, &right.node) {
  81                             // do not suggest to dereference literals
  82                             (&ExprLit(..), _) |
  83                             (_, &ExprLit(..)) => {},
  84                             // &foo == &bar
  85                             (&ExprAddrOf(_, ref l), &ExprAddrOf(_, ref r)) => {
  86                                 if implements_trait(cx, cx.tables.expr_ty(l), trait_id, &[cx.tables.expr_ty(r)], None) {
  87                                     span_lint_and_then(cx,
  88                                                        OP_REF,
  89                                                        e.span,
  90                                                        "taken reference of both operands, which is done automatically \
  91                                                         by the operator anyway",
  92                                                        |db| {
  93                                         let lsnip = snippet(cx, l.span, "...").to_string();
  94                                         let rsnip = snippet(cx, r.span, "...").to_string();
  95                                         multispan_sugg(db,
  96                                                        "use the values directly".to_string(),
  97                                                        vec![(left.span, lsnip),
  98                                                             (right.span, rsnip)]);
  99                                     })
 100                                 }
 101                             },
 102                             // &foo == bar
 103                             (&ExprAddrOf(_, ref l), _) => {
 104                                 if implements_trait(cx,
 105                                                     cx.tables.expr_ty(l),
 106                                                     trait_id,
 107                                                     &[cx.tables.expr_ty(right)],
 108                                                     None) {
 109                                     span_lint_and_then(cx, OP_REF, e.span, "taken reference of left operand", |db| {
 110                                         let lsnip = snippet(cx, l.span, "...").to_string();
 111                                         let rsnip = Sugg::hir(cx, right, "...").deref().to_string();
 112                                         multispan_sugg(db,
 113                                                        "dereference the right operand instead".to_string(),
 114                                                        vec![(left.span, lsnip),
 115                                                             (right.span, rsnip)]);
 116                                     })
 117                                 }
 118                             },
 119                             // foo == &bar
 120                             (_, &ExprAddrOf(_, ref r)) => {
 121                                 if implements_trait(cx,
 122                                                     cx.tables.expr_ty(left),
 123                                                     trait_id,
 124                                                     &[cx.tables.expr_ty(r)],
 125                                                     None) {
 126                                     span_lint_and_then(cx, OP_REF, e.span, "taken reference of right operand", |db| {
 127                                         let lsnip = Sugg::hir(cx, left, "...").deref().to_string();
 128                                         let rsnip = snippet(cx, r.span, "...").to_string();
 129                                         multispan_sugg(db,
 130                                                        "dereference the left operand instead".to_string(),
 131                                                        vec![(left.span, lsnip),
 132                                                             (right.span, rsnip)]);
 133                                     })
 134                                 }
 135                             },
 136                             _ => {},
 137                         }
 138                     }
 139                 }
 140             }
 141         }
 142     }
 143 }
 144
 145
 146 fn is_valid_operator(op: &BinOp) -> bool {
 147     match op.node {
 148         BiSub | BiDiv | BiEq | BiLt | BiLe | BiGt | BiGe | BiNe | BiAnd | BiOr | BiBitXor | BiBitAnd | BiBitOr => true,
 149         _ => false,
 150     }
 151 }