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 Spread,
115}
116
117impl SyntaxKind {
118 pub(crate) fn is_terminator(&self) -> bool {
119 matches!(
120 self,
121 Self::End | Self::Semicolon | Self::RightBrace | Self::RightParen | Self::RightBracket
122 )
123 }
124
125 pub(crate) fn descriptive_name(&self) -> &'static str {
126 match self {
127 SyntaxKind::Amp => "&",
128 SyntaxKind::AmpAmp => "&&",
129 SyntaxKind::AmpersandEq => "&=",
130 SyntaxKind::Apostrophe => "'",
131 SyntaxKind::Args => "argument list",
132 SyntaxKind::Array => "array",
133 SyntaxKind::Arrow => "=>",
134 SyntaxKind::As => "as",
135 SyntaxKind::Assignment => "assignment",
136 SyntaxKind::At => "@",
137 SyntaxKind::Backtick => "`",
138 SyntaxKind::Bang => "!",
139 SyntaxKind::BangEq => "!=",
140 SyntaxKind::Binary => "binary expression",
141 SyntaxKind::Bool => "boolean literal",
142 SyntaxKind::Break => "break",
143 SyntaxKind::BreakStatement => "break statement",
144 SyntaxKind::CaptureList => "capture group",
145 SyntaxKind::Capture => "captured variable",
146 SyntaxKind::CodeBlock => "code block",
147 SyntaxKind::Colon => ":",
148 SyntaxKind::ColonColon => "::",
149 SyntaxKind::Comma => ",",
150 SyntaxKind::Comment => "comment",
151 SyntaxKind::Condition => "condition",
152 SyntaxKind::Conditional => "if expression",
153 SyntaxKind::ConditionalAlternate => "else if expression",
154 SyntaxKind::ConditionalElse => "else expression",
155 SyntaxKind::Continue => "continue",
156 SyntaxKind::DestructureAssignment => "destructuring assignment",
157 SyntaxKind::Destructuring => "destructuring",
158 SyntaxKind::DocComment => "doc comment",
159 SyntaxKind::Dollar => "$",
160 SyntaxKind::Dot => ".",
161 SyntaxKind::Dots => "..",
162 SyntaxKind::DotsEq => "..=",
163 SyntaxKind::DoubleQuote => "\"",
164 SyntaxKind::Ellipsis => "...",
165 SyntaxKind::Else => "else",
166 SyntaxKind::End => "end of file",
167 SyntaxKind::Enum => "enum",
168 SyntaxKind::Eq => "=",
169 SyntaxKind::EqEq => "==",
170 SyntaxKind::Error => "error",
171 SyntaxKind::FieldAccess => "field access",
172 SyntaxKind::Float => "float literal",
173 SyntaxKind::For => "for",
174 SyntaxKind::ForLoop => "for loop",
175 SyntaxKind::FuncCall => "function call",
176 SyntaxKind::Gt => ">",
177 SyntaxKind::GtEq => ">=",
178 SyntaxKind::GtGt => ">>",
179 SyntaxKind::Hash => "#",
180 SyntaxKind::Hat => "^",
181 SyntaxKind::HatEq => "^=",
182 SyntaxKind::Ident => "identifier",
183 SyntaxKind::If => "if",
184 SyntaxKind::Import => "import",
185 SyntaxKind::In => "in",
186 SyntaxKind::IndexAccess => "index access",
187 SyntaxKind::Int => "integer literal",
188 SyntaxKind::LeftBrace => "{",
189 SyntaxKind::LeftBracket => "[",
190 SyntaxKind::LeftParen => "(",
191 SyntaxKind::Let => "let",
192 SyntaxKind::LetBinding => "let binding",
193 SyntaxKind::Loop => "loop",
194 SyntaxKind::Lt => "<",
195 SyntaxKind::LtEq => "<=",
196 SyntaxKind::LtLt => "<<",
197 SyntaxKind::MapEntry => "map entry",
198 SyntaxKind::MapLiteral => "map literal",
199 SyntaxKind::Minus => "-",
200 SyntaxKind::MinusEq => "-=",
201 SyntaxKind::ModuleImport => "module import",
202 SyntaxKind::ImportItem => "import item",
203 SyntaxKind::Mut => "mut",
204 SyntaxKind::Named => "named binding",
205 SyntaxKind::NewLine => "newline",
206 SyntaxKind::Param => "parameter",
207 SyntaxKind::Params => "parameter list",
208 SyntaxKind::Parenthesized => "parenthesized expression",
209 SyntaxKind::PathAccess => "path",
210 SyntaxKind::Percent => "%",
211 SyntaxKind::Pipe => "|",
212 SyntaxKind::PipeEq => "|=",
213 SyntaxKind::PipePipe => "||",
214 SyntaxKind::Plus => "+",
215 SyntaxKind::PlusEq => "+=",
216 SyntaxKind::Pub => "pub",
217 SyntaxKind::Range => "range",
218 SyntaxKind::Ref => "ref",
219 SyntaxKind::Return => "return",
220 SyntaxKind::ReturnStatement => "return statement",
221 SyntaxKind::RightBrace => "}",
222 SyntaxKind::RightBracket => "]",
223 SyntaxKind::RightParen => ")",
224 SyntaxKind::Semicolon => ";",
225 SyntaxKind::Slash => "/",
226 SyntaxKind::SlashEq => "/=",
227 SyntaxKind::Spread => "..",
228 SyntaxKind::Star => "*",
229 SyntaxKind::StarEq => "*=",
230 SyntaxKind::Str => "string literal",
231 SyntaxKind::Tilde => "~",
232 SyntaxKind::TildeEq => "~=",
233 SyntaxKind::Lambda => "trailing lambda",
234 SyntaxKind::Unary => "unary expression",
235 SyntaxKind::Underscore => "_",
236 SyntaxKind::Unit => "()",
237 SyntaxKind::While => "while",
238 SyntaxKind::WhileLoop => "while loop",
239 }
240 }
241
242 pub(crate) fn matching_delimiter(&self) -> Option<SyntaxKind> {
243 match self {
244 Self::LeftBrace => Some(Self::RightBrace),
245 Self::LeftParen => Some(Self::RightParen),
246 Self::LeftBracket => Some(Self::RightBracket),
247 Self::RightBrace => Some(Self::LeftBrace),
248 Self::RightParen => Some(Self::LeftParen),
249 Self::RightBracket => Some(Self::LeftBracket),
250 Self::Pipe => Some(Self::Pipe),
251 _ => None,
252 }
253 }
254
255 pub(crate) fn is_closing_delimiter(&self) -> bool {
256 matches!(
257 self,
258 Self::RightBrace | Self::RightParen | Self::RightBracket
259 )
260 }
261
262 pub(crate) fn is_grouping(&self) -> bool {
263 matches!(
264 self,
265 Self::LeftParen
266 | Self::LeftBrace
267 | Self::LeftBracket
268 | Self::RightBrace
269 | Self::RightParen
270 | Self::RightBracket
271 | Self::Pipe
272 )
273 }
274 pub(crate) fn is_keyword(&self) -> bool {
275 matches!(
276 self,
277 Self::As
278 | Self::Break
279 | Self::Continue
280 | Self::Else
281 | Self::Enum
282 | Self::For
283 | Self::If
284 | Self::Import
285 | Self::In
286 | Self::Let
287 | Self::LetBinding
288 | Self::Loop
289 | Self::Mut
290 | Self::Ref
291 | Self::Return
292 | Self::Unit
293 | Self::While
294 | Self::Pub
295 )
296 }
297}