141 lines
2.9 KiB
Rust
141 lines
2.9 KiB
Rust
//@aux-build:proc_macros.rs
|
|
|
|
#![allow(
|
|
unused_variables,
|
|
dead_code,
|
|
clippy::derive_partial_eq_without_eq,
|
|
clippy::needless_if
|
|
)]
|
|
#![warn(clippy::equatable_if_let)]
|
|
|
|
extern crate proc_macros;
|
|
use proc_macros::{external, inline_macros};
|
|
|
|
use std::cmp::Ordering;
|
|
|
|
#[derive(PartialEq)]
|
|
enum Enum {
|
|
TupleVariant(i32, u64),
|
|
RecordVariant { a: i64, b: u32 },
|
|
UnitVariant,
|
|
Recursive(Struct),
|
|
}
|
|
|
|
#[derive(PartialEq)]
|
|
struct Struct {
|
|
a: i32,
|
|
b: bool,
|
|
}
|
|
|
|
struct NoPartialEqStruct {
|
|
a: i32,
|
|
b: bool,
|
|
}
|
|
|
|
enum NotPartialEq {
|
|
A,
|
|
B,
|
|
}
|
|
|
|
enum NotStructuralEq {
|
|
A,
|
|
B,
|
|
}
|
|
|
|
impl PartialEq for NotStructuralEq {
|
|
fn eq(&self, _: &NotStructuralEq) -> bool {
|
|
false
|
|
}
|
|
}
|
|
|
|
#[inline_macros]
|
|
fn main() {
|
|
let a = 2;
|
|
let b = 3;
|
|
let c = Some(2);
|
|
let d = Struct { a: 2, b: false };
|
|
let e = Enum::UnitVariant;
|
|
let f = NotPartialEq::A;
|
|
let g = NotStructuralEq::A;
|
|
let h = NoPartialEqStruct { a: 2, b: false };
|
|
|
|
// true
|
|
|
|
if let 2 = a {}
|
|
//~^ equatable_if_let
|
|
if let Ordering::Greater = a.cmp(&b) {}
|
|
//~^ equatable_if_let
|
|
if let Some(2) = c {}
|
|
//~^ equatable_if_let
|
|
if let Struct { a: 2, b: false } = d {}
|
|
//~^ equatable_if_let
|
|
if let Enum::TupleVariant(32, 64) = e {}
|
|
//~^ equatable_if_let
|
|
if let Enum::RecordVariant { a: 64, b: 32 } = e {}
|
|
//~^ equatable_if_let
|
|
if let Enum::UnitVariant = e {}
|
|
//~^ equatable_if_let
|
|
if let (Enum::UnitVariant, &Struct { a: 2, b: false }) = (e, &d) {}
|
|
//~^ equatable_if_let
|
|
|
|
// false
|
|
|
|
if let 2 | 3 = a {}
|
|
if let x @ 2 = a {}
|
|
if let Some(3 | 4) = c {}
|
|
if let Struct { a, b: false } = d {}
|
|
if let Struct { a: 2, b: x } = d {}
|
|
if let NotPartialEq::A = f {}
|
|
//~^ equatable_if_let
|
|
if let NotStructuralEq::A = g {}
|
|
//~^ equatable_if_let
|
|
if let Some(NotPartialEq::A) = Some(f) {}
|
|
//~^ equatable_if_let
|
|
if let Some(NotStructuralEq::A) = Some(g) {}
|
|
//~^ equatable_if_let
|
|
if let NoPartialEqStruct { a: 2, b: false } = h {}
|
|
//~^ equatable_if_let
|
|
|
|
if let inline!("abc") = "abc" {
|
|
//~^ equatable_if_let
|
|
println!("OK");
|
|
}
|
|
|
|
external!({ if let 2 = $a {} });
|
|
}
|
|
|
|
mod issue8710 {
|
|
fn str_ref(cs: &[char]) {
|
|
if let Some('i') = cs.iter().next() {
|
|
//~^ equatable_if_let
|
|
} else {
|
|
todo!();
|
|
}
|
|
}
|
|
|
|
fn i32_ref(cs: &[i32]) {
|
|
if let Some(1) = cs.iter().next() {
|
|
//~^ equatable_if_let
|
|
} else {
|
|
todo!();
|
|
}
|
|
}
|
|
|
|
fn enum_ref() {
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
|
|
enum MyEnum {
|
|
A(i32),
|
|
B,
|
|
}
|
|
|
|
fn get_enum() -> Option<&'static MyEnum> {
|
|
todo!()
|
|
}
|
|
|
|
if let Some(MyEnum::B) = get_enum() {
|
|
//~^ equatable_if_let
|
|
} else {
|
|
todo!();
|
|
}
|
|
}
|
|
}
|