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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
//@ check-pass
//@ revisions:e2015 e2018 e2021 e2024
//@[e2015] edition:2015
//@[e2018] edition:2018
//@[e2021] edition:2021
//@[e2024] edition:2024
// Ensure that all (usable as identifier) keywords work as raw identifiers in all positions.
// This was motivated by issue #137128, where `r#move`/`r#static`` did not work as `const` names
// due to a parser check not acounting for raw identifiers.
#![crate_type = "lib"]
#![allow(dead_code, nonstandard_style)]
// NOTE: It is vital to only use a `tt` fragment to avoid confusing
// the parser with nonterminals that can mask bugs.
macro_rules! tests {
($kw:tt) => {
mod $kw {
mod const_item {
const $kw: () = ();
}
mod static_item {
static $kw: () = ();
}
mod fn_item {
fn $kw() {}
}
mod mod_and_use_item {
mod $kw {
use super::$kw;
}
}
mod ty_alias_item {
type $kw = ();
}
mod struct_item {
struct $kw { $kw: () }
}
mod enum_item {
enum $kw { $kw }
}
mod union_item {
union $kw { $kw: () }
}
mod trait_item {
trait $kw {
fn $kw() {}
}
}
mod generics_and_impl {
struct A<$kw>($kw);
enum B<$kw> { A($kw) }
trait Tr<$kw> {
type $kw;
}
impl<$kw> Tr<$kw> for A<$kw> {
type $kw = ();
}
impl<$kw> B<$kw> {}
}
mod extern_crate {
#[cfg(any())]
extern crate $kw;
}
mod body {
fn expr() {
let $kw = 0;
let b = $kw;
assert_eq!($kw, b);
type $kw = ();
let $kw: $kw = ();
let _ = $kw as $kw;
}
fn pat_const() {
const $kw: u8 = 0;
// Ensure that $kw actually matches the constant.
#[forbid(unreachable_patterns)]
match 1 {
$kw => {}
_ => {}
}
}
fn pat_binding() {
match 1 {
$kw => {}
_ => {}
}
}
}
}
};
}
tests!(r#break);
tests!(r#const);
tests!(r#continue);
tests!(r#else);
tests!(r#enum);
tests!(r#extern);
tests!(r#false);
tests!(r#fn);
tests!(r#for);
tests!(r#if);
tests!(r#impl);
tests!(r#in);
tests!(r#let);
tests!(r#loop);
tests!(r#match);
tests!(r#mod);
tests!(r#move);
tests!(r#mut);
tests!(r#pub);
tests!(r#ref);
tests!(r#return);
tests!(r#static);
tests!(r#struct);
tests!(r#trait);
tests!(r#true);
tests!(r#type);
tests!(r#unsafe);
tests!(r#use);
tests!(r#where);
tests!(r#while);
tests!(r#abstract);
tests!(r#become);
tests!(r#box);
tests!(r#do);
tests!(r#final);
tests!(r#macro);
tests!(r#override);
tests!(r#priv);
tests!(r#typeof);
tests!(r#unsized);
tests!(r#virtual);
tests!(r#yield);
tests!(r#async);
tests!(r#await);
tests!(r#dyn);
tests!(r#gen);
tests!(r#try);
// Weak keywords:
tests!(auto);
tests!(builtin);
tests!(catch);
tests!(default);
tests!(macro_rules);
tests!(raw);
tests!(reuse);
tests!(contract_ensures);
tests!(contract_requires);
tests!(safe);
tests!(union);
tests!(yeet);
|
