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
|
// run-pass
// Check that it is possible to resolve, in the value namespace,
// to an `enum` variant through a type alias. This includes `Self`.
// Type qualified syntax `<Type>::Variant` also works when syntactically valid.
#[derive(Debug, PartialEq, Eq)]
enum Foo {
Bar(i32),
Baz { i: i32 },
Qux,
}
type FooAlias = Foo;
type OptionAlias = Option<i32>;
macro_rules! check_pat {
($x:expr, $p:pat) => {
assert!(if let $p = $x { true } else { false });
};
}
impl Foo {
fn bar() -> Self {
let x = Self::Bar(3);
assert_eq!(x, <Self>::Bar(3));
check_pat!(x, Self::Bar(3));
x
}
fn baz() -> Self {
let x = Self::Baz { i: 42 };
check_pat!(x, Self::Baz { i: 42 });
x
}
fn qux() -> Self {
let x = Self::Qux;
assert_eq!(x, <Self>::Qux);
check_pat!(x, Self::Qux);
check_pat!(x, <Self>::Qux);
x
}
}
fn main() {
let bar = Foo::Bar(1);
assert_eq!(bar, FooAlias::Bar(1));
assert_eq!(bar, <FooAlias>::Bar(1));
check_pat!(bar, FooAlias::Bar(1));
let baz = FooAlias::Baz { i: 2 };
assert_eq!(baz, Foo::Baz { i: 2 });
check_pat!(baz, FooAlias::Baz { i: 2 });
let qux = Foo::Qux;
assert_eq!(qux, FooAlias::Qux);
assert_eq!(qux, <FooAlias>::Qux);
check_pat!(qux, FooAlias::Qux);
check_pat!(qux, <FooAlias>::Qux);
assert_eq!(Foo::bar(), Foo::Bar(3));
assert_eq!(Foo::baz(), Foo::Baz { i: 42 });
assert_eq!(Foo::qux(), Foo::Qux);
let some = Option::Some(4);
assert_eq!(some, OptionAlias::Some(4));
check_pat!(some, OptionAlias::Some(4));
}
|
