1#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
2pub enum SyntaxKind {
3 Amp,
4 AmpAmp,
5 AmpersandEq,
6 Apostrophe,
7 Args,
8 Arrow,
9 As,
10 Assignment,
11 At,
12 Backtick,
13 Bang,
14 BangEq,
15 Binary,
16 Bool,
17 Break,
18 Capture,
19 CaptureList,
20 CodeBlock,
21 Colon,
22 ColonColon,
23 Comma,
24 Comment,
25 Condition,
26 Conditional,
27 ConditionalAlternate,
28 ConditionalElse,
29 Continue,
30 DestructureAssignment,
31 Destructuring,
32 DocComment,
33 Dollar,
34 Dot,
35 Dots,
36 DotsEq,
37 DoubleQuote,
38 Ellipsis,
39 Else,
40 End,
41 Enum,
42 Eq,
43 EqEq,
44 Error,
45 FieldAccess,
46 Float,
47 For,
48 ForLoop,
49 FuncCall,
50 Gt,
51 GtEq,
52 GtGt,
53 Hash,
54 Hat,
55 HatEq,
56 Ident,
57 If,
58 Import,
59 In,
60 IndexAccess,
61 Int,
62 LeftBrace,
63 LeftBracket,
64 LeftParen,
65 Let,
66 LetBinding,
67 Loop,
68 Lt,
69 LtEq,
70 LtLt,
71 Minus,
72 MinusEq,
73 Mut,
74 Named,
75 NewLine,
76 Param,
77 Params,
78 Parenthesized,
79 PathAccess,
80 Percent,
81 Pipe,
82 PipeEq,
83 PipePipe,
84 Plus,
85 PlusEq,
86 Pub,
87 Ref,
88 Return,
89 RightBrace,
90 RightBracket,
91 RightParen,
92 Semicolon,
93 Slash,
94 SlashEq,
95 Star,
96 StarEq,
97 Str,
98 Tilde,
99 TildeEq,
100 Unary,
101 Underscore,
102 Unit,
103 While,
104 WhileLoop,
105 Array,
106 Range,
107 MapLiteral,
108 MapEntry,
109 BreakStatement,
110 ReturnStatement,
111 Lambda,
112 ImportItem,
113 ModuleImport,
114}
115
116impl SyntaxKind {
117 pub(crate) fn is_terminator(&self) -> bool {
118 matches!(
119 self,
120 Self::End | Self::Semicolon | Self::RightBrace | Self::RightParen | Self::RightBracket
121 )
122 }
123
124 pub(crate) fn descriptive_name(&self) -> &'static str {
125 match self {
126 SyntaxKind::Amp => "&",
127 SyntaxKind::AmpAmp => "&&",
128 SyntaxKind::AmpersandEq => "&=",
129 SyntaxKind::Apostrophe => "'",
130 SyntaxKind::Args => "argument list",
131 SyntaxKind::Array => "array",
132 SyntaxKind::Arrow => "=>",
133 SyntaxKind::As => "as",
134 SyntaxKind::Assignment => "assignment",
135 SyntaxKind::At => "@",
136 SyntaxKind::Backtick => "`",
137 SyntaxKind::Bang => "!",
138 SyntaxKind::BangEq => "!=",
139 SyntaxKind::Binary => "binary expression",
140 SyntaxKind::Bool => "boolean literal",
141 SyntaxKind::Break => "break",
142 SyntaxKind::BreakStatement => "break statement",
143 SyntaxKind::CaptureList => "capture group",
144 SyntaxKind::Capture => "captured variable",
145 SyntaxKind::CodeBlock => "code block",
146 SyntaxKind::Colon => ":",
147 SyntaxKind::ColonColon => "::",
148 SyntaxKind::Comma => ",",
149 SyntaxKind::Comment => "comment",
150 SyntaxKind::Condition => "condition",
151 SyntaxKind::Conditional => "if expression",
152 SyntaxKind::ConditionalAlternate => "else if expression",
153 SyntaxKind::ConditionalElse => "else expression",
154 SyntaxKind::Continue => "continue",
155 SyntaxKind::DestructureAssignment => "destructuring assignment",
156 SyntaxKind::Destructuring => "destructuring",
157 SyntaxKind::DocComment => "doc comment",
158 SyntaxKind::Dollar => "$",
159 SyntaxKind::Dot => ".",
160 SyntaxKind::Dots => "..",
161 SyntaxKind::DotsEq => "..=",
162 SyntaxKind::DoubleQuote => "\"",
163 SyntaxKind::Ellipsis => "...",
164 SyntaxKind::Else => "else",
165 SyntaxKind::End => "end of file",
166 SyntaxKind::Enum => "enum",
167 SyntaxKind::Eq => "=",
168 SyntaxKind::EqEq => "==",
169 SyntaxKind::Error => "error",
170 SyntaxKind::FieldAccess => "field access",
171 SyntaxKind::Float => "float literal",
172 SyntaxKind::For => "for",
173 SyntaxKind::ForLoop => "for loop",
174 SyntaxKind::FuncCall => "function call",
175 SyntaxKind::Gt => ">",
176 SyntaxKind::GtEq => ">=",
177 SyntaxKind::GtGt => ">>",
178 SyntaxKind::Hash => "#",
179 SyntaxKind::Hat => "^",
180 SyntaxKind::HatEq => "^=",
181 SyntaxKind::Ident => "identifier",
182 SyntaxKind::If => "if",
183 SyntaxKind::Import => "import",
184 SyntaxKind::In => "in",
185 SyntaxKind::IndexAccess => "index access",
186 SyntaxKind::Int => "integer literal",
187 SyntaxKind::LeftBrace => "{",
188 SyntaxKind::LeftBracket => "[",
189 SyntaxKind::LeftParen => "(",
190 SyntaxKind::Let => "let",
191 SyntaxKind::LetBinding => "let binding",
192 SyntaxKind::Loop => "loop",
193 SyntaxKind::Lt => "<",
194 SyntaxKind::LtEq => "<=",
195 SyntaxKind::LtLt => "<<",
196 SyntaxKind::MapEntry => "map entry",
197 SyntaxKind::MapLiteral => "map literal",
198 SyntaxKind::Minus => "-",
199 SyntaxKind::MinusEq => "-=",
200 SyntaxKind::ModuleImport => "module import",
201 SyntaxKind::ImportItem => "import item",
202 SyntaxKind::Mut => "mut",
203 SyntaxKind::Named => "named binding",
204 SyntaxKind::NewLine => "newline",
205 SyntaxKind::Param => "parameter",
206 SyntaxKind::Params => "parameter list",
207 SyntaxKind::Parenthesized => "parenthesized expression",
208 SyntaxKind::PathAccess => "path",
209 SyntaxKind::Percent => "%",
210 SyntaxKind::Pipe => "|",
211 SyntaxKind::PipeEq => "|=",
212 SyntaxKind::PipePipe => "||",
213 SyntaxKind::Plus => "+",
214 SyntaxKind::PlusEq => "+=",
215 SyntaxKind::Pub => "pub",
216 SyntaxKind::Range => "range",
217 SyntaxKind::Ref => "ref",
218 SyntaxKind::Return => "return",
219 SyntaxKind::ReturnStatement => "return statement",
220 SyntaxKind::RightBrace => "}",
221 SyntaxKind::RightBracket => "]",
222 SyntaxKind::RightParen => ")",
223 SyntaxKind::Semicolon => ";",
224 SyntaxKind::Slash => "/",
225 SyntaxKind::SlashEq => "/=",
226 SyntaxKind::Star => "*",
227 SyntaxKind::StarEq => "*=",
228 SyntaxKind::Str => "string literal",
229 SyntaxKind::Tilde => "~",
230 SyntaxKind::TildeEq => "~=",
231 SyntaxKind::Lambda => "trailing lambda",
232 SyntaxKind::Unary => "unary expression",
233 SyntaxKind::Underscore => "_",
234 SyntaxKind::Unit => "()",
235 SyntaxKind::While => "while",
236 SyntaxKind::WhileLoop => "while loop",
237 }
238 }
239
240 pub(crate) fn matching_delimiter(&self) -> Option<SyntaxKind> {
241 match self {
242 Self::LeftBrace => Some(Self::RightBrace),
243 Self::LeftParen => Some(Self::RightParen),
244 Self::LeftBracket => Some(Self::RightBracket),
245 Self::RightBrace => Some(Self::LeftBrace),
246 Self::RightParen => Some(Self::LeftParen),
247 Self::RightBracket => Some(Self::LeftBracket),
248 Self::Pipe => Some(Self::Pipe),
249 _ => None,
250 }
251 }
252
253 pub(crate) fn is_closing_delimiter(&self) -> bool {
254 matches!(
255 self,
256 Self::RightBrace | Self::RightParen | Self::RightBracket
257 )
258 }
259
260 pub(crate) fn is_grouping(&self) -> bool {
261 matches!(
262 self,
263 Self::LeftParen
264 | Self::LeftBrace
265 | Self::LeftBracket
266 | Self::RightBrace
267 | Self::RightParen
268 | Self::RightBracket
269 | Self::Pipe
270 )
271 }
272 pub(crate) fn is_keyword(&self) -> bool {
273 matches!(
274 self,
275 Self::As
276 | Self::Break
277 | Self::Continue
278 | Self::Else
279 | Self::Enum
280 | Self::For
281 | Self::If
282 | Self::Import
283 | Self::In
284 | Self::Let
285 | Self::LetBinding
286 | Self::Loop
287 | Self::Mut
288 | Self::Ref
289 | Self::Return
290 | Self::Unit
291 | Self::While
292 | Self::Pub
293 )
294 }
295}