rust/tests/ui/copies.rs

399 lines
6.3 KiB
Rust
Raw Normal View History

2017-09-18 12:47:33 +02:00
#![feature(dotdoteq_in_patterns, inclusive_range_syntax)]
#![allow(dead_code, no_effect, unnecessary_operation)]
2016-01-30 20:10:14 +01:00
#![allow(let_and_return)]
#![allow(needless_return)]
#![allow(unused_variables)]
2016-02-10 01:22:53 +01:00
#![allow(cyclomatic_complexity)]
2016-02-22 15:42:24 +01:00
#![allow(blacklisted_name)]
#![allow(collapsible_if)]
#![allow(zero_divided_by_zero, eq_op)]
2016-12-02 17:38:31 +01:00
#![allow(path_statements)]
2016-02-10 01:22:53 +01:00
fn bar<T>(_: T) {}
fn foo() -> bool { unimplemented!() }
struct Foo {
bar: u8,
}
pub enum Abc {
A,
B,
C,
}
#[warn(if_same_then_else)]
#[warn(match_same_arms)]
fn if_same_then_else() -> Result<&'static str, ()> {
if true {
Foo { bar: 42 };
0..10;
..;
0..;
..10;
2017-09-28 19:40:19 +02:00
0..=10;
foo();
}
2017-02-08 14:58:07 +01:00
else {
Foo { bar: 42 };
0..10;
..;
0..;
..10;
2017-09-28 19:40:19 +02:00
0..=10;
foo();
}
if true {
Foo { bar: 42 };
}
else {
Foo { bar: 43 };
}
if true {
();
}
else {
()
}
if true {
0..10;
}
else {
2017-09-28 19:40:19 +02:00
0..=10;
}
if true {
foo();
foo();
}
else {
foo();
}
let _ = match 42 {
42 => {
foo();
let mut a = 42 + [23].len() as i32;
if true {
a += 7;
}
a = -31-a;
a
}
2017-02-08 14:58:07 +01:00
_ => {
foo();
let mut a = 42 + [23].len() as i32;
if true {
a += 7;
}
a = -31-a;
a
}
};
let _ = match Abc::A {
Abc::A => 0,
Abc::B => 1,
2017-02-08 14:58:07 +01:00
_ => 0,
};
if true {
foo();
}
let _ = if true {
42
}
2017-02-08 14:58:07 +01:00
else {
42
};
2016-01-30 20:10:14 +01:00
if true {
for _ in &[42] {
let foo: &Option<_> = &Some::<u8>(42);
if true {
break;
} else {
continue;
}
}
}
2017-02-08 14:58:07 +01:00
else {
for _ in &[42] {
let foo: &Option<_> = &Some::<u8>(42);
if true {
break;
} else {
continue;
}
}
}
if true {
2016-01-30 20:10:14 +01:00
let bar = if true {
42
}
else {
43
};
while foo() { break; }
bar + 1;
}
2017-02-08 14:58:07 +01:00
else {
2016-01-30 20:10:14 +01:00
let bar = if true {
42
}
else {
43
};
while foo() { break; }
bar + 1;
}
if true {
2016-02-10 01:22:53 +01:00
let _ = match 42 {
42 => 1,
a if a > 0 => 2,
2017-09-28 19:40:19 +02:00
10..=15 => 3,
2016-02-10 01:22:53 +01:00
_ => 4,
};
2016-01-30 20:10:14 +01:00
}
else if false {
foo();
}
2017-02-08 14:58:07 +01:00
else if foo() {
2016-02-10 01:22:53 +01:00
let _ = match 42 {
42 => 1,
a if a > 0 => 2,
2017-09-28 19:40:19 +02:00
10..=15 => 3,
2016-02-10 01:22:53 +01:00
_ => 4,
};
2016-01-30 20:10:14 +01:00
}
if true {
if let Some(a) = Some(42) {}
}
2017-02-08 14:58:07 +01:00
else {
if let Some(a) = Some(42) {}
}
if true {
if let (1, .., 3) = (1, 2, 3) {}
}
2017-02-08 14:58:07 +01:00
else {
if let (1, .., 3) = (1, 2, 3) {}
}
if true {
if let (1, .., 3) = (1, 2, 3) {}
}
else {
if let (.., 3) = (1, 2, 3) {}
}
if true {
if let (1, .., 3) = (1, 2, 3) {}
}
else {
if let (.., 4) = (1, 2, 3) {}
}
if true {
if let (1, .., 3) = (1, 2, 3) {}
}
else {
if let (.., 1, 3) = (1, 2, 3) {}
}
if true {
if let Some(42) = None {}
}
else {
if let Option::Some(42) = None {}
}
if true {
if let Some(42) = None::<u8> {}
}
else {
if let Some(42) = None {}
}
2016-12-02 22:23:24 +01:00
if true {
if let Some(42) = None::<u8> {}
}
else {
if let Some(42) = None::<u32> {}
}
if true {
2016-01-30 20:10:14 +01:00
if let Some(a) = Some(42) {}
}
else {
if let Some(a) = Some(43) {}
2016-01-30 20:10:14 +01:00
}
2016-02-10 01:22:53 +01:00
let _ = match 42 {
42 => foo(),
2017-02-08 14:58:07 +01:00
51 => foo(),
2016-02-10 01:22:53 +01:00
_ => true,
};
let _ = match Some(42) {
Some(_) => 24,
2017-02-08 14:58:07 +01:00
None => 24,
};
2016-05-31 21:50:13 +02:00
let _ = match Some(42) {
Some(foo) => 24,
None => 24,
};
2016-02-10 01:22:53 +01:00
let _ = match Some(42) {
Some(42) => 24,
Some(a) => 24, // bindings are different
None => 0,
};
let _ = match Some(42) {
Some(a) if a > 0 => 24,
Some(a) => 24, // one arm has a guard
None => 0,
};
2016-02-10 01:22:53 +01:00
match (Some(42), Some(42)) {
(Some(a), None) => bar(a),
2017-02-08 14:58:07 +01:00
(None, Some(a)) => bar(a),
2016-02-10 01:22:53 +01:00
_ => (),
}
match (Some(42), Some(42)) {
(Some(a), ..) => bar(a),
2017-02-08 14:58:07 +01:00
(.., Some(a)) => bar(a),
_ => (),
}
match (1, 2, 3) {
(1, .., 3) => 42,
2017-02-08 14:58:07 +01:00
(.., 3) => 42,
_ => 0,
};
let _ = if true {
0.0
2017-02-08 14:58:07 +01:00
} else {
0.0
};
let _ = if true {
-0.0
2017-02-08 14:58:07 +01:00
} else {
-0.0
};
let _ = if true {
0.0
} else {
-0.0
};
2016-07-13 18:35:31 +02:00
// Different NaNs
let _ = if true {
0.0 / 0.0
2016-07-13 18:35:31 +02:00
} else {
std::f32::NAN
2016-07-13 18:35:31 +02:00
};
// Same NaNs
let _ = if true {
std::f32::NAN
2017-02-08 14:58:07 +01:00
} else {
2016-07-13 18:35:31 +02:00
std::f32::NAN
};
let _ = match Some(()) {
Some(()) => 0.0,
None => -0.0
};
2016-02-10 01:22:53 +01:00
match (Some(42), Some("")) {
(Some(a), None) => bar(a),
(None, Some(a)) => bar(a), // bindings have different types
_ => (),
}
if true {
try!(Ok("foo"));
}
2017-02-08 14:58:07 +01:00
else {
try!(Ok("foo"));
}
if true {
2016-01-30 20:10:14 +01:00
let foo = "";
return Ok(&foo[0..]);
2016-01-30 20:10:14 +01:00
}
else if false {
let foo = "bar";
return Ok(&foo[0..]);
}
2017-02-08 14:58:07 +01:00
else {
2016-01-30 20:10:14 +01:00
let foo = "";
return Ok(&foo[0..]);
2016-01-30 20:10:14 +01:00
}
}
#[warn(ifs_same_cond)]
#[allow(if_same_then_else)] // all empty blocks
fn ifs_same_cond() {
let a = 0;
2016-02-09 15:18:27 +01:00
let b = false;
if b {
}
2017-02-08 14:58:07 +01:00
else if b {
2016-02-09 15:18:27 +01:00
}
if a == 1 {
}
2017-02-08 14:58:07 +01:00
else if a == 1 {
}
if 2*a == 1 {
}
else if 2*a == 2 {
}
2017-02-08 14:58:07 +01:00
else if 2*a == 1 {
}
else if a == 1 {
}
// See #659
if cfg!(feature = "feature1-659") {
1
} else if cfg!(feature = "feature2-659") {
2
} else {
3
};
2016-01-30 20:10:14 +01:00
let mut v = vec![1];
if v.pop() == None { // ok, functions
}
else if v.pop() == None {
}
if v.len() == 42 { // ok, functions
}
2016-01-30 20:10:14 +01:00
else if v.len() == 42 {
}
}
fn main() {}