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