1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
//@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 a == 2 {}
if a.cmp(&b) == Ordering::Greater {}
if c == Some(2) {}
if d == (Struct { a: 2, b: false }) {}
if e == Enum::TupleVariant(32, 64) {}
if e == (Enum::RecordVariant { a: 64, b: 32 }) {}
if e == Enum::UnitVariant {}
if (e, &d) == (Enum::UnitVariant, &Struct { a: 2, b: false }) {}
// 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 matches!(f, NotPartialEq::A) {}
if g == NotStructuralEq::A {}
if matches!(Some(f), Some(NotPartialEq::A)) {}
if Some(g) == Some(NotStructuralEq::A) {}
if matches!(h, NoPartialEqStruct { a: 2, b: false }) {}
if "abc" == inline!("abc") {
println!("OK");
}
external!({ if let 2 = $a {} });
}
|