2018-12-08 18:56:59 +01:00
|
|
|
#[rustfmt::skip]
|
2018-07-28 17:34:52 +02:00
|
|
|
#[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)]
|
2015-04-30 11:48:43 +02:00
|
|
|
fn main() {
|
2015-08-11 20:22:20 +02:00
|
|
|
// simple values and comparisons
|
2017-02-08 14:58:07 +01:00
|
|
|
1 == 1;
|
|
|
|
"no" == "no";
|
2015-08-11 20:22:20 +02:00
|
|
|
// even though I agree that no means no ;-)
|
2017-02-08 14:58:07 +01:00
|
|
|
false != false;
|
|
|
|
1.5 < 1.5;
|
|
|
|
1u64 >= 1u64;
|
2015-08-11 20:22:20 +02:00
|
|
|
|
2015-08-13 09:44:03 +02:00
|
|
|
// casts, methods, parentheses
|
2017-02-08 14:58:07 +01:00
|
|
|
(1 as u64) & (1 as u64);
|
|
|
|
1 ^ ((((((1))))));
|
2015-08-11 20:22:20 +02:00
|
|
|
|
|
|
|
// unary and binary operators
|
2017-02-08 14:58:07 +01:00
|
|
|
(-(2) < -(2));
|
2015-04-30 11:48:43 +02:00
|
|
|
((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
|
2017-02-08 14:58:07 +01:00
|
|
|
(1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
|
2015-08-11 20:22:20 +02:00
|
|
|
|
|
|
|
// various other things
|
2017-02-08 14:58:07 +01:00
|
|
|
([1] != [1]);
|
|
|
|
((1, 2) != (1, 2));
|
2015-04-30 11:48:43 +02:00
|
|
|
vec![1, 2, 3] == vec![1, 2, 3]; //no error yet, as we don't match macros
|
2015-08-21 12:26:03 +02:00
|
|
|
|
|
|
|
// const folding
|
2017-02-08 14:58:07 +01:00
|
|
|
1 + 1 == 2;
|
|
|
|
1 - 1 == 0;
|
|
|
|
|
|
|
|
1 - 1;
|
|
|
|
1 / 1;
|
|
|
|
true && true;
|
|
|
|
|
|
|
|
true || true;
|
2016-02-03 20:42:05 +01:00
|
|
|
|
2016-01-30 20:10:14 +01:00
|
|
|
|
2016-11-16 21:57:56 +01:00
|
|
|
let a: u32 = 0;
|
|
|
|
let b: u32 = 0;
|
2016-03-24 16:11:38 +01:00
|
|
|
|
2017-02-08 14:58:07 +01:00
|
|
|
a == b && b == a;
|
|
|
|
a != b && b != a;
|
|
|
|
a < b && b > a;
|
|
|
|
a <= b && b >= a;
|
|
|
|
|
2016-01-30 20:10:14 +01:00
|
|
|
let mut a = vec![1];
|
2017-02-08 14:58:07 +01:00
|
|
|
a == a;
|
2016-01-30 20:10:14 +01:00
|
|
|
2*a.len() == 2*a.len(); // ok, functions
|
|
|
|
a.pop() == a.pop(); // ok, functions
|
2017-04-28 17:07:39 +02:00
|
|
|
|
|
|
|
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;
|
2017-12-22 19:37:44 +01:00
|
|
|
|
|
|
|
check_ignore_macro();
|
2018-03-23 19:26:52 +01:00
|
|
|
|
|
|
|
// named constants
|
|
|
|
const A: u32 = 10;
|
|
|
|
const B: u32 = 10;
|
|
|
|
const C: u32 = A / B; // ok, different named constants
|
|
|
|
const D: u32 = A / A;
|
2017-12-22 19:37:44 +01:00
|
|
|
}
|
|
|
|
|
2018-12-08 18:56:59 +01:00
|
|
|
#[rustfmt::skip]
|
2017-12-22 19:37:44 +01:00
|
|
|
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);
|
2015-04-30 11:48:43 +02:00
|
|
|
}
|