1use super::ToTokens;
2use super::lex::{Cursor, LexError, Scan};
3use crate::{Span, Spanner, TokenStream, TokenTree};
4
5macro_rules! define_keyword {
6 ($($name:ident[$is_method:ident, $as_method:ident] => $text:literal),+ $(,)?) => {
7 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
9 pub enum Keyword {
10 $($name($name),)*
11 }
12
13 impl Keyword {
14 #[inline]
15 pub fn as_str(&self) -> &'static str {
16 match self {
17 $(Self::$name(v) => v.as_str(),)*
18 }
19 }
20
21 #[inline]
22 pub fn span(&self) -> Span {
23 match self {
24 $(Self::$name(v) => v.span(),)*
25 }
26 }
27
28 #[inline]
29 pub fn set_span(&mut self, span: Span) {
30 match self {
31 $(Self::$name(v) => v.set_span(span),)*
32 }
33 }
34
35 #[inline]
36 pub fn from_str(text: &str, span: Span) -> Option<Self> {
37 match text {
38 $($text => Some(Self::$name($name::new(span))),)*
39 _ => None,
40 }
41 }
42
43 #[inline]
44 pub fn to_token_tree(&self) -> TokenTree {
45 TokenTree::Keyword(*self)
46 }
47
48 #[inline]
49 pub fn into_token_tree(self) -> TokenTree {
50 TokenTree::Keyword(self)
51 }
52 }
53
54 impl Scan for Keyword {
55 fn scan(cursor: Cursor<'_>) -> Result<(Cursor<'_>, Self), LexError> {
56 let (end, id) = super::Ident::scan(cursor)?;
57
58 if id.is_raw() {
59 return cursor.error().into();
60 }
61
62 match id.text() {
63 $($text => Ok((end, Self::$name($name::new(id.span())))),)*
64 _ => cursor.error().into(),
65 }
66 }
67 }
68
69 impl ToTokens for Keyword {
70 fn to_tokens(&self, tokens: &mut TokenStream) {
71 match self {
72 $(Self::$name(v) => v.to_tokens(tokens),)*
73 }
74 }
75 }
76
77 impl Spanner for Keyword {
78 fn span(&self) -> Span {
79 self.span()
80 }
81 }
82
83 impl std::fmt::Display for Keyword {
84 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
85 match self {
86 $(Self::$name(v) => v.fmt(f),)*
87 }
88 }
89 }
90
91 #[cfg(feature = "serde")]
92 impl serde::Serialize for Keyword {
93 fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
94 where
95 S: serde::Serializer,
96 {
97 self.as_str().serialize(s)
98 }
99 }
100
101 $(
102 #[doc = concat!("The Rust keyword token `", $text, "`. ")]
103 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
104 pub struct $name {
105 span: Span,
106 }
107
108 impl $name {
109 pub const TEXT: &'static str = $text;
110
111 #[inline]
112 pub fn new(span: Span) -> Self {
113 Self { span }
114 }
115
116 #[inline]
117 pub fn span(&self) -> Span {
118 self.span
119 }
120
121 #[inline]
122 pub fn set_span(&mut self, span: Span) {
123 self.span = span;
124 }
125
126 #[inline]
127 pub fn as_str(&self) -> &'static str {
128 Self::TEXT
129 }
130 }
131
132 impl std::fmt::Display for $name {
133 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
134 f.write_str($text)
135 }
136 }
137
138 impl Scan for $name {
139 fn scan(cursor: Cursor<'_>) -> Result<(Cursor<'_>, Self), LexError> {
140 let (end, id) = super::Ident::scan(cursor)?;
141
142 if !id.is_raw() && id.text() == $text {
143 Ok((end, Self::new(id.span())))
144 } else {
145 cursor.error().into()
146 }
147 }
148 }
149
150 impl ToTokens for $name {
151 fn to_tokens(&self, tokens: &mut TokenStream) {
152 tokens.extend_one(TokenTree::Keyword(Keyword::$name(*self)));
153 }
154 }
155
156 impl Spanner for $name {
157 fn span(&self) -> Span {
158 self.span
159 }
160 }
161
162 impl From<$name> for Keyword {
163 fn from(value: $name) -> Self {
164 Self::$name(value)
165 }
166 }
167
168 #[cfg(feature = "serde")]
169 impl serde::Serialize for $name {
170 fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
171 where
172 S: serde::Serializer,
173 {
174 self.as_str().serialize(s)
175 }
176 }
177 )+
178
179 impl TokenTree {
180 pub fn is_keyword(&self) -> bool {
181 matches!(self, Self::Keyword(_))
182 }
183
184 pub fn as_keyword(&self) -> Option<&Keyword> {
185 match self {
186 Self::Keyword(v) => Some(v),
187 _ => None,
188 }
189 }
190
191 $(
192 #[doc = concat!("**", stringify!($name), "** (\"", $text, "\")")]
193 pub fn $is_method(&self) -> bool {
194 matches!(self, Self::Keyword(Keyword::$name(_)))
195 }
196
197 #[doc = concat!("**", stringify!($name), "** (\"", $text, "\")")]
198 pub fn $as_method(&self) -> Option<&$name> {
199 match self {
200 Self::Keyword(Keyword::$name(v)) => Some(v),
201 _ => None,
202 }
203 }
204 )*
205 }
206 };
207}
208
209define_keyword! {
210 As[is_keyword_as, as_keyword_as] => "as",
211 Async[is_keyword_async, as_keyword_async] => "async",
212 Auto[is_keyword_auto, as_keyword_auto] => "auto",
213 Await[is_keyword_await, as_keyword_await] => "await",
214 Become[is_keyword_become, as_keyword_become] => "become",
215 Box[is_keyword_box, as_keyword_box] => "box",
216 Break[is_keyword_break, as_keyword_break] => "break",
217 Const[is_keyword_const, as_keyword_const] => "const",
218 Continue[is_keyword_continue, as_keyword_continue] => "continue",
219 Crate[is_keyword_crate, as_keyword_crate] => "crate",
220 Default[is_keyword_default, as_keyword_default] => "default",
221 Do[is_keyword_do, as_keyword_do] => "do",
222 Dyn[is_keyword_dyn, as_keyword_dyn] => "dyn",
223 Else[is_keyword_else, as_keyword_else] => "else",
224 Enum[is_keyword_enum, as_keyword_enum] => "enum",
225 Extern[is_keyword_extern, as_keyword_extern] => "extern",
226 Final[is_keyword_final, as_keyword_final] => "final",
227 Fn[is_keyword_fn, as_keyword_fn] => "fn",
228 For[is_keyword_for, as_keyword_for] => "for",
229 If[is_keyword_if, as_keyword_if] => "if",
230 Impl[is_keyword_impl, as_keyword_impl] => "impl",
231 In[is_keyword_in, as_keyword_in] => "in",
232 Let[is_keyword_let, as_keyword_let] => "let",
233 Loop[is_keyword_loop, as_keyword_loop] => "loop",
234 Macro[is_keyword_macro, as_keyword_macro] => "macro",
235 MacroRules[is_keyword_macro_rules, as_keyword_macro_rules] => "macro_rules",
236 Match[is_keyword_match, as_keyword_match] => "match",
237 Mod[is_keyword_mod, as_keyword_mod] => "mod",
238 Move[is_keyword_move, as_keyword_move] => "move",
239 Mut[is_keyword_mut, as_keyword_mut] => "mut",
240 Override[is_keyword_override, as_keyword_override] => "override",
241 Priv[is_keyword_priv, as_keyword_priv] => "priv",
242 Pub[is_keyword_pub, as_keyword_pub] => "pub",
243 Raw[is_keyword_raw, as_keyword_raw] => "raw",
244 Ref[is_keyword_ref, as_keyword_ref] => "ref",
245 Return[is_keyword_return, as_keyword_return] => "return",
246 SelfType[is_keyword_self_type, as_keyword_self_type] => "Self",
247 SelfValue[is_keyword_self_value, as_keyword_self_value] => "self",
248 Static[is_keyword_static, as_keyword_static] => "static",
249 Struct[is_keyword_struct, as_keyword_struct] => "struct",
250 Super[is_keyword_super, as_keyword_super] => "super",
251 Trait[is_keyword_trait, as_keyword_trait] => "trait",
252 Try[is_keyword_try, as_keyword_try] => "try",
253 Type[is_keyword_type, as_keyword_type] => "type",
254 Typeof[is_keyword_typeof, as_keyword_typeof] => "typeof",
255 Union[is_keyword_union, as_keyword_union] => "union",
256 Unsafe[is_keyword_unsafe, as_keyword_unsafe] => "unsafe",
257 Unsized[is_keyword_unsized, as_keyword_unsized] => "unsized",
258 Use[is_keyword_use, as_keyword_use] => "use",
259 Virtual[is_keyword_virtual, as_keyword_virtual] => "virtual",
260 Where[is_keyword_where, as_keyword_where] => "where",
261 While[is_keyword_while, as_keyword_while] => "while",
262 Yield[is_keyword_yield, as_keyword_yield] => "yield",
263}