mirror of
https://github.com/rust-lang/rust.git
synced 2024-12-12 16:45:37 +00:00
223 lines
5.0 KiB
Rust
223 lines
5.0 KiB
Rust
// run-rustfix
|
|
#![warn(clippy::needless_match)]
|
|
#![allow(clippy::manual_map)]
|
|
#![allow(dead_code)]
|
|
|
|
#[derive(Clone, Copy)]
|
|
enum Simple {
|
|
A,
|
|
B,
|
|
C,
|
|
D,
|
|
}
|
|
|
|
fn useless_match() {
|
|
let i = 10;
|
|
let _: i32 = match i {
|
|
0 => 0,
|
|
1 => 1,
|
|
2 => 2,
|
|
_ => i,
|
|
};
|
|
let s = "test";
|
|
let _: &str = match s {
|
|
"a" => "a",
|
|
"b" => "b",
|
|
s => s,
|
|
};
|
|
}
|
|
|
|
fn custom_type_match() {
|
|
let se = Simple::A;
|
|
let _: Simple = match se {
|
|
Simple::A => Simple::A,
|
|
Simple::B => Simple::B,
|
|
Simple::C => Simple::C,
|
|
Simple::D => Simple::D,
|
|
};
|
|
// Don't trigger
|
|
let _: Simple = match se {
|
|
Simple::A => Simple::A,
|
|
Simple::B => Simple::B,
|
|
_ => Simple::C,
|
|
};
|
|
// Mingled, don't trigger
|
|
let _: Simple = match se {
|
|
Simple::A => Simple::B,
|
|
Simple::B => Simple::C,
|
|
Simple::C => Simple::D,
|
|
Simple::D => Simple::A,
|
|
};
|
|
}
|
|
|
|
fn option_match(x: Option<i32>) {
|
|
let _: Option<i32> = match x {
|
|
Some(a) => Some(a),
|
|
None => None,
|
|
};
|
|
// Don't trigger, this is the case for manual_map_option
|
|
let _: Option<i32> = match x {
|
|
Some(a) => Some(-a),
|
|
None => None,
|
|
};
|
|
}
|
|
|
|
fn func_ret_err<T>(err: T) -> Result<i32, T> {
|
|
Err(err)
|
|
}
|
|
|
|
fn result_match() {
|
|
let _: Result<i32, i32> = match Ok(1) {
|
|
Ok(a) => Ok(a),
|
|
Err(err) => Err(err),
|
|
};
|
|
let _: Result<i32, i32> = match func_ret_err(0_i32) {
|
|
Err(err) => Err(err),
|
|
Ok(a) => Ok(a),
|
|
};
|
|
// as ref, don't trigger
|
|
let res = &func_ret_err(0_i32);
|
|
let _: Result<&i32, &i32> = match *res {
|
|
Ok(ref x) => Ok(x),
|
|
Err(ref x) => Err(x),
|
|
};
|
|
}
|
|
|
|
fn if_let_option() {
|
|
let _ = if let Some(a) = Some(1) { Some(a) } else { None };
|
|
|
|
fn do_something() {}
|
|
|
|
// Don't trigger
|
|
let _ = if let Some(a) = Some(1) {
|
|
Some(a)
|
|
} else {
|
|
do_something();
|
|
None
|
|
};
|
|
|
|
// Don't trigger
|
|
let _ = if let Some(a) = Some(1) {
|
|
do_something();
|
|
Some(a)
|
|
} else {
|
|
None
|
|
};
|
|
}
|
|
|
|
fn if_let_result() {
|
|
let x: Result<i32, i32> = Ok(1);
|
|
let _: Result<i32, i32> = if let Err(e) = x { Err(e) } else { x };
|
|
let _: Result<i32, i32> = if let Ok(val) = x { Ok(val) } else { x };
|
|
// Input type mismatch, don't trigger
|
|
let _: Result<i32, i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
|
|
}
|
|
|
|
fn if_let_custom_enum(x: Simple) {
|
|
let _: Simple = if let Simple::A = x {
|
|
Simple::A
|
|
} else if let Simple::B = x {
|
|
Simple::B
|
|
} else if let Simple::C = x {
|
|
Simple::C
|
|
} else {
|
|
x
|
|
};
|
|
|
|
// Don't trigger
|
|
let _: Simple = if let Simple::A = x {
|
|
Simple::A
|
|
} else if true {
|
|
Simple::B
|
|
} else {
|
|
x
|
|
};
|
|
}
|
|
|
|
mod issue8542 {
|
|
#[derive(Clone, Copy)]
|
|
enum E {
|
|
VariantA(u8, u8),
|
|
VariantB(u8, bool),
|
|
}
|
|
|
|
enum Complex {
|
|
A(u8),
|
|
B(u8, bool),
|
|
C(u8, i32, f64),
|
|
D(E, bool),
|
|
}
|
|
|
|
fn match_test() {
|
|
let ce = Complex::B(8, false);
|
|
let aa = 0_u8;
|
|
let bb = false;
|
|
|
|
let _: Complex = match ce {
|
|
Complex::A(a) => Complex::A(a),
|
|
Complex::B(a, b) => Complex::B(a, b),
|
|
Complex::C(a, b, c) => Complex::C(a, b, c),
|
|
Complex::D(E::VariantA(ea, eb), b) => Complex::D(E::VariantA(ea, eb), b),
|
|
Complex::D(E::VariantB(ea, eb), b) => Complex::D(E::VariantB(ea, eb), b),
|
|
};
|
|
|
|
// Don't trigger
|
|
let _: Complex = match ce {
|
|
Complex::A(_) => Complex::A(aa),
|
|
Complex::B(_, b) => Complex::B(aa, b),
|
|
Complex::C(_, b, _) => Complex::C(aa, b, 64_f64),
|
|
Complex::D(e, b) => Complex::D(e, b),
|
|
};
|
|
|
|
// Don't trigger
|
|
let _: Complex = match ce {
|
|
Complex::A(a) => Complex::A(a),
|
|
Complex::B(a, _) => Complex::B(a, bb),
|
|
Complex::C(a, _, _) => Complex::C(a, 32_i32, 64_f64),
|
|
_ => ce,
|
|
};
|
|
}
|
|
}
|
|
|
|
/// Lint triggered when type coercions happen.
|
|
/// Do NOT trigger on any of these.
|
|
mod issue8551 {
|
|
trait Trait {}
|
|
struct Struct;
|
|
impl Trait for Struct {}
|
|
|
|
fn optmap(s: Option<&Struct>) -> Option<&dyn Trait> {
|
|
match s {
|
|
Some(s) => Some(s),
|
|
None => None,
|
|
}
|
|
}
|
|
|
|
fn lint_tests() {
|
|
let option: Option<&Struct> = None;
|
|
let _: Option<&dyn Trait> = match option {
|
|
Some(s) => Some(s),
|
|
None => None,
|
|
};
|
|
|
|
let _: Option<&dyn Trait> = if true {
|
|
match option {
|
|
Some(s) => Some(s),
|
|
None => None,
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let result: Result<&Struct, i32> = Err(0);
|
|
let _: Result<&dyn Trait, i32> = match result {
|
|
Ok(s) => Ok(s),
|
|
Err(e) => Err(e),
|
|
};
|
|
|
|
let _: Option<&dyn Trait> = if let Some(s) = option { Some(s) } else { None };
|
|
}
|
|
}
|
|
|
|
fn main() {}
|