Auto merge of #3603 - xfix:random-state-lint, r=phansch

[rust.git] / tests / ui / eq_op.rs

diff --git a/tests/ui/eq_op.rs b/tests/ui/eq_op.rs
index 842e5729fcd8fcb907b4a4645a4570d4f93e845e..020c7d795a4cd5c4a26ce454de013577462abe78 100644 (file)
--- a/tests/ui/eq_op.rs
+++ b/tests/ui/eq_op.rs
@@ -1,10 +1,17 @@
-#![feature(plugin)]
-#![plugin(clippy)]
-
-#[deny(eq_op)]
-#[allow(identity_op, double_parens)]
-#[allow(no_effect, unused_variables, unnecessary_operation, short_circuit_statement)]
-#[deny(nonminimal_bool)]
+// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[rustfmt::skip]
+#[warn(clippy::eq_op)]
+#[allow(clippy::identity_op, clippy::double_parens, clippy::many_single_char_names)]
+#[allow(clippy::no_effect, unused_variables, clippy::unnecessary_operation, clippy::short_circuit_statement)]
+#[warn(clippy::nonminimal_bool)]
 fn main() {
     // simple values and comparisons
     1 == 1;
@@ -21,9 +28,6 @@ fn main() {
     // unary and binary operators
     (-(2) < -(2));
     ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
-
-
-
     (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
 
     // various other things
@@ -35,7 +39,6 @@ fn main() {
     1 + 1 == 2;
     1 - 1 == 0;
 
-
     1 - 1;
     1 / 1;
     true && true;
@@ -47,16 +50,71 @@ fn main() {
     let b: u32 = 0;
 
     a == b && b == a;
-
     a != b && b != a;
-
     a < b && b > a;
-
     a <= b && b >= a;
 
-
     let mut a = vec![1];
     a == a;
     2*a.len() == 2*a.len(); // ok, functions
     a.pop() == a.pop(); // ok, functions
+
+    use std::ops::BitAnd;
+    struct X(i32);
+    impl BitAnd for X {
+        type Output = X;
+        fn bitand(self, rhs: X) -> X {
+            X(self.0 & rhs.0)
+        }
+    }
+    impl<'a> BitAnd<&'a X> for X {
+        type Output = X;
+        fn bitand(self, rhs: &'a X) -> X {
+            X(self.0 & rhs.0)
+        }
+    }
+    let x = X(1);
+    let y = X(2);
+    let z = x & &y;
+
+    #[derive(Copy, Clone)]
+    struct Y(i32);
+    impl BitAnd for Y {
+        type Output = Y;
+        fn bitand(self, rhs: Y) -> Y {
+            Y(self.0 & rhs.0)
+        }
+    }
+    impl<'a> BitAnd<&'a Y> for Y {
+        type Output = Y;
+        fn bitand(self, rhs: &'a Y) -> Y {
+            Y(self.0 & rhs.0)
+        }
+    }
+    let x = Y(1);
+    let y = Y(2);
+    let z = x & &y;
+
+    check_ignore_macro();
+
+    // named constants
+    const A: u32 = 10;
+    const B: u32 = 10;
+    const C: u32 = A / B; // ok, different named constants
+    const D: u32 = A / A;
+}
+
+#[rustfmt::skip]
+macro_rules! check_if_named_foo {
+    ($expression:expr) => (
+        if stringify!($expression) == "foo" {
+            println!("foo!");
+        } else {
+            println!("not foo.");
+        }
+    )
+}
+
+fn check_ignore_macro() {
+    check_if_named_foo!(foo);
 }