| //@aux-build:proc_macros.rs |
| #![feature(if_let_guard)] |
| #![allow(clippy::no_effect, unused)] |
| #![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)) => .., |
| _ => .., |
| }; |
| } |
| |
| // Do not lint |
| |
| fn f(s: Option<std::ffi::OsString>) { |
| match s { |
| Some(x) if x == "a" => {}, |
| Some(x) if "a" == x => {}, |
| _ => {}, |
| } |
| } |
| |
| 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) => {}, |
| _ => {}, |
| } |
| } |
| } |