rue_parser/
syntax_kind.rs

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    // Trivia
9    #[display("whitespace")]
10    Whitespace,
11
12    #[display("line comment")]
13    LineComment,
14
15    #[display("block comment")]
16    BlockComment,
17
18    // Literals
19    #[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    // Keywords
38    #[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    // Grouping
108    #[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    // Arithmetic operators
127    #[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    // Comparison operators
143    #[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    // Logical operators
162    #[display("`!`")]
163    Not,
164
165    #[display("`&&`")]
166    And,
167
168    #[display("`||`")]
169    Or,
170
171    // Bitwise operators
172    #[display("`~`")]
173    BitwiseNot,
174
175    #[display("`&`")]
176    BitwiseAnd,
177
178    #[display("`|`")]
179    BitwiseOr,
180
181    #[display("`^`")]
182    BitwiseXor,
183
184    #[display("`<<`")]
185    LeftArithmeticShift,
186
187    #[display("`>>`")]
188    RightArithmeticShift,
189
190    #[display("`>>>`")]
191    RightLogicalShift,
192
193    // Punctuation
194    #[display("`=`")]
195    Assign,
196
197    #[display("`.`")]
198    Dot,
199
200    #[display("`,`")]
201    Comma,
202
203    #[display("`:`")]
204    Colon,
205
206    #[display("`;`")]
207    Semicolon,
208
209    #[display("`->`")]
210    Arrow,
211
212    #[display("`=>`")]
213    FatArrow,
214
215    #[display("`::`")]
216    PathSeparator,
217
218    #[display("`::<`")]
219    TurboFish,
220
221    #[display("`...`")]
222    Spread,
223
224    // AST
225    #[display("document")]
226    Document,
227
228    #[display("module item")]
229    ModuleItem,
230
231    #[display("function item")]
232    FunctionItem,
233
234    #[display("function parameter")]
235    FunctionParameter,
236
237    #[display("constant item")]
238    ConstantItem,
239
240    #[display("type alias item")]
241    TypeAliasItem,
242
243    #[display("struct item")]
244    StructItem,
245
246    #[display("struct field")]
247    StructField,
248
249    #[display("import item")]
250    ImportItem,
251
252    #[display("import path")]
253    ImportPath,
254
255    #[display("import path segment")]
256    ImportPathSegment,
257
258    #[display("generic parameters")]
259    GenericParameters,
260
261    #[display("generic arguments")]
262    GenericArguments,
263
264    #[display("literal type")]
265    LiteralType,
266
267    #[display("path type")]
268    PathType,
269
270    #[display("union type")]
271    UnionType,
272
273    #[display("group type")]
274    GroupType,
275
276    #[display("pair type")]
277    PairType,
278
279    #[display("list type")]
280    ListType,
281
282    #[display("list type item")]
283    ListTypeItem,
284
285    #[display("lambda type")]
286    LambdaType,
287
288    #[display("lambda parameter")]
289    LambdaParameter,
290
291    #[display("block")]
292    Block,
293
294    #[display("let statement")]
295    LetStmt,
296
297    #[display("expression statement")]
298    ExprStmt,
299
300    #[display("if statement")]
301    IfStmt,
302
303    #[display("return statement")]
304    ReturnStmt,
305
306    #[display("assert statement")]
307    AssertStmt,
308
309    #[display("raise statement")]
310    RaiseStmt,
311
312    #[display("debug statement")]
313    DebugStmt,
314
315    #[display("path expression")]
316    PathExpr,
317
318    #[display("path segment")]
319    PathSegment,
320
321    #[display("struct initializer expression")]
322    StructInitializerExpr,
323
324    #[display("struct initializer field")]
325    StructInitializerField,
326
327    #[display("literal expression")]
328    LiteralExpr,
329
330    #[display("group expression")]
331    GroupExpr,
332
333    #[display("pair expression")]
334    PairExpr,
335
336    #[display("list expression")]
337    ListExpr,
338
339    #[display("list item")]
340    ListItem,
341
342    #[display("prefix expression")]
343    PrefixExpr,
344
345    #[display("binary expression")]
346    BinaryExpr,
347
348    #[display("function call expression")]
349    FunctionCallExpr,
350
351    #[display("if expression")]
352    IfExpr,
353
354    #[display("guard expression")]
355    GuardExpr,
356
357    #[display("cast expression")]
358    CastExpr,
359
360    #[display("field access expression")]
361    FieldAccessExpr,
362
363    #[display("lambda expression")]
364    LambdaExpr,
365
366    #[display("named binding")]
367    NamedBinding,
368
369    #[display("pair binding")]
370    PairBinding,
371
372    #[display("list binding")]
373    ListBinding,
374
375    #[display("list binding item")]
376    ListBindingItem,
377
378    #[display("struct binding")]
379    StructBinding,
380
381    #[display("struct field binding")]
382    StructFieldBinding,
383
384    // Unexpected cases
385    #[display("error")]
386    Error,
387
388    #[display("eof")]
389    Eof,
390}
391
392#[macro_export]
393macro_rules! T {
394    [nil] => { $crate::SyntaxKind::Nil };
395    [true] => { $crate::SyntaxKind::True };
396    [false] => { $crate::SyntaxKind::False };
397    [import] => { $crate::SyntaxKind::Import };
398    [export] => { $crate::SyntaxKind::Export };
399    [extern] => { $crate::SyntaxKind::Extern };
400    [inline] => { $crate::SyntaxKind::Inline };
401    [test] => { $crate::SyntaxKind::Test };
402    [mod] => { $crate::SyntaxKind::Mod };
403    [fn] => { $crate::SyntaxKind::Fn };
404    [const] => { $crate::SyntaxKind::Const };
405    [type] => { $crate::SyntaxKind::Type };
406    [struct] => { $crate::SyntaxKind::Struct };
407    [let] => { $crate::SyntaxKind::Let };
408    [if] => { $crate::SyntaxKind::If };
409    [else] => { $crate::SyntaxKind::Else };
410    [return] => { $crate::SyntaxKind::Return };
411    [assert] => { $crate::SyntaxKind::Assert };
412    [raise] => { $crate::SyntaxKind::Raise };
413    [debug] => { $crate::SyntaxKind::Debug };
414    [is] => { $crate::SyntaxKind::Is };
415    [as] => { $crate::SyntaxKind::As };
416    [super] => { $crate::SyntaxKind::Super };
417    ['('] => { $crate::SyntaxKind::OpenParen };
418    [')'] => { $crate::SyntaxKind::CloseParen };
419    ['{'] => { $crate::SyntaxKind::OpenBrace };
420    ['}'] => { $crate::SyntaxKind::CloseBrace };
421    ['['] => { $crate::SyntaxKind::OpenBracket };
422    [']'] => { $crate::SyntaxKind::CloseBracket };
423    [+] => { $crate::SyntaxKind::Plus };
424    [-] => { $crate::SyntaxKind::Minus };
425    [*] => { $crate::SyntaxKind::Star };
426    [/] => { $crate::SyntaxKind::Slash };
427    [%] => { $crate::SyntaxKind::Percent };
428    [==] => { $crate::SyntaxKind::Equals };
429    [!=] => { $crate::SyntaxKind::NotEquals };
430    [<] => { $crate::SyntaxKind::LessThan };
431    [>] => { $crate::SyntaxKind::GreaterThan };
432    [<=] => { $crate::SyntaxKind::LessThanEquals };
433    [>=] => { $crate::SyntaxKind::GreaterThanEquals };
434    [!] => { $crate::SyntaxKind::Not };
435    [&&] => { $crate::SyntaxKind::And };
436    [||] => { $crate::SyntaxKind::Or };
437    [&] => { $crate::SyntaxKind::BitwiseAnd };
438    [|] => { $crate::SyntaxKind::BitwiseOr };
439    [~] => { $crate::SyntaxKind::BitwiseNot };
440    [^] => { $crate::SyntaxKind::BitwiseXor };
441    [<<] => { $crate::SyntaxKind::LeftArithmeticShift };
442    [>>] => { $crate::SyntaxKind::RightArithmeticShift };
443    [>>>] => { $crate::SyntaxKind::RightLogicalShift };
444    [=] => { $crate::SyntaxKind::Assign };
445    [.] => { $crate::SyntaxKind::Dot };
446    [,] => { $crate::SyntaxKind::Comma };
447    [:] => { $crate::SyntaxKind::Colon };
448    [;] => { $crate::SyntaxKind::Semicolon };
449    [->] => { $crate::SyntaxKind::Arrow };
450    [=>] => { $crate::SyntaxKind::FatArrow };
451    [::] => { $crate::SyntaxKind::PathSeparator };
452    [...] => { $crate::SyntaxKind::Spread };
453}
454
455impl SyntaxKind {
456    pub const LITERAL: &[Self] = &[
457        SyntaxKind::String,
458        SyntaxKind::Hex,
459        SyntaxKind::Binary,
460        SyntaxKind::Octal,
461        SyntaxKind::Integer,
462        T![nil],
463        T![true],
464        T![false],
465        T![super],
466    ];
467    pub const PREFIX_OPS: &[Self] = &[T![!], T![-], T![+], T![~]];
468    pub const BINARY_OPS: &[Self] = &[
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        T![|],
484        T![^],
485        T![>>>],
486        T![<<],
487        T![>>],
488    ];
489
490    pub fn is_trivia(&self) -> bool {
491        matches!(
492            self,
493            Self::Whitespace | Self::LineComment | Self::BlockComment | Self::Error
494        )
495    }
496
497    pub fn split(&self) -> &'static [Self] {
498        match self {
499            SyntaxKind::Whitespace => &[Self::Whitespace],
500            SyntaxKind::LineComment => &[Self::LineComment],
501            SyntaxKind::BlockComment => &[Self::BlockComment],
502            SyntaxKind::String => &[Self::String],
503            SyntaxKind::Hex => &[Self::Hex],
504            SyntaxKind::Binary => &[Self::Binary],
505            SyntaxKind::Octal => &[Self::Octal],
506            SyntaxKind::Integer => &[Self::Integer],
507            SyntaxKind::Ident => &[Self::Ident],
508            T![nil] => &[T![nil]],
509            T![true] => &[T![true]],
510            T![false] => &[T![false]],
511            T![import] => &[T![import]],
512            T![export] => &[T![export]],
513            T![extern] => &[T![extern]],
514            T![inline] => &[T![inline]],
515            T![test] => &[T![test]],
516            T![mod] => &[T![mod]],
517            T![fn] => &[T![fn]],
518            T![const] => &[T![const]],
519            T![type] => &[T![type]],
520            T![struct] => &[T![struct]],
521            T![let] => &[T![let]],
522            T![if] => &[T![if]],
523            T![else] => &[T![else]],
524            T![return] => &[T![return]],
525            T![assert] => &[T![assert]],
526            T![raise] => &[T![raise]],
527            T![debug] => &[T![debug]],
528            T![is] => &[T![is]],
529            T![as] => &[T![as]],
530            T![super] => &[T![super]],
531            T!['('] => &[T!['(']],
532            T![')'] => &[T![')']],
533            T!['{'] => &[T!['{']],
534            T!['}'] => &[T!['}']],
535            T!['['] => &[T!['[']],
536            T![']'] => &[T![']']],
537            T![+] => &[T![+]],
538            T![-] => &[T![-]],
539            T![*] => &[T![*]],
540            T![/] => &[T![/]],
541            T![%] => &[T![%]],
542            T![==] => &[T![=], T![=]],
543            T![!=] => &[T![!], T![=]],
544            T![<] => &[T![<]],
545            T![>] => &[T![>]],
546            T![<=] => &[T![<], T![=]],
547            T![>=] => &[T![>], T![=]],
548            T![!] => &[T![!]],
549            T![&&] => &[T![&], T![&]],
550            T![||] => &[T![|], T![|]],
551            T![~] => &[T![~]],
552            T![&] => &[T![&]],
553            T![|] => &[T![|]],
554            T![^] => &[T![^]],
555            T![<<] => &[T![<], T![<]],
556            T![>>] => &[T![>], T![>]],
557            T![>>>] => &[T![>], T![>], T![>]],
558            T![=] => &[T![=]],
559            T![.] => &[T![.]],
560            T![,] => &[T![,]],
561            T![:] => &[T![:]],
562            T![;] => &[T![;]],
563            T![->] => &[T![-], T![>]],
564            T![=>] => &[T![=], T![>]],
565            T![::] => &[T![:], T![:]],
566            T![...] => &[T![.], T![.], T![.]],
567            SyntaxKind::TurboFish => &[T![:], T![:], T![<]],
568            SyntaxKind::Document => &[SyntaxKind::Document],
569            SyntaxKind::ModuleItem => &[SyntaxKind::ModuleItem],
570            SyntaxKind::FunctionItem => &[SyntaxKind::FunctionItem],
571            SyntaxKind::FunctionParameter => &[SyntaxKind::FunctionParameter],
572            SyntaxKind::ConstantItem => &[SyntaxKind::ConstantItem],
573            SyntaxKind::TypeAliasItem => &[SyntaxKind::TypeAliasItem],
574            SyntaxKind::StructItem => &[SyntaxKind::StructItem],
575            SyntaxKind::StructField => &[SyntaxKind::StructField],
576            SyntaxKind::ImportItem => &[SyntaxKind::ImportItem],
577            SyntaxKind::ImportPath => &[SyntaxKind::ImportPath],
578            SyntaxKind::ImportPathSegment => &[SyntaxKind::ImportPathSegment],
579            SyntaxKind::GenericParameters => &[SyntaxKind::GenericParameters],
580            SyntaxKind::GenericArguments => &[SyntaxKind::GenericArguments],
581            SyntaxKind::LiteralType => &[SyntaxKind::LiteralType],
582            SyntaxKind::PathType => &[SyntaxKind::PathType],
583            SyntaxKind::UnionType => &[SyntaxKind::UnionType],
584            SyntaxKind::GroupType => &[SyntaxKind::GroupType],
585            SyntaxKind::PairType => &[SyntaxKind::PairType],
586            SyntaxKind::ListType => &[SyntaxKind::ListType],
587            SyntaxKind::ListTypeItem => &[SyntaxKind::ListTypeItem],
588            SyntaxKind::LambdaType => &[SyntaxKind::LambdaType],
589            SyntaxKind::LambdaParameter => &[SyntaxKind::LambdaParameter],
590            SyntaxKind::Block => &[SyntaxKind::Block],
591            SyntaxKind::LetStmt => &[SyntaxKind::LetStmt],
592            SyntaxKind::ExprStmt => &[SyntaxKind::ExprStmt],
593            SyntaxKind::IfStmt => &[SyntaxKind::IfStmt],
594            SyntaxKind::ReturnStmt => &[SyntaxKind::ReturnStmt],
595            SyntaxKind::AssertStmt => &[SyntaxKind::AssertStmt],
596            SyntaxKind::RaiseStmt => &[SyntaxKind::RaiseStmt],
597            SyntaxKind::DebugStmt => &[SyntaxKind::DebugStmt],
598            SyntaxKind::PathExpr => &[SyntaxKind::PathExpr],
599            SyntaxKind::PathSegment => &[SyntaxKind::PathSegment],
600            SyntaxKind::StructInitializerExpr => &[SyntaxKind::StructInitializerExpr],
601            SyntaxKind::StructInitializerField => &[SyntaxKind::StructInitializerField],
602            SyntaxKind::LiteralExpr => &[SyntaxKind::LiteralExpr],
603            SyntaxKind::GroupExpr => &[SyntaxKind::GroupExpr],
604            SyntaxKind::PairExpr => &[SyntaxKind::PairExpr],
605            SyntaxKind::ListExpr => &[SyntaxKind::ListExpr],
606            SyntaxKind::ListItem => &[SyntaxKind::ListItem],
607            SyntaxKind::PrefixExpr => &[SyntaxKind::PrefixExpr],
608            SyntaxKind::BinaryExpr => &[SyntaxKind::BinaryExpr],
609            SyntaxKind::FunctionCallExpr => &[SyntaxKind::FunctionCallExpr],
610            SyntaxKind::IfExpr => &[SyntaxKind::IfExpr],
611            SyntaxKind::GuardExpr => &[SyntaxKind::GuardExpr],
612            SyntaxKind::CastExpr => &[SyntaxKind::CastExpr],
613            SyntaxKind::FieldAccessExpr => &[SyntaxKind::FieldAccessExpr],
614            SyntaxKind::LambdaExpr => &[SyntaxKind::LambdaExpr],
615            SyntaxKind::NamedBinding => &[SyntaxKind::NamedBinding],
616            SyntaxKind::PairBinding => &[SyntaxKind::PairBinding],
617            SyntaxKind::ListBinding => &[SyntaxKind::ListBinding],
618            SyntaxKind::ListBindingItem => &[SyntaxKind::ListBindingItem],
619            SyntaxKind::StructBinding => &[SyntaxKind::StructBinding],
620            SyntaxKind::StructFieldBinding => &[SyntaxKind::StructFieldBinding],
621            SyntaxKind::Error => &[SyntaxKind::Error],
622            SyntaxKind::Eof => &[SyntaxKind::Eof],
623        }
624    }
625}
rue_parser/syntax_kind.rs

rue_parser/
syntax_kind.rs
