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