Update for rustc 1.19.0-nightly (4bf5c99af 2017-06-10).

[rust.git] / clippy_lints / src / eq_op.rs

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 51a11dd9dde65b90d0ddb3a7176783b37ebfce0c..9eab6352cc2e319e91fbfaa27e83554ea2a3b1c4 100644 (file)
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -52,14 +52,12 @@ fn get_lints(&self) -> LintArray {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
         if let ExprBinary(ref op, ref left, ref right) = e.node {
-            if is_valid_operator(op) {
-                if SpanlessEq::new(cx).ignore_fn().eq_expr(left, right) {
-                    span_lint(cx,
-                              EQ_OP,
-                              e.span,
-                              &format!("equal expressions as operands to `{}`", op.node.as_str()));
-                    return;
-                }
+            if is_valid_operator(op) && SpanlessEq::new(cx).ignore_fn().eq_expr(left, right) {
+                span_lint(cx,
+                          EQ_OP,
+                          e.span,
+                          &format!("equal expressions as operands to `{}`", op.node.as_str()));
+                return;
             }
             let (trait_id, requires_ref) = match op.node {
                 BiAdd => (cx.tcx.lang_items.add_trait(), false),
@@ -77,7 +75,6 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
                 BiNe | BiEq => (cx.tcx.lang_items.eq_trait(), true),
                 BiLt | BiLe | BiGe | BiGt => (cx.tcx.lang_items.ord_trait(), true),
             };
-            let parent = cx.tcx.hir.get_parent(e.id);
             if let Some(trait_id) = trait_id {
                 #[allow(match_same_arms)]
                 match (&left.node, &right.node) {
@@ -88,37 +85,35 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
                     (&ExprAddrOf(_, ref l), &ExprAddrOf(_, ref r)) => {
                         let lty = cx.tables.expr_ty(l);
                         let rty = cx.tables.expr_ty(r);
-                        let lcpy = is_copy(cx, lty, parent);
-                        let rcpy = is_copy(cx, rty, parent);
+                        let lcpy = is_copy(cx, lty);
+                        let rcpy = is_copy(cx, rty);
                         // either operator autorefs or both args are copyable
-                        if (requires_ref || (lcpy && rcpy)) && implements_trait(cx, lty, trait_id, &[rty], None) {
+                        if (requires_ref || (lcpy && rcpy)) && implements_trait(cx, lty, trait_id, &[rty]) {
                             span_lint_and_then(cx,
-                                                OP_REF,
-                                                e.span,
-                                                "needlessly taken reference of both operands",
-                                                |db| {
+                                               OP_REF,
+                                               e.span,
+                                               "needlessly taken reference of both operands",
+                                               |db| {
                                 let lsnip = snippet(cx, l.span, "...").to_string();
                                 let rsnip = snippet(cx, r.span, "...").to_string();
                                 multispan_sugg(db,
-                                                "use the values directly".to_string(),
-                                                vec![(left.span, lsnip),
+                                               "use the values directly".to_string(),
+                                               vec![(left.span, lsnip),
                                                     (right.span, rsnip)]);
                             })
-                        } else if lcpy && !rcpy && implements_trait(cx, lty, trait_id, &[cx.tables.expr_ty(right)], None) {
-                            span_lint_and_then(cx,
-                                                OP_REF,
-                                                e.span,
-                                                "needlessly taken reference of left operand",
-                                                |db| {
+                        } else if lcpy && !rcpy &&
+                                  implements_trait(cx, lty, trait_id, &[cx.tables.expr_ty(right)]) {
+                            span_lint_and_then(cx, OP_REF, e.span, "needlessly taken reference of left operand", |db| {
                                 let lsnip = snippet(cx, l.span, "...").to_string();
                                 db.span_suggestion(left.span, "use the left value directly", lsnip);
                             })
-                        } else if !lcpy && rcpy && implements_trait(cx, cx.tables.expr_ty(left), trait_id, &[rty], None) {
+                        } else if !lcpy && rcpy &&
+                                  implements_trait(cx, cx.tables.expr_ty(left), trait_id, &[rty]) {
                             span_lint_and_then(cx,
-                                                OP_REF,
-                                                e.span,
-                                                "needlessly taken reference of right operand",
-                                                |db| {
+                                               OP_REF,
+                                               e.span,
+                                               "needlessly taken reference of right operand",
+                                               |db| {
                                 let rsnip = snippet(cx, r.span, "...").to_string();
                                 db.span_suggestion(right.span, "use the right value directly", rsnip);
                             })
@@ -127,8 +122,9 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
                     // &foo == bar
                     (&ExprAddrOf(_, ref l), _) => {
                         let lty = cx.tables.expr_ty(l);
-                        let lcpy = is_copy(cx, lty, parent);
-                        if (requires_ref || lcpy) && implements_trait(cx, lty, trait_id, &[cx.tables.expr_ty(right)], None) {
+                        let lcpy = is_copy(cx, lty);
+                        if (requires_ref || lcpy) &&
+                           implements_trait(cx, lty, trait_id, &[cx.tables.expr_ty(right)]) {
                             span_lint_and_then(cx, OP_REF, e.span, "needlessly taken reference of left operand", |db| {
                                 let lsnip = snippet(cx, l.span, "...").to_string();
                                 db.span_suggestion(left.span, "use the left value directly", lsnip);
@@ -138,11 +134,12 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
                     // foo == &bar
                     (_, &ExprAddrOf(_, ref r)) => {
                         let rty = cx.tables.expr_ty(r);
-                        let rcpy = is_copy(cx, rty, parent);
-                        if (requires_ref || rcpy) && implements_trait(cx, cx.tables.expr_ty(left), trait_id, &[rty], None) {
+                        let rcpy = is_copy(cx, rty);
+                        if (requires_ref || rcpy) &&
+                           implements_trait(cx, cx.tables.expr_ty(left), trait_id, &[rty]) {
                             span_lint_and_then(cx, OP_REF, e.span, "taken reference of right operand", |db| {
                                 let rsnip = snippet(cx, r.span, "...").to_string();
-                                db.span_suggestion(left.span, "use the right value directly", rsnip);
+                                db.span_suggestion(right.span, "use the right value directly", rsnip);
                             })
                         }
                     },