rust/tests/ui/matches.rs

284 lines
5.1 KiB
Rust
Raw Normal View History

2017-09-18 12:47:33 +02:00
#![feature(exclusive_range_pattern)]
2015-04-13 19:58:18 +02:00
2017-09-18 12:47:33 +02:00
#![warn(clippy)]
#![allow(unused, if_let_redundant_pattern_matching)]
#![warn(single_match_else)]
2015-04-13 19:58:18 +02:00
2016-01-13 01:19:27 +01:00
use std::borrow::Cow;
enum Foo { Bar, Baz(u8) }
use Foo::*;
enum ExprNode {
ExprAddrOf,
Butterflies,
Unicorns,
}
static NODE: ExprNode = ExprNode::Unicorns;
2016-06-22 02:17:26 +02:00
fn dummy() {
}
fn unwrap_addr() -> Option<&'static ExprNode> {
2016-06-22 02:17:26 +02:00
match ExprNode::Butterflies {
ExprNode::ExprAddrOf => Some(&NODE),
2016-06-22 02:17:26 +02:00
_ => { let x = 5; None },
}
}
fn single_match(){
2015-04-13 19:58:18 +02:00
let x = Some(1u8);
2016-01-13 01:19:27 +01:00
2016-06-22 02:17:26 +02:00
match x {
Some(y) => { println!("{:?}", y); }
2015-04-13 19:58:18 +02:00
_ => ()
2016-06-22 02:17:26 +02:00
};
2016-01-13 01:19:27 +01:00
2015-04-13 19:58:18 +02:00
let z = (1u8,1u8);
2016-06-22 02:17:26 +02:00
match z {
(2...3, 7...9) => dummy(),
2015-04-13 19:58:18 +02:00
_ => {}
2016-06-22 02:17:26 +02:00
};
// Not linted (pattern guards used)
match x {
Some(y) if y == 0 => println!("{:?}", y),
_ => ()
}
// Not linted (no block with statements in the single arm)
match z {
(2...3, 7...9) => println!("{:?}", z),
_ => println!("nope"),
}
2015-04-13 19:58:18 +02:00
}
2016-01-13 01:19:27 +01:00
fn single_match_know_enum() {
let x = Some(1u8);
let y : Result<_, i8> = Ok(1i8);
2016-06-22 02:17:26 +02:00
match x {
Some(y) => dummy(),
2016-01-13 01:19:27 +01:00
None => ()
2016-06-22 02:17:26 +02:00
};
2016-01-13 01:19:27 +01:00
2016-06-22 02:17:26 +02:00
match y {
Ok(y) => dummy(),
2016-01-13 01:19:27 +01:00
Err(..) => ()
2016-06-22 02:17:26 +02:00
};
2016-01-13 01:19:27 +01:00
let c = Cow::Borrowed("");
2016-06-22 02:17:26 +02:00
match c {
Cow::Borrowed(..) => dummy(),
2016-01-13 01:19:27 +01:00
Cow::Owned(..) => (),
2016-06-22 02:17:26 +02:00
};
2016-01-13 01:19:27 +01:00
let z = Foo::Bar;
// no warning
match z {
Bar => println!("42"),
Baz(_) => (),
}
match z {
Baz(_) => println!("42"),
Bar => (),
}
}
fn match_bool() {
let test: bool = true;
match test {
true => 0,
false => 42,
};
let option = 1;
match option == 1 {
2015-10-21 08:24:56 +02:00
true => 1,
false => 0,
};
2015-12-23 01:14:10 +01:00
match test {
true => (),
false => { println!("Noooo!"); }
2015-10-21 08:24:56 +02:00
};
2015-12-23 01:14:10 +01:00
match test {
2016-06-29 21:50:21 +02:00
false => { println!("Noooo!"); }
_ => (),
};
match test && test {
false => { println!("Noooo!"); }
2015-10-21 08:24:56 +02:00
_ => (),
};
2015-12-23 01:14:10 +01:00
match test {
false => { println!("Noooo!"); }
true => { println!("Yes!"); }
};
// Not linted
match option {
1 ... 10 => 1,
11 ... 20 => 2,
_ => 3,
};
}
fn ref_pats() {
2015-09-02 08:19:47 +02:00
{
let v = &Some(0);
2016-03-09 16:22:31 +01:00
match v {
2015-09-02 08:19:47 +02:00
&Some(v) => println!("{:?}", v),
&None => println!("none"),
}
match v { // this doesn't trigger, we have a different pattern
&Some(v) => println!("some"),
other => println!("other"),
}
}
let tup =& (1, 2);
2016-03-09 16:22:31 +01:00
match tup {
&(v, 1) => println!("{}", v),
_ => println!("none"),
}
// special case: using & both in expr and pats
let w = Some(0);
2016-03-09 16:22:31 +01:00
match &w {
&Some(v) => println!("{:?}", v),
&None => println!("none"),
}
// false positive: only wildcard pattern
let w = Some(0);
match w {
_ => println!("none"),
}
let a = &Some(0);
2016-03-09 16:22:31 +01:00
if let &None = a {
println!("none");
}
let b = Some(0);
2016-03-09 16:22:31 +01:00
if let &None = &b {
println!("none");
}
}
2015-12-23 01:14:10 +01:00
fn overlapping() {
const FOO : u64 = 2;
match 42 {
2017-02-08 14:58:07 +01:00
0 ... 10 => println!("0 ... 10"),
0 ... 11 => println!("0 ... 11"),
2015-12-23 01:14:10 +01:00
_ => (),
}
match 42 {
2017-02-08 14:58:07 +01:00
0 ... 5 => println!("0 ... 5"),
2015-12-23 01:14:10 +01:00
6 ... 7 => println!("6 ... 7"),
2017-02-08 14:58:07 +01:00
FOO ... 11 => println!("0 ... 11"),
2015-12-23 01:14:10 +01:00
_ => (),
}
match 42 {
2017-02-08 14:58:07 +01:00
2 => println!("2"),
0 ... 5 => println!("0 ... 5"),
_ => (),
}
match 42 {
2017-02-08 14:58:07 +01:00
2 => println!("2"),
0 ... 2 => println!("0 ... 2"),
_ => (),
}
2015-12-23 01:14:10 +01:00
match 42 {
0 ... 10 => println!("0 ... 10"),
2017-01-31 08:08:54 +01:00
11 ... 50 => println!("11 ... 50"),
2015-12-23 01:14:10 +01:00
_ => (),
}
match 42 {
2 => println!("2"),
0 .. 2 => println!("0 .. 2"),
_ => (),
}
match 42 {
2017-01-31 08:08:54 +01:00
0 .. 10 => println!("0 .. 10"),
10 .. 50 => println!("10 .. 50"),
_ => (),
}
match 42 {
2017-02-08 14:58:07 +01:00
0 .. 11 => println!("0 .. 11"),
0 ... 11 => println!("0 ... 11"),
_ => (),
}
2016-05-31 22:01:56 +02:00
if let None = Some(42) {
// nothing
} else if let None = Some(42) {
// another nothing :-)
}
2015-12-23 01:14:10 +01:00
}
2017-02-11 07:57:50 +01:00
fn match_wild_err_arm() {
let x: Result<i32, &str> = Ok(3);
match x {
Ok(3) => println!("ok"),
Ok(_) => println!("ok"),
2017-02-11 14:42:42 +01:00
Err(_) => panic!("err")
2017-02-11 07:57:50 +01:00
}
match x {
Ok(3) => println!("ok"),
Ok(_) => println!("ok"),
2017-02-11 14:42:42 +01:00
Err(_) => {panic!()}
2017-02-11 07:57:50 +01:00
}
match x {
Ok(3) => println!("ok"),
Ok(_) => println!("ok"),
2017-02-11 14:42:42 +01:00
Err(_) => {panic!();}
2017-02-11 07:57:50 +01:00
}
2017-02-11 14:42:42 +01:00
// allowed when not with `panic!` block
match x {
Ok(3) => println!("ok"),
Ok(_) => println!("ok"),
Err(_) => println!("err")
}
// allowed when used with `unreachable!`
2017-02-11 07:57:50 +01:00
match x {
Ok(3) => println!("ok"),
Ok(_) => println!("ok"),
Err(_) => {unreachable!()}
}
2017-02-11 14:42:42 +01:00
match x {
Ok(3) => println!("ok"),
Ok(_) => println!("ok"),
Err(_) => unreachable!()
}
2017-02-11 07:57:50 +01:00
match x {
Ok(3) => println!("ok"),
Ok(_) => println!("ok"),
Err(_) => {unreachable!();}
}
}
fn main() {
}