1use derive_more::Display;
2use num_derive::{FromPrimitive, ToPrimitive};
3
4#[derive(
5 Debug, Display, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, ToPrimitive, FromPrimitive,
6)]
7pub enum SyntaxKind {
8 #[display("whitespace")]
10 Whitespace,
11
12 #[display("line comment")]
13 LineComment,
14
15 #[display("block comment")]
16 BlockComment,
17
18 #[display("string literal")]
20 String,
21
22 #[display("hex literal")]
23 Hex,
24
25 #[display("integer literal")]
26 Integer,
27
28 #[display("identifier")]
29 Ident,
30
31 #[display("`nil`")]
33 Nil,
34
35 #[display("`true`")]
36 True,
37
38 #[display("`false`")]
39 False,
40
41 #[display("`export`")]
42 Export,
43
44 #[display("`extern`")]
45 Extern,
46
47 #[display("`inline`")]
48 Inline,
49
50 #[display("`test`")]
51 Test,
52
53 #[display("`mod`")]
54 Mod,
55
56 #[display("`fn`")]
57 Fn,
58
59 #[display("`const`")]
60 Const,
61
62 #[display("`type`")]
63 Type,
64
65 #[display("`struct`")]
66 Struct,
67
68 #[display("`let`")]
69 Let,
70
71 #[display("`if`")]
72 If,
73
74 #[display("`else`")]
75 Else,
76
77 #[display("`return`")]
78 Return,
79
80 #[display("`assert`")]
81 Assert,
82
83 #[display("`raise`")]
84 Raise,
85
86 #[display("`is`")]
87 Is,
88
89 #[display("`as`")]
90 As,
91
92 #[display("`(`")]
94 OpenParen,
95
96 #[display("`)`")]
97 CloseParen,
98
99 #[display("`{{`")]
100 OpenBrace,
101
102 #[display("`}}`")]
103 CloseBrace,
104
105 #[display("`[`")]
106 OpenBracket,
107
108 #[display("`]`")]
109 CloseBracket,
110
111 #[display("`+`")]
113 Plus,
114
115 #[display("`-`")]
116 Minus,
117
118 #[display("`*`")]
119 Star,
120
121 #[display("`/`")]
122 Slash,
123
124 #[display("`%`")]
125 Percent,
126
127 #[display("`==`")]
129 Equals,
130
131 #[display("`!=`")]
132 NotEquals,
133
134 #[display("`<`")]
135 LessThan,
136
137 #[display("`>`")]
138 GreaterThan,
139
140 #[display("`<=`")]
141 LessThanEquals,
142
143 #[display("`>=`")]
144 GreaterThanEquals,
145
146 #[display("`!`")]
148 Not,
149
150 #[display("`&&`")]
151 And,
152
153 #[display("`||`")]
154 Or,
155
156 #[display("`~`")]
158 BitwiseNot,
159
160 #[display("`&`")]
161 BitwiseAnd,
162
163 #[display("`|`")]
164 BitwiseOr,
165
166 #[display("`^`")]
167 BitwiseXor,
168
169 #[display("`<<`")]
170 LeftShift,
171
172 #[display("`>>`")]
173 RightShift,
174
175 #[display("`=`")]
177 Assign,
178
179 #[display("`.`")]
180 Dot,
181
182 #[display("`,`")]
183 Comma,
184
185 #[display("`:`")]
186 Colon,
187
188 #[display("`;`")]
189 Semicolon,
190
191 #[display("`->`")]
192 Arrow,
193
194 #[display("`=>`")]
195 FatArrow,
196
197 #[display("`::`")]
198 PathSeparator,
199
200 #[display("`...`")]
201 Spread,
202
203 #[display("document")]
205 Document,
206
207 #[display("module item")]
208 ModuleItem,
209
210 #[display("function item")]
211 FunctionItem,
212
213 #[display("function parameter")]
214 FunctionParameter,
215
216 #[display("constant item")]
217 ConstantItem,
218
219 #[display("type alias item")]
220 TypeAliasItem,
221
222 #[display("struct item")]
223 StructItem,
224
225 #[display("struct field")]
226 StructField,
227
228 #[display("generic parameters")]
229 GenericParameters,
230
231 #[display("generic arguments")]
232 GenericArguments,
233
234 #[display("literal type")]
235 LiteralType,
236
237 #[display("path type")]
238 PathType,
239
240 #[display("union type")]
241 UnionType,
242
243 #[display("group type")]
244 GroupType,
245
246 #[display("pair type")]
247 PairType,
248
249 #[display("list type")]
250 ListType,
251
252 #[display("list type item")]
253 ListTypeItem,
254
255 #[display("lambda type")]
256 LambdaType,
257
258 #[display("lambda parameter")]
259 LambdaParameter,
260
261 #[display("block")]
262 Block,
263
264 #[display("let statement")]
265 LetStmt,
266
267 #[display("expression statement")]
268 ExprStmt,
269
270 #[display("if statement")]
271 IfStmt,
272
273 #[display("return statement")]
274 ReturnStmt,
275
276 #[display("assert statement")]
277 AssertStmt,
278
279 #[display("raise statement")]
280 RaiseStmt,
281
282 #[display("path expression")]
283 PathExpr,
284
285 #[display("path segment")]
286 PathSegment,
287
288 #[display("leading path separator")]
289 LeadingPathSeparator,
290
291 #[display("struct initializer expression")]
292 StructInitializerExpr,
293
294 #[display("struct initializer field")]
295 StructInitializerField,
296
297 #[display("literal expression")]
298 LiteralExpr,
299
300 #[display("group expression")]
301 GroupExpr,
302
303 #[display("pair expression")]
304 PairExpr,
305
306 #[display("list expression")]
307 ListExpr,
308
309 #[display("list item")]
310 ListItem,
311
312 #[display("prefix expression")]
313 PrefixExpr,
314
315 #[display("binary expression")]
316 BinaryExpr,
317
318 #[display("function call expression")]
319 FunctionCallExpr,
320
321 #[display("if expression")]
322 IfExpr,
323
324 #[display("guard expression")]
325 GuardExpr,
326
327 #[display("cast expression")]
328 CastExpr,
329
330 #[display("field access expression")]
331 FieldAccessExpr,
332
333 #[display("lambda expression")]
334 LambdaExpr,
335
336 #[display("named binding")]
337 NamedBinding,
338
339 #[display("pair binding")]
340 PairBinding,
341
342 #[display("list binding")]
343 ListBinding,
344
345 #[display("list binding item")]
346 ListBindingItem,
347
348 #[display("struct binding")]
349 StructBinding,
350
351 #[display("struct field binding")]
352 StructFieldBinding,
353
354 #[display("error")]
356 Error,
357
358 #[display("eof")]
359 Eof,
360}
361
362#[macro_export]
363macro_rules! T {
364 [nil] => { $crate::SyntaxKind::Nil };
365 [true] => { $crate::SyntaxKind::True };
366 [false] => { $crate::SyntaxKind::False };
367 [export] => { $crate::SyntaxKind::Export };
368 [extern] => { $crate::SyntaxKind::Extern };
369 [inline] => { $crate::SyntaxKind::Inline };
370 [test] => { $crate::SyntaxKind::Test };
371 [mod] => { $crate::SyntaxKind::Mod };
372 [fn] => { $crate::SyntaxKind::Fn };
373 [const] => { $crate::SyntaxKind::Const };
374 [type] => { $crate::SyntaxKind::Type };
375 [struct] => { $crate::SyntaxKind::Struct };
376 [let] => { $crate::SyntaxKind::Let };
377 [if] => { $crate::SyntaxKind::If };
378 [else] => { $crate::SyntaxKind::Else };
379 [return] => { $crate::SyntaxKind::Return };
380 [assert] => { $crate::SyntaxKind::Assert };
381 [raise] => { $crate::SyntaxKind::Raise };
382 [is] => { $crate::SyntaxKind::Is };
383 [as] => { $crate::SyntaxKind::As };
384 ['('] => { $crate::SyntaxKind::OpenParen };
385 [')'] => { $crate::SyntaxKind::CloseParen };
386 ['{'] => { $crate::SyntaxKind::OpenBrace };
387 ['}'] => { $crate::SyntaxKind::CloseBrace };
388 ['['] => { $crate::SyntaxKind::OpenBracket };
389 [']'] => { $crate::SyntaxKind::CloseBracket };
390 [+] => { $crate::SyntaxKind::Plus };
391 [-] => { $crate::SyntaxKind::Minus };
392 [*] => { $crate::SyntaxKind::Star };
393 [/] => { $crate::SyntaxKind::Slash };
394 [%] => { $crate::SyntaxKind::Percent };
395 [==] => { $crate::SyntaxKind::Equals };
396 [!=] => { $crate::SyntaxKind::NotEquals };
397 [<] => { $crate::SyntaxKind::LessThan };
398 [>] => { $crate::SyntaxKind::GreaterThan };
399 [<=] => { $crate::SyntaxKind::LessThanEquals };
400 [>=] => { $crate::SyntaxKind::GreaterThanEquals };
401 [!] => { $crate::SyntaxKind::Not };
402 [&&] => { $crate::SyntaxKind::And };
403 [||] => { $crate::SyntaxKind::Or };
404 [&] => { $crate::SyntaxKind::BitwiseAnd };
405 [|] => { $crate::SyntaxKind::BitwiseOr };
406 [~] => { $crate::SyntaxKind::BitwiseNot };
407 [^] => { $crate::SyntaxKind::BitwiseXor };
408 [<<] => { $crate::SyntaxKind::LeftShift };
409 [>>] => { $crate::SyntaxKind::RightShift };
410 [=] => { $crate::SyntaxKind::Assign };
411 [.] => { $crate::SyntaxKind::Dot };
412 [,] => { $crate::SyntaxKind::Comma };
413 [:] => { $crate::SyntaxKind::Colon };
414 [;] => { $crate::SyntaxKind::Semicolon };
415 [->] => { $crate::SyntaxKind::Arrow };
416 [=>] => { $crate::SyntaxKind::FatArrow };
417 [::] => { $crate::SyntaxKind::PathSeparator };
418 [...] => { $crate::SyntaxKind::Spread };
419}
420
421impl SyntaxKind {
422 pub const LITERAL: &[Self] = &[
423 SyntaxKind::String,
424 SyntaxKind::Hex,
425 SyntaxKind::Integer,
426 T![nil],
427 T![true],
428 T![false],
429 ];
430 pub const PREFIX_OPS: &[Self] = &[T![!], T![-], T![+], T![~]];
431 pub const BINARY_OPS: &[Self] = &[
432 T![+],
433 T![-],
434 T![*],
435 T![/],
436 T![%],
437 T![<],
438 T![>],
439 T![<=],
440 T![>=],
441 T![==],
442 T![!=],
443 T![&&],
444 T![||],
445 T![&],
446 T![|],
447 T![^],
448 T![<<],
449 T![>>],
450 ];
451
452 pub fn is_trivia(&self) -> bool {
453 matches!(
454 self,
455 Self::Whitespace | Self::LineComment | Self::BlockComment | Self::Error
456 )
457 }
458
459 pub fn split(&self) -> &'static [Self] {
460 match self {
461 SyntaxKind::Whitespace => &[Self::Whitespace],
462 SyntaxKind::LineComment => &[Self::LineComment],
463 SyntaxKind::BlockComment => &[Self::BlockComment],
464 SyntaxKind::String => &[Self::String],
465 SyntaxKind::Hex => &[Self::Hex],
466 SyntaxKind::Integer => &[Self::Integer],
467 SyntaxKind::Ident => &[Self::Ident],
468 T![nil] => &[T![nil]],
469 T![true] => &[T![true]],
470 T![false] => &[T![false]],
471 T![export] => &[T![export]],
472 T![extern] => &[T![extern]],
473 T![inline] => &[T![inline]],
474 T![test] => &[T![test]],
475 T![mod] => &[T![mod]],
476 T![fn] => &[T![fn]],
477 T![const] => &[T![const]],
478 T![type] => &[T![type]],
479 T![struct] => &[T![struct]],
480 T![let] => &[T![let]],
481 T![if] => &[T![if]],
482 T![else] => &[T![else]],
483 T![return] => &[T![return]],
484 T![assert] => &[T![assert]],
485 T![raise] => &[T![raise]],
486 T![is] => &[T![is]],
487 T![as] => &[T![as]],
488 T!['('] => &[T!['(']],
489 T![')'] => &[T![')']],
490 T!['{'] => &[T!['{']],
491 T!['}'] => &[T!['}']],
492 T!['['] => &[T!['[']],
493 T![']'] => &[T![']']],
494 T![+] => &[T![+]],
495 T![-] => &[T![-]],
496 T![*] => &[T![*]],
497 T![/] => &[T![/]],
498 T![%] => &[T![%]],
499 T![==] => &[T![=], T![=]],
500 T![!=] => &[T![!], T![=]],
501 T![<] => &[T![<]],
502 T![>] => &[T![>]],
503 T![<=] => &[T![<], T![=]],
504 T![>=] => &[T![>], T![=]],
505 T![!] => &[T![!]],
506 T![&&] => &[T![&], T![&]],
507 T![||] => &[T![|], T![|]],
508 T![~] => &[T![~]],
509 T![&] => &[T![&]],
510 T![|] => &[T![|]],
511 T![^] => &[T![^]],
512 T![<<] => &[T![<], T![<]],
513 T![>>] => &[T![>], T![>]],
514 T![=] => &[T![=]],
515 T![.] => &[T![.]],
516 T![,] => &[T![,]],
517 T![:] => &[T![:]],
518 T![;] => &[T![;]],
519 T![->] => &[T![-], T![>]],
520 T![=>] => &[T![=], T![>]],
521 T![::] => &[T![:], T![:]],
522 T![...] => &[T![.], T![.], T![.]],
523 SyntaxKind::Document => &[SyntaxKind::Document],
524 SyntaxKind::ModuleItem => &[SyntaxKind::ModuleItem],
525 SyntaxKind::FunctionItem => &[SyntaxKind::FunctionItem],
526 SyntaxKind::FunctionParameter => &[SyntaxKind::FunctionParameter],
527 SyntaxKind::ConstantItem => &[SyntaxKind::ConstantItem],
528 SyntaxKind::TypeAliasItem => &[SyntaxKind::TypeAliasItem],
529 SyntaxKind::StructItem => &[SyntaxKind::StructItem],
530 SyntaxKind::StructField => &[SyntaxKind::StructField],
531 SyntaxKind::GenericParameters => &[SyntaxKind::GenericParameters],
532 SyntaxKind::GenericArguments => &[SyntaxKind::GenericArguments],
533 SyntaxKind::LiteralType => &[SyntaxKind::LiteralType],
534 SyntaxKind::PathType => &[SyntaxKind::PathType],
535 SyntaxKind::UnionType => &[SyntaxKind::UnionType],
536 SyntaxKind::GroupType => &[SyntaxKind::GroupType],
537 SyntaxKind::PairType => &[SyntaxKind::PairType],
538 SyntaxKind::ListType => &[SyntaxKind::ListType],
539 SyntaxKind::ListTypeItem => &[SyntaxKind::ListTypeItem],
540 SyntaxKind::LambdaType => &[SyntaxKind::LambdaType],
541 SyntaxKind::LambdaParameter => &[SyntaxKind::LambdaParameter],
542 SyntaxKind::Block => &[SyntaxKind::Block],
543 SyntaxKind::LetStmt => &[SyntaxKind::LetStmt],
544 SyntaxKind::ExprStmt => &[SyntaxKind::ExprStmt],
545 SyntaxKind::IfStmt => &[SyntaxKind::IfStmt],
546 SyntaxKind::ReturnStmt => &[SyntaxKind::ReturnStmt],
547 SyntaxKind::AssertStmt => &[SyntaxKind::AssertStmt],
548 SyntaxKind::RaiseStmt => &[SyntaxKind::RaiseStmt],
549 SyntaxKind::PathExpr => &[SyntaxKind::PathExpr],
550 SyntaxKind::PathSegment => &[SyntaxKind::PathSegment],
551 SyntaxKind::LeadingPathSeparator => &[SyntaxKind::LeadingPathSeparator],
552 SyntaxKind::StructInitializerExpr => &[SyntaxKind::StructInitializerExpr],
553 SyntaxKind::StructInitializerField => &[SyntaxKind::StructInitializerField],
554 SyntaxKind::LiteralExpr => &[SyntaxKind::LiteralExpr],
555 SyntaxKind::GroupExpr => &[SyntaxKind::GroupExpr],
556 SyntaxKind::PairExpr => &[SyntaxKind::PairExpr],
557 SyntaxKind::ListExpr => &[SyntaxKind::ListExpr],
558 SyntaxKind::ListItem => &[SyntaxKind::ListItem],
559 SyntaxKind::PrefixExpr => &[SyntaxKind::PrefixExpr],
560 SyntaxKind::BinaryExpr => &[SyntaxKind::BinaryExpr],
561 SyntaxKind::FunctionCallExpr => &[SyntaxKind::FunctionCallExpr],
562 SyntaxKind::IfExpr => &[SyntaxKind::IfExpr],
563 SyntaxKind::GuardExpr => &[SyntaxKind::GuardExpr],
564 SyntaxKind::CastExpr => &[SyntaxKind::CastExpr],
565 SyntaxKind::FieldAccessExpr => &[SyntaxKind::FieldAccessExpr],
566 SyntaxKind::LambdaExpr => &[SyntaxKind::LambdaExpr],
567 SyntaxKind::NamedBinding => &[SyntaxKind::NamedBinding],
568 SyntaxKind::PairBinding => &[SyntaxKind::PairBinding],
569 SyntaxKind::ListBinding => &[SyntaxKind::ListBinding],
570 SyntaxKind::ListBindingItem => &[SyntaxKind::ListBindingItem],
571 SyntaxKind::StructBinding => &[SyntaxKind::StructBinding],
572 SyntaxKind::StructFieldBinding => &[SyntaxKind::StructFieldBinding],
573 SyntaxKind::Error => &[SyntaxKind::Error],
574 SyntaxKind::Eof => &[SyntaxKind::Eof],
575 }
576 }
577}