rust-clippy/tests/ui/redundant_guards.rs

319 lines
6.6 KiB
Rust

//@aux-build:proc_macros.rs
#![feature(if_let_guard)]
#![allow(clippy::no_effect, unused, clippy::single_match)]
#![warn(clippy::redundant_guards)]
#[macro_use]
extern crate proc_macros;
struct A(u32);
struct B {
e: Option<A>,
}
struct C(u32, u32);
#[derive(PartialEq)]
struct FloatWrapper(f32);
fn issue11304() {
match 0.1 {
x if x == 0.0 => todo!(),
_ => todo!(),
}
match FloatWrapper(0.1) {
x if x == FloatWrapper(0.0) => todo!(),
_ => todo!(),
}
}
fn main() {
let c = C(1, 2);
match c {
C(x, y) if let 1 = y => ..,
_ => todo!(),
};
let x = Some(Some(1));
match x {
Some(x) if matches!(x, Some(1) if true) => ..,
Some(x) if matches!(x, Some(1)) => {
println!("a");
..
},
Some(x) if let Some(1) = x => ..,
Some(x) if x == Some(2) => ..,
Some(x) if Some(2) == x => ..,
// Don't lint, since x is used in the body
Some(x) if let Some(1) = x => {
x;
..
},
_ => todo!(),
};
let y = 1;
match x {
// Don't inline these, since y is not from the pat
Some(x) if matches!(y, 1 if true) => ..,
Some(x) if let 1 = y => ..,
Some(x) if y == 2 => ..,
Some(x) if 2 == y => ..,
_ => todo!(),
};
let a = A(1);
match a {
_ if a.0 == 1 => {},
_ if 1 == a.0 => {},
_ => todo!(),
}
let b = B { e: Some(A(0)) };
match b {
B { e } if matches!(e, Some(A(2))) => ..,
_ => todo!(),
};
// Do not lint, since we cannot represent this as a pattern (at least, without a conversion)
let v = Some(vec![1u8, 2, 3]);
match v {
Some(x) if x == [1] => {},
_ => {},
}
external! {
let x = Some(Some(1));
match x {
Some(x) if let Some(1) = x => ..,
_ => todo!(),
};
}
with_span! {
span
let x = Some(Some(1));
match x {
Some(x) if let Some(1) = x => ..,
_ => todo!(),
};
}
}
enum E {
A(&'static str),
B(&'static str),
C(&'static str),
}
fn i() {
match E::A("") {
// Do not lint
E::A(x) | E::B(x) | E::C(x) if x == "from an or pattern" => {},
E::A(y) if y == "not from an or pattern" => {},
_ => {},
};
}
fn h(v: Option<u32>) {
match v {
x if matches!(x, Some(0)) => ..,
_ => ..,
};
}
fn negative_literal(i: i32) {
match i {
i if i == -1 => {},
i if i == 1 => {},
_ => {},
}
}
// Do not lint
fn f(s: Option<std::ffi::OsString>) {
match s {
Some(x) if x == "a" => {},
Some(x) if "a" == x => {},
_ => {},
}
}
fn not_matches() {
match Some(42) {
// The pattern + guard is not equivalent to `Some(42)` because of the `panic!`
Some(v)
if match v {
42 => true,
_ => panic!(),
} => {},
_ => {},
}
}
struct S {
a: usize,
}
impl PartialEq for S {
fn eq(&self, _: &Self) -> bool {
true
}
}
impl Eq for S {}
static CONST_S: S = S { a: 1 };
fn g(opt_s: Option<S>) {
match opt_s {
Some(x) if x == CONST_S => {},
Some(x) if CONST_S == x => {},
_ => {},
}
}
mod issue11465 {
enum A {
Foo([u8; 3]),
}
struct B {
b: String,
c: i32,
}
fn issue11465() {
let c = Some(1);
match c {
Some(ref x) if x == &1 => {},
Some(ref x) if &1 == x => {},
Some(ref x) if let &2 = x => {},
Some(ref x) if matches!(x, &3) => {},
_ => {},
};
let enum_a = A::Foo([98, 97, 114]);
match enum_a {
A::Foo(ref arr) if arr == b"foo" => {},
A::Foo(ref arr) if b"foo" == arr => {},
A::Foo(ref arr) if let b"bar" = arr => {},
A::Foo(ref arr) if matches!(arr, b"baz") => {},
_ => {},
};
let struct_b = B {
b: "bar".to_string(),
c: 42,
};
match struct_b {
B { ref b, .. } if b == "bar" => {},
B { ref b, .. } if "bar" == b => {},
B { ref c, .. } if c == &1 => {},
B { ref c, .. } if &1 == c => {},
B { ref c, .. } if let &1 = c => {},
B { ref c, .. } if matches!(c, &1) => {},
_ => {},
}
}
}
fn issue11807() {
#![allow(clippy::single_match)]
match Some(Some("")) {
Some(Some(x)) if x.is_empty() => {},
_ => {},
}
match Some(Some(String::new())) {
// Do not lint: String deref-coerces to &str
Some(Some(x)) if x.is_empty() => {},
_ => {},
}
match Some(Some(&[] as &[i32])) {
Some(Some(x)) if x.is_empty() => {},
_ => {},
}
match Some(Some([] as [i32; 0])) {
Some(Some(x)) if x.is_empty() => {},
_ => {},
}
match Some(Some(Vec::<()>::new())) {
// Do not lint: Vec deref-coerces to &[T]
Some(Some(x)) if x.is_empty() => {},
_ => {},
}
match Some(Some(&[] as &[i32])) {
Some(Some(x)) if x.starts_with(&[]) => {},
_ => {},
}
match Some(Some(&[] as &[i32])) {
Some(Some(x)) if x.starts_with(&[1]) => {},
_ => {},
}
match Some(Some(&[] as &[i32])) {
Some(Some(x)) if x.starts_with(&[1, 2]) => {},
_ => {},
}
match Some(Some(&[] as &[i32])) {
Some(Some(x)) if x.ends_with(&[1, 2]) => {},
_ => {},
}
match Some(Some(Vec::<i32>::new())) {
// Do not lint: deref coercion
Some(Some(x)) if x.starts_with(&[1, 2]) => {},
_ => {},
}
}
mod issue12243 {
pub const fn const_fn(x: &str) {
match x {
// Shouldn't lint.
y if y.is_empty() => {},
_ => {},
}
}
pub fn non_const_fn(x: &str) {
match x {
y if y.is_empty() => {},
//~^ ERROR: redundant guard
_ => {},
}
}
struct Bar;
impl Bar {
pub const fn const_bar(x: &str) {
match x {
// Shouldn't lint.
y if y.is_empty() => {},
_ => {},
}
}
pub fn non_const_bar(x: &str) {
match x {
y if y.is_empty() => {},
//~^ ERROR: redundant guard
_ => {},
}
}
}
static FOO: () = {
match "" {
// Shouldn't lint.
x if x.is_empty() => {},
_ => {},
}
};
}