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

rue_parser/
syntax_kind.rs
