1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Declaration<'tree> {
3 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
4 FunctionDeclaration(::std::boxed::Box<FunctionDeclaration<'tree>>),
5 GeneratorFunctionDeclaration(::std::boxed::Box<GeneratorFunctionDeclaration<'tree>>),
6 LexicalDeclaration(::std::boxed::Box<LexicalDeclaration<'tree>>),
7 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
8 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
9}
10impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
11 #[allow(clippy::collapsible_else_if)]
12 fn from_node(
13 node: ::treesitter_types::tree_sitter::Node<'tree>,
14 src: &'tree [u8],
15 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16 match node.kind() {
17 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
18 ::treesitter_types::runtime::maybe_grow_stack(|| {
19 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20 })?,
21 ))),
22 "function_declaration" => Ok(Self::FunctionDeclaration(::std::boxed::Box::new(
23 ::treesitter_types::runtime::maybe_grow_stack(|| {
24 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
25 })?,
26 ))),
27 "generator_function_declaration" => Ok(Self::GeneratorFunctionDeclaration(
28 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
29 <GeneratorFunctionDeclaration as ::treesitter_types::FromNode>::from_node(
30 node, src,
31 )
32 })?),
33 )),
34 "lexical_declaration" => Ok(Self::LexicalDeclaration(::std::boxed::Box::new(
35 ::treesitter_types::runtime::maybe_grow_stack(|| {
36 <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
37 })?,
38 ))),
39 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
40 ::treesitter_types::runtime::maybe_grow_stack(|| {
41 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
42 })?,
43 ))),
44 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
45 ::treesitter_types::runtime::maybe_grow_stack(|| {
46 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
47 })?,
48 ))),
49 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
50 }
51 }
52}
53impl ::treesitter_types::Spanned for Declaration<'_> {
54 fn span(&self) -> ::treesitter_types::Span {
55 match self {
56 Self::ClassDeclaration(inner) => inner.span(),
57 Self::FunctionDeclaration(inner) => inner.span(),
58 Self::GeneratorFunctionDeclaration(inner) => inner.span(),
59 Self::LexicalDeclaration(inner) => inner.span(),
60 Self::UsingDeclaration(inner) => inner.span(),
61 Self::VariableDeclaration(inner) => inner.span(),
62 }
63 }
64}
65#[derive(Debug, Clone, PartialEq, Eq)]
66pub enum Expression<'tree> {
67 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
68 AugmentedAssignmentExpression(::std::boxed::Box<AugmentedAssignmentExpression<'tree>>),
69 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
70 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
71 JsxElement(::std::boxed::Box<JsxElement<'tree>>),
72 JsxSelfClosingElement(::std::boxed::Box<JsxSelfClosingElement<'tree>>),
73 NewExpression(::std::boxed::Box<NewExpression<'tree>>),
74 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
75 TernaryExpression(::std::boxed::Box<TernaryExpression<'tree>>),
76 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
77 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
78 YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
79}
80impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
81 #[allow(clippy::collapsible_else_if)]
82 fn from_node(
83 node: ::treesitter_types::tree_sitter::Node<'tree>,
84 src: &'tree [u8],
85 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
86 match node.kind() {
87 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
88 ::treesitter_types::runtime::maybe_grow_stack(|| {
89 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
90 })?,
91 ))),
92 "augmented_assignment_expression" => Ok(Self::AugmentedAssignmentExpression(
93 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
94 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
95 node, src,
96 )
97 })?),
98 )),
99 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
100 ::treesitter_types::runtime::maybe_grow_stack(|| {
101 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
102 })?,
103 ))),
104 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
105 ::treesitter_types::runtime::maybe_grow_stack(|| {
106 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
107 })?,
108 ))),
109 "jsx_element" => Ok(Self::JsxElement(::std::boxed::Box::new(
110 ::treesitter_types::runtime::maybe_grow_stack(|| {
111 <JsxElement as ::treesitter_types::FromNode>::from_node(node, src)
112 })?,
113 ))),
114 "jsx_self_closing_element" => Ok(Self::JsxSelfClosingElement(::std::boxed::Box::new(
115 ::treesitter_types::runtime::maybe_grow_stack(|| {
116 <JsxSelfClosingElement as ::treesitter_types::FromNode>::from_node(node, src)
117 })?,
118 ))),
119 "new_expression" => Ok(Self::NewExpression(::std::boxed::Box::new(
120 ::treesitter_types::runtime::maybe_grow_stack(|| {
121 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)
122 })?,
123 ))),
124 "ternary_expression" => Ok(Self::TernaryExpression(::std::boxed::Box::new(
125 ::treesitter_types::runtime::maybe_grow_stack(|| {
126 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
127 })?,
128 ))),
129 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
130 ::treesitter_types::runtime::maybe_grow_stack(|| {
131 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
132 })?,
133 ))),
134 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
135 ::treesitter_types::runtime::maybe_grow_stack(|| {
136 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
137 })?,
138 ))),
139 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
140 ::treesitter_types::runtime::maybe_grow_stack(|| {
141 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
142 })?,
143 ))),
144 _other => {
145 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
146 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
147 }) {
148 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
149 } else {
150 Err(::treesitter_types::ParseError::unexpected_kind(
151 _other, node,
152 ))
153 }
154 }
155 }
156 }
157}
158impl ::treesitter_types::Spanned for Expression<'_> {
159 fn span(&self) -> ::treesitter_types::Span {
160 match self {
161 Self::AssignmentExpression(inner) => inner.span(),
162 Self::AugmentedAssignmentExpression(inner) => inner.span(),
163 Self::AwaitExpression(inner) => inner.span(),
164 Self::BinaryExpression(inner) => inner.span(),
165 Self::JsxElement(inner) => inner.span(),
166 Self::JsxSelfClosingElement(inner) => inner.span(),
167 Self::NewExpression(inner) => inner.span(),
168 Self::PrimaryExpression(inner) => inner.span(),
169 Self::TernaryExpression(inner) => inner.span(),
170 Self::UnaryExpression(inner) => inner.span(),
171 Self::UpdateExpression(inner) => inner.span(),
172 Self::YieldExpression(inner) => inner.span(),
173 }
174 }
175}
176#[derive(Debug, Clone, PartialEq, Eq)]
177pub enum Pattern<'tree> {
178 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
179 Identifier(::std::boxed::Box<Identifier<'tree>>),
180 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
181 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
182 RestPattern(::std::boxed::Box<RestPattern<'tree>>),
183 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
184 Undefined(::std::boxed::Box<Undefined<'tree>>),
185}
186impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
187 #[allow(clippy::collapsible_else_if)]
188 fn from_node(
189 node: ::treesitter_types::tree_sitter::Node<'tree>,
190 src: &'tree [u8],
191 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
192 match node.kind() {
193 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
194 ::treesitter_types::runtime::maybe_grow_stack(|| {
195 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
196 })?,
197 ))),
198 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
199 ::treesitter_types::runtime::maybe_grow_stack(|| {
200 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
201 })?,
202 ))),
203 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
204 ::treesitter_types::runtime::maybe_grow_stack(|| {
205 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
206 })?,
207 ))),
208 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
209 ::treesitter_types::runtime::maybe_grow_stack(|| {
210 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
211 })?,
212 ))),
213 "rest_pattern" => Ok(Self::RestPattern(::std::boxed::Box::new(
214 ::treesitter_types::runtime::maybe_grow_stack(|| {
215 <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)
216 })?,
217 ))),
218 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
219 ::treesitter_types::runtime::maybe_grow_stack(|| {
220 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
221 })?,
222 ))),
223 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
224 ::treesitter_types::runtime::maybe_grow_stack(|| {
225 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)
226 })?,
227 ))),
228 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
229 }
230 }
231}
232impl ::treesitter_types::Spanned for Pattern<'_> {
233 fn span(&self) -> ::treesitter_types::Span {
234 match self {
235 Self::ArrayPattern(inner) => inner.span(),
236 Self::Identifier(inner) => inner.span(),
237 Self::MemberExpression(inner) => inner.span(),
238 Self::ObjectPattern(inner) => inner.span(),
239 Self::RestPattern(inner) => inner.span(),
240 Self::SubscriptExpression(inner) => inner.span(),
241 Self::Undefined(inner) => inner.span(),
242 }
243 }
244}
245#[derive(Debug, Clone, PartialEq, Eq)]
246pub enum PrimaryExpression<'tree> {
247 Array(::std::boxed::Box<Array<'tree>>),
248 ArrowFunction(::std::boxed::Box<ArrowFunction<'tree>>),
249 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
250 Class(::std::boxed::Box<Class<'tree>>),
251 False(::std::boxed::Box<False<'tree>>),
252 FunctionExpression(::std::boxed::Box<FunctionExpression<'tree>>),
253 GeneratorFunction(::std::boxed::Box<GeneratorFunction<'tree>>),
254 Identifier(::std::boxed::Box<Identifier<'tree>>),
255 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
256 MetaProperty(::std::boxed::Box<MetaProperty<'tree>>),
257 Null(::std::boxed::Box<Null<'tree>>),
258 Number(::std::boxed::Box<Number<'tree>>),
259 Object(::std::boxed::Box<Object<'tree>>),
260 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
261 Regex(::std::boxed::Box<Regex<'tree>>),
262 String(::std::boxed::Box<String<'tree>>),
263 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
264 Super(::std::boxed::Box<Super<'tree>>),
265 TemplateString(::std::boxed::Box<TemplateString<'tree>>),
266 This(::std::boxed::Box<This<'tree>>),
267 True(::std::boxed::Box<True<'tree>>),
268 Undefined(::std::boxed::Box<Undefined<'tree>>),
269}
270impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryExpression<'tree> {
271 #[allow(clippy::collapsible_else_if)]
272 fn from_node(
273 node: ::treesitter_types::tree_sitter::Node<'tree>,
274 src: &'tree [u8],
275 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
276 match node.kind() {
277 "array" => Ok(Self::Array(::std::boxed::Box::new(
278 ::treesitter_types::runtime::maybe_grow_stack(|| {
279 <Array as ::treesitter_types::FromNode>::from_node(node, src)
280 })?,
281 ))),
282 "arrow_function" => Ok(Self::ArrowFunction(::std::boxed::Box::new(
283 ::treesitter_types::runtime::maybe_grow_stack(|| {
284 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)
285 })?,
286 ))),
287 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
288 ::treesitter_types::runtime::maybe_grow_stack(|| {
289 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
290 })?,
291 ))),
292 "class" => Ok(Self::Class(::std::boxed::Box::new(
293 ::treesitter_types::runtime::maybe_grow_stack(|| {
294 <Class as ::treesitter_types::FromNode>::from_node(node, src)
295 })?,
296 ))),
297 "false" => Ok(Self::False(::std::boxed::Box::new(
298 ::treesitter_types::runtime::maybe_grow_stack(|| {
299 <False as ::treesitter_types::FromNode>::from_node(node, src)
300 })?,
301 ))),
302 "function_expression" => Ok(Self::FunctionExpression(::std::boxed::Box::new(
303 ::treesitter_types::runtime::maybe_grow_stack(|| {
304 <FunctionExpression as ::treesitter_types::FromNode>::from_node(node, src)
305 })?,
306 ))),
307 "generator_function" => Ok(Self::GeneratorFunction(::std::boxed::Box::new(
308 ::treesitter_types::runtime::maybe_grow_stack(|| {
309 <GeneratorFunction as ::treesitter_types::FromNode>::from_node(node, src)
310 })?,
311 ))),
312 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
313 ::treesitter_types::runtime::maybe_grow_stack(|| {
314 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
315 })?,
316 ))),
317 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
318 ::treesitter_types::runtime::maybe_grow_stack(|| {
319 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
320 })?,
321 ))),
322 "meta_property" => Ok(Self::MetaProperty(::std::boxed::Box::new(
323 ::treesitter_types::runtime::maybe_grow_stack(|| {
324 <MetaProperty as ::treesitter_types::FromNode>::from_node(node, src)
325 })?,
326 ))),
327 "null" => Ok(Self::Null(::std::boxed::Box::new(
328 ::treesitter_types::runtime::maybe_grow_stack(|| {
329 <Null as ::treesitter_types::FromNode>::from_node(node, src)
330 })?,
331 ))),
332 "number" => Ok(Self::Number(::std::boxed::Box::new(
333 ::treesitter_types::runtime::maybe_grow_stack(|| {
334 <Number as ::treesitter_types::FromNode>::from_node(node, src)
335 })?,
336 ))),
337 "object" => Ok(Self::Object(::std::boxed::Box::new(
338 ::treesitter_types::runtime::maybe_grow_stack(|| {
339 <Object as ::treesitter_types::FromNode>::from_node(node, src)
340 })?,
341 ))),
342 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
343 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
344 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
345 })?),
346 )),
347 "regex" => Ok(Self::Regex(::std::boxed::Box::new(
348 ::treesitter_types::runtime::maybe_grow_stack(|| {
349 <Regex as ::treesitter_types::FromNode>::from_node(node, src)
350 })?,
351 ))),
352 "string" => Ok(Self::String(::std::boxed::Box::new(
353 ::treesitter_types::runtime::maybe_grow_stack(|| {
354 <String as ::treesitter_types::FromNode>::from_node(node, src)
355 })?,
356 ))),
357 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
358 ::treesitter_types::runtime::maybe_grow_stack(|| {
359 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
360 })?,
361 ))),
362 "super" => Ok(Self::Super(::std::boxed::Box::new(
363 ::treesitter_types::runtime::maybe_grow_stack(|| {
364 <Super as ::treesitter_types::FromNode>::from_node(node, src)
365 })?,
366 ))),
367 "template_string" => Ok(Self::TemplateString(::std::boxed::Box::new(
368 ::treesitter_types::runtime::maybe_grow_stack(|| {
369 <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)
370 })?,
371 ))),
372 "this" => Ok(Self::This(::std::boxed::Box::new(
373 ::treesitter_types::runtime::maybe_grow_stack(|| {
374 <This as ::treesitter_types::FromNode>::from_node(node, src)
375 })?,
376 ))),
377 "true" => Ok(Self::True(::std::boxed::Box::new(
378 ::treesitter_types::runtime::maybe_grow_stack(|| {
379 <True as ::treesitter_types::FromNode>::from_node(node, src)
380 })?,
381 ))),
382 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
383 ::treesitter_types::runtime::maybe_grow_stack(|| {
384 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)
385 })?,
386 ))),
387 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
388 }
389 }
390}
391impl ::treesitter_types::Spanned for PrimaryExpression<'_> {
392 fn span(&self) -> ::treesitter_types::Span {
393 match self {
394 Self::Array(inner) => inner.span(),
395 Self::ArrowFunction(inner) => inner.span(),
396 Self::CallExpression(inner) => inner.span(),
397 Self::Class(inner) => inner.span(),
398 Self::False(inner) => inner.span(),
399 Self::FunctionExpression(inner) => inner.span(),
400 Self::GeneratorFunction(inner) => inner.span(),
401 Self::Identifier(inner) => inner.span(),
402 Self::MemberExpression(inner) => inner.span(),
403 Self::MetaProperty(inner) => inner.span(),
404 Self::Null(inner) => inner.span(),
405 Self::Number(inner) => inner.span(),
406 Self::Object(inner) => inner.span(),
407 Self::ParenthesizedExpression(inner) => inner.span(),
408 Self::Regex(inner) => inner.span(),
409 Self::String(inner) => inner.span(),
410 Self::SubscriptExpression(inner) => inner.span(),
411 Self::Super(inner) => inner.span(),
412 Self::TemplateString(inner) => inner.span(),
413 Self::This(inner) => inner.span(),
414 Self::True(inner) => inner.span(),
415 Self::Undefined(inner) => inner.span(),
416 }
417 }
418}
419#[derive(Debug, Clone, PartialEq, Eq)]
420pub enum Statement<'tree> {
421 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
422 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
423 DebuggerStatement(::std::boxed::Box<DebuggerStatement<'tree>>),
424 Declaration(::std::boxed::Box<Declaration<'tree>>),
425 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
426 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
427 ExportStatement(::std::boxed::Box<ExportStatement<'tree>>),
428 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
429 ForInStatement(::std::boxed::Box<ForInStatement<'tree>>),
430 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
431 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
432 ImportStatement(::std::boxed::Box<ImportStatement<'tree>>),
433 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
434 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
435 StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
436 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
437 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
438 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
439 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
440 WithStatement(::std::boxed::Box<WithStatement<'tree>>),
441}
442impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
443 #[allow(clippy::collapsible_else_if)]
444 fn from_node(
445 node: ::treesitter_types::tree_sitter::Node<'tree>,
446 src: &'tree [u8],
447 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
448 match node.kind() {
449 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
450 ::treesitter_types::runtime::maybe_grow_stack(|| {
451 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
452 })?,
453 ))),
454 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
455 ::treesitter_types::runtime::maybe_grow_stack(|| {
456 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
457 })?,
458 ))),
459 "debugger_statement" => Ok(Self::DebuggerStatement(::std::boxed::Box::new(
460 ::treesitter_types::runtime::maybe_grow_stack(|| {
461 <DebuggerStatement as ::treesitter_types::FromNode>::from_node(node, src)
462 })?,
463 ))),
464 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
465 ::treesitter_types::runtime::maybe_grow_stack(|| {
466 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
467 })?,
468 ))),
469 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
470 ::treesitter_types::runtime::maybe_grow_stack(|| {
471 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
472 })?,
473 ))),
474 "export_statement" => Ok(Self::ExportStatement(::std::boxed::Box::new(
475 ::treesitter_types::runtime::maybe_grow_stack(|| {
476 <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)
477 })?,
478 ))),
479 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
480 ::treesitter_types::runtime::maybe_grow_stack(|| {
481 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
482 })?,
483 ))),
484 "for_in_statement" => Ok(Self::ForInStatement(::std::boxed::Box::new(
485 ::treesitter_types::runtime::maybe_grow_stack(|| {
486 <ForInStatement as ::treesitter_types::FromNode>::from_node(node, src)
487 })?,
488 ))),
489 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
490 ::treesitter_types::runtime::maybe_grow_stack(|| {
491 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
492 })?,
493 ))),
494 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
495 ::treesitter_types::runtime::maybe_grow_stack(|| {
496 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
497 })?,
498 ))),
499 "import_statement" => Ok(Self::ImportStatement(::std::boxed::Box::new(
500 ::treesitter_types::runtime::maybe_grow_stack(|| {
501 <ImportStatement as ::treesitter_types::FromNode>::from_node(node, src)
502 })?,
503 ))),
504 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
505 ::treesitter_types::runtime::maybe_grow_stack(|| {
506 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
507 })?,
508 ))),
509 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
510 ::treesitter_types::runtime::maybe_grow_stack(|| {
511 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
512 })?,
513 ))),
514 "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
515 ::treesitter_types::runtime::maybe_grow_stack(|| {
516 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)
517 })?,
518 ))),
519 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
520 ::treesitter_types::runtime::maybe_grow_stack(|| {
521 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
522 })?,
523 ))),
524 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
525 ::treesitter_types::runtime::maybe_grow_stack(|| {
526 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
527 })?,
528 ))),
529 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
530 ::treesitter_types::runtime::maybe_grow_stack(|| {
531 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
532 })?,
533 ))),
534 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
535 ::treesitter_types::runtime::maybe_grow_stack(|| {
536 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
537 })?,
538 ))),
539 "with_statement" => Ok(Self::WithStatement(::std::boxed::Box::new(
540 ::treesitter_types::runtime::maybe_grow_stack(|| {
541 <WithStatement as ::treesitter_types::FromNode>::from_node(node, src)
542 })?,
543 ))),
544 _other => {
545 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
546 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
547 }) {
548 Ok(Self::Declaration(::std::boxed::Box::new(v)))
549 } else {
550 Err(::treesitter_types::ParseError::unexpected_kind(
551 _other, node,
552 ))
553 }
554 }
555 }
556 }
557}
558impl ::treesitter_types::Spanned for Statement<'_> {
559 fn span(&self) -> ::treesitter_types::Span {
560 match self {
561 Self::BreakStatement(inner) => inner.span(),
562 Self::ContinueStatement(inner) => inner.span(),
563 Self::DebuggerStatement(inner) => inner.span(),
564 Self::Declaration(inner) => inner.span(),
565 Self::DoStatement(inner) => inner.span(),
566 Self::EmptyStatement(inner) => inner.span(),
567 Self::ExportStatement(inner) => inner.span(),
568 Self::ExpressionStatement(inner) => inner.span(),
569 Self::ForInStatement(inner) => inner.span(),
570 Self::ForStatement(inner) => inner.span(),
571 Self::IfStatement(inner) => inner.span(),
572 Self::ImportStatement(inner) => inner.span(),
573 Self::LabeledStatement(inner) => inner.span(),
574 Self::ReturnStatement(inner) => inner.span(),
575 Self::StatementBlock(inner) => inner.span(),
576 Self::SwitchStatement(inner) => inner.span(),
577 Self::ThrowStatement(inner) => inner.span(),
578 Self::TryStatement(inner) => inner.span(),
579 Self::WhileStatement(inner) => inner.span(),
580 Self::WithStatement(inner) => inner.span(),
581 }
582 }
583}
584#[derive(Debug, Clone, PartialEq, Eq)]
585pub struct Arguments<'tree> {
586 pub span: ::treesitter_types::Span,
587 pub children: ::std::vec::Vec<ArgumentsChildren<'tree>>,
588}
589impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
590 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
591 fn from_node(
592 node: ::treesitter_types::tree_sitter::Node<'tree>,
593 src: &'tree [u8],
594 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
595 debug_assert_eq!(node.kind(), "arguments");
596 Ok(Self {
597 span: ::treesitter_types::Span::from(node),
598 children: {
599 #[allow(clippy::suspicious_else_formatting)]
600 let non_field_children = {
601 let mut cursor = node.walk();
602 let mut result = ::std::vec::Vec::new();
603 if cursor.goto_first_child() {
604 loop {
605 if cursor.field_name().is_none()
606 && cursor.node().is_named()
607 && !cursor.node().is_extra()
608 {
609 result.push(cursor.node());
610 }
611 if !cursor.goto_next_sibling() {
612 break;
613 }
614 }
615 }
616 result
617 };
618 let mut items = ::std::vec::Vec::new();
619 for child in non_field_children {
620 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
621 <ArgumentsChildren as ::treesitter_types::FromNode>::from_node(child, src)
622 })?);
623 }
624 items
625 },
626 })
627 }
628}
629impl ::treesitter_types::Spanned for Arguments<'_> {
630 fn span(&self) -> ::treesitter_types::Span {
631 self.span
632 }
633}
634#[derive(Debug, Clone, PartialEq, Eq)]
635pub struct Array<'tree> {
636 pub span: ::treesitter_types::Span,
637 pub children: ::std::vec::Vec<ArrayChildren<'tree>>,
638}
639impl<'tree> ::treesitter_types::FromNode<'tree> for Array<'tree> {
640 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
641 fn from_node(
642 node: ::treesitter_types::tree_sitter::Node<'tree>,
643 src: &'tree [u8],
644 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
645 debug_assert_eq!(node.kind(), "array");
646 Ok(Self {
647 span: ::treesitter_types::Span::from(node),
648 children: {
649 #[allow(clippy::suspicious_else_formatting)]
650 let non_field_children = {
651 let mut cursor = node.walk();
652 let mut result = ::std::vec::Vec::new();
653 if cursor.goto_first_child() {
654 loop {
655 if cursor.field_name().is_none()
656 && cursor.node().is_named()
657 && !cursor.node().is_extra()
658 {
659 result.push(cursor.node());
660 }
661 if !cursor.goto_next_sibling() {
662 break;
663 }
664 }
665 }
666 result
667 };
668 let mut items = ::std::vec::Vec::new();
669 for child in non_field_children {
670 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
671 <ArrayChildren as ::treesitter_types::FromNode>::from_node(child, src)
672 })?);
673 }
674 items
675 },
676 })
677 }
678}
679impl ::treesitter_types::Spanned for Array<'_> {
680 fn span(&self) -> ::treesitter_types::Span {
681 self.span
682 }
683}
684#[derive(Debug, Clone, PartialEq, Eq)]
685pub struct ArrayPattern<'tree> {
686 pub span: ::treesitter_types::Span,
687 pub children: ::std::vec::Vec<ArrayPatternChildren<'tree>>,
688}
689impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPattern<'tree> {
690 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
691 fn from_node(
692 node: ::treesitter_types::tree_sitter::Node<'tree>,
693 src: &'tree [u8],
694 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
695 debug_assert_eq!(node.kind(), "array_pattern");
696 Ok(Self {
697 span: ::treesitter_types::Span::from(node),
698 children: {
699 #[allow(clippy::suspicious_else_formatting)]
700 let non_field_children = {
701 let mut cursor = node.walk();
702 let mut result = ::std::vec::Vec::new();
703 if cursor.goto_first_child() {
704 loop {
705 if cursor.field_name().is_none()
706 && cursor.node().is_named()
707 && !cursor.node().is_extra()
708 {
709 result.push(cursor.node());
710 }
711 if !cursor.goto_next_sibling() {
712 break;
713 }
714 }
715 }
716 result
717 };
718 let mut items = ::std::vec::Vec::new();
719 for child in non_field_children {
720 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
721 <ArrayPatternChildren as ::treesitter_types::FromNode>::from_node(
722 child, src,
723 )
724 })?);
725 }
726 items
727 },
728 })
729 }
730}
731impl ::treesitter_types::Spanned for ArrayPattern<'_> {
732 fn span(&self) -> ::treesitter_types::Span {
733 self.span
734 }
735}
736#[derive(Debug, Clone, PartialEq, Eq)]
737pub struct ArrowFunction<'tree> {
738 pub span: ::treesitter_types::Span,
739 pub body: ArrowFunctionBody<'tree>,
740 pub parameter: ::core::option::Option<Identifier<'tree>>,
741 pub parameters: ::core::option::Option<FormalParameters<'tree>>,
742}
743impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunction<'tree> {
744 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
745 fn from_node(
746 node: ::treesitter_types::tree_sitter::Node<'tree>,
747 src: &'tree [u8],
748 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
749 debug_assert_eq!(node.kind(), "arrow_function");
750 Ok(Self {
751 span: ::treesitter_types::Span::from(node),
752 body: {
753 let child = node
754 .child_by_field_name("body")
755 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
756 ::treesitter_types::runtime::maybe_grow_stack(|| {
757 <ArrowFunctionBody as ::treesitter_types::FromNode>::from_node(child, src)
758 })?
759 },
760 parameter: match node.child_by_field_name("parameter") {
761 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
762 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
763 })?),
764 None => None,
765 },
766 parameters: match node.child_by_field_name("parameters") {
767 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
768 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
769 })?),
770 None => None,
771 },
772 })
773 }
774}
775impl ::treesitter_types::Spanned for ArrowFunction<'_> {
776 fn span(&self) -> ::treesitter_types::Span {
777 self.span
778 }
779}
780#[derive(Debug, Clone, PartialEq, Eq)]
781pub struct AssignmentExpression<'tree> {
782 pub span: ::treesitter_types::Span,
783 pub left: AssignmentExpressionLeft<'tree>,
784 pub right: Expression<'tree>,
785}
786impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
787 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
788 fn from_node(
789 node: ::treesitter_types::tree_sitter::Node<'tree>,
790 src: &'tree [u8],
791 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
792 debug_assert_eq!(node.kind(), "assignment_expression");
793 Ok(Self {
794 span: ::treesitter_types::Span::from(node),
795 left: {
796 let child = node
797 .child_by_field_name("left")
798 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
799 ::treesitter_types::runtime::maybe_grow_stack(|| {
800 <AssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
801 child, src,
802 )
803 })?
804 },
805 right: {
806 let child = node
807 .child_by_field_name("right")
808 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
809 ::treesitter_types::runtime::maybe_grow_stack(|| {
810 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
811 })?
812 },
813 })
814 }
815}
816impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
817 fn span(&self) -> ::treesitter_types::Span {
818 self.span
819 }
820}
821#[derive(Debug, Clone, PartialEq, Eq)]
822pub struct AssignmentPattern<'tree> {
823 pub span: ::treesitter_types::Span,
824 pub left: Pattern<'tree>,
825 pub right: Expression<'tree>,
826}
827impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentPattern<'tree> {
828 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
829 fn from_node(
830 node: ::treesitter_types::tree_sitter::Node<'tree>,
831 src: &'tree [u8],
832 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
833 debug_assert_eq!(node.kind(), "assignment_pattern");
834 Ok(Self {
835 span: ::treesitter_types::Span::from(node),
836 left: {
837 let child = node
838 .child_by_field_name("left")
839 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
840 ::treesitter_types::runtime::maybe_grow_stack(|| {
841 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
842 })?
843 },
844 right: {
845 let child = node
846 .child_by_field_name("right")
847 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
848 ::treesitter_types::runtime::maybe_grow_stack(|| {
849 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
850 })?
851 },
852 })
853 }
854}
855impl ::treesitter_types::Spanned for AssignmentPattern<'_> {
856 fn span(&self) -> ::treesitter_types::Span {
857 self.span
858 }
859}
860#[derive(Debug, Clone, PartialEq, Eq)]
861pub struct AugmentedAssignmentExpression<'tree> {
862 pub span: ::treesitter_types::Span,
863 pub left: AugmentedAssignmentExpressionLeft<'tree>,
864 pub operator: AugmentedAssignmentExpressionOperator,
865 pub right: Expression<'tree>,
866}
867impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpression<'tree> {
868 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
869 fn from_node(
870 node: ::treesitter_types::tree_sitter::Node<'tree>,
871 src: &'tree [u8],
872 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
873 debug_assert_eq!(node.kind(), "augmented_assignment_expression");
874 Ok(Self {
875 span: ::treesitter_types::Span::from(node),
876 left: {
877 let child = node
878 .child_by_field_name("left")
879 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
880 ::treesitter_types::runtime::maybe_grow_stack(|| {
881 <AugmentedAssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
882 child, src,
883 )
884 })?
885 },
886 operator: {
887 let child = node.child_by_field_name("operator").ok_or_else(|| {
888 ::treesitter_types::ParseError::missing_field("operator", node)
889 })?;
890 ::treesitter_types::runtime::maybe_grow_stack(|| {
891 <AugmentedAssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
892 child,
893 src,
894 )
895 })?
896 },
897 right: {
898 let child = node
899 .child_by_field_name("right")
900 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
901 ::treesitter_types::runtime::maybe_grow_stack(|| {
902 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
903 })?
904 },
905 })
906 }
907}
908impl ::treesitter_types::Spanned for AugmentedAssignmentExpression<'_> {
909 fn span(&self) -> ::treesitter_types::Span {
910 self.span
911 }
912}
913#[derive(Debug, Clone, PartialEq, Eq)]
914pub struct AwaitExpression<'tree> {
915 pub span: ::treesitter_types::Span,
916 pub children: Expression<'tree>,
917}
918impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
919 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
920 fn from_node(
921 node: ::treesitter_types::tree_sitter::Node<'tree>,
922 src: &'tree [u8],
923 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
924 debug_assert_eq!(node.kind(), "await_expression");
925 Ok(Self {
926 span: ::treesitter_types::Span::from(node),
927 children: {
928 #[allow(clippy::suspicious_else_formatting)]
929 let non_field_children = {
930 let mut cursor = node.walk();
931 let mut result = ::std::vec::Vec::new();
932 if cursor.goto_first_child() {
933 loop {
934 if cursor.field_name().is_none()
935 && cursor.node().is_named()
936 && !cursor.node().is_extra()
937 {
938 result.push(cursor.node());
939 }
940 if !cursor.goto_next_sibling() {
941 break;
942 }
943 }
944 }
945 result
946 };
947 let child = if let Some(&c) = non_field_children.first() {
948 c
949 } else {
950 let mut fallback_cursor = node.walk();
951 let mut fallback_child = None;
952 if fallback_cursor.goto_first_child() {
953 loop {
954 if fallback_cursor.field_name().is_none()
955 && !fallback_cursor.node().is_extra()
956 {
957 let candidate = fallback_cursor.node();
958 #[allow(clippy::needless_question_mark)]
959 if (|| -> ::core::result::Result<
960 _,
961 ::treesitter_types::ParseError,
962 > {
963 let child = candidate;
964 Ok(
965 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
966 child,
967 src,
968 ))?,
969 )
970 })()
971 .is_ok()
972 {
973 fallback_child = Some(candidate);
974 break;
975 }
976 }
977 if !fallback_cursor.goto_next_sibling() {
978 break;
979 }
980 }
981 }
982 if fallback_child.is_none() {
983 let mut cursor2 = node.walk();
984 if cursor2.goto_first_child() {
985 loop {
986 if cursor2.node().is_named() && !cursor2.node().is_extra() {
987 let candidate = cursor2.node();
988 #[allow(clippy::needless_question_mark)]
989 if (|| -> ::core::result::Result<
990 _,
991 ::treesitter_types::ParseError,
992 > {
993 let child = candidate;
994 Ok(
995 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
996 child,
997 src,
998 ))?,
999 )
1000 })()
1001 .is_ok()
1002 {
1003 fallback_child = Some(candidate);
1004 break;
1005 }
1006 }
1007 if !cursor2.goto_next_sibling() {
1008 break;
1009 }
1010 }
1011 }
1012 }
1013 fallback_child.ok_or_else(|| {
1014 ::treesitter_types::ParseError::missing_field("children", node)
1015 })?
1016 };
1017 ::treesitter_types::runtime::maybe_grow_stack(|| {
1018 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1019 })?
1020 },
1021 })
1022 }
1023}
1024impl ::treesitter_types::Spanned for AwaitExpression<'_> {
1025 fn span(&self) -> ::treesitter_types::Span {
1026 self.span
1027 }
1028}
1029#[derive(Debug, Clone, PartialEq, Eq)]
1030pub struct BinaryExpression<'tree> {
1031 pub span: ::treesitter_types::Span,
1032 pub left: BinaryExpressionLeft<'tree>,
1033 pub operator: BinaryExpressionOperator,
1034 pub right: Expression<'tree>,
1035}
1036impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1037 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1038 fn from_node(
1039 node: ::treesitter_types::tree_sitter::Node<'tree>,
1040 src: &'tree [u8],
1041 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1042 debug_assert_eq!(node.kind(), "binary_expression");
1043 Ok(Self {
1044 span: ::treesitter_types::Span::from(node),
1045 left: {
1046 let child = node
1047 .child_by_field_name("left")
1048 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1049 ::treesitter_types::runtime::maybe_grow_stack(|| {
1050 <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)
1051 })?
1052 },
1053 operator: {
1054 let child = node.child_by_field_name("operator").ok_or_else(|| {
1055 ::treesitter_types::ParseError::missing_field("operator", node)
1056 })?;
1057 ::treesitter_types::runtime::maybe_grow_stack(|| {
1058 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
1059 child, src,
1060 )
1061 })?
1062 },
1063 right: {
1064 let child = node
1065 .child_by_field_name("right")
1066 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1067 ::treesitter_types::runtime::maybe_grow_stack(|| {
1068 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1069 })?
1070 },
1071 })
1072 }
1073}
1074impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1075 fn span(&self) -> ::treesitter_types::Span {
1076 self.span
1077 }
1078}
1079#[derive(Debug, Clone, PartialEq, Eq)]
1080pub struct BreakStatement<'tree> {
1081 pub span: ::treesitter_types::Span,
1082 pub label: ::core::option::Option<StatementIdentifier<'tree>>,
1083}
1084impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
1085 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1086 fn from_node(
1087 node: ::treesitter_types::tree_sitter::Node<'tree>,
1088 src: &'tree [u8],
1089 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1090 debug_assert_eq!(node.kind(), "break_statement");
1091 Ok(Self {
1092 span: ::treesitter_types::Span::from(node),
1093 label: match node.child_by_field_name("label") {
1094 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1095 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
1096 })?),
1097 None => None,
1098 },
1099 })
1100 }
1101}
1102impl ::treesitter_types::Spanned for BreakStatement<'_> {
1103 fn span(&self) -> ::treesitter_types::Span {
1104 self.span
1105 }
1106}
1107#[derive(Debug, Clone, PartialEq, Eq)]
1108pub struct CallExpression<'tree> {
1109 pub span: ::treesitter_types::Span,
1110 pub arguments: CallExpressionArguments<'tree>,
1111 pub function: CallExpressionFunction<'tree>,
1112 pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
1113}
1114impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
1115 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1116 fn from_node(
1117 node: ::treesitter_types::tree_sitter::Node<'tree>,
1118 src: &'tree [u8],
1119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1120 debug_assert_eq!(node.kind(), "call_expression");
1121 Ok(Self {
1122 span: ::treesitter_types::Span::from(node),
1123 arguments: {
1124 let child = node.child_by_field_name("arguments").ok_or_else(|| {
1125 ::treesitter_types::ParseError::missing_field("arguments", node)
1126 })?;
1127 ::treesitter_types::runtime::maybe_grow_stack(|| {
1128 <CallExpressionArguments as ::treesitter_types::FromNode>::from_node(child, src)
1129 })?
1130 },
1131 function: {
1132 let child = node.child_by_field_name("function").ok_or_else(|| {
1133 ::treesitter_types::ParseError::missing_field("function", node)
1134 })?;
1135 ::treesitter_types::runtime::maybe_grow_stack(|| {
1136 <CallExpressionFunction as ::treesitter_types::FromNode>::from_node(child, src)
1137 })?
1138 },
1139 optional_chain: match node.child_by_field_name("optional_chain") {
1140 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1141 <OptionalChain as ::treesitter_types::FromNode>::from_node(child, src)
1142 })?),
1143 None => None,
1144 },
1145 })
1146 }
1147}
1148impl ::treesitter_types::Spanned for CallExpression<'_> {
1149 fn span(&self) -> ::treesitter_types::Span {
1150 self.span
1151 }
1152}
1153#[derive(Debug, Clone, PartialEq, Eq)]
1154pub struct CatchClause<'tree> {
1155 pub span: ::treesitter_types::Span,
1156 pub body: StatementBlock<'tree>,
1157 pub parameter: ::core::option::Option<CatchClauseParameter<'tree>>,
1158}
1159impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
1160 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1161 fn from_node(
1162 node: ::treesitter_types::tree_sitter::Node<'tree>,
1163 src: &'tree [u8],
1164 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1165 debug_assert_eq!(node.kind(), "catch_clause");
1166 Ok(Self {
1167 span: ::treesitter_types::Span::from(node),
1168 body: {
1169 let child = node
1170 .child_by_field_name("body")
1171 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1172 ::treesitter_types::runtime::maybe_grow_stack(|| {
1173 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)
1174 })?
1175 },
1176 parameter: match node.child_by_field_name("parameter") {
1177 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1178 <CatchClauseParameter as ::treesitter_types::FromNode>::from_node(child, src)
1179 })?),
1180 None => None,
1181 },
1182 })
1183 }
1184}
1185impl ::treesitter_types::Spanned for CatchClause<'_> {
1186 fn span(&self) -> ::treesitter_types::Span {
1187 self.span
1188 }
1189}
1190#[derive(Debug, Clone, PartialEq, Eq)]
1191pub struct Class<'tree> {
1192 pub span: ::treesitter_types::Span,
1193 pub body: ClassBody<'tree>,
1194 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
1195 pub name: ::core::option::Option<Identifier<'tree>>,
1196 pub children: ::core::option::Option<ClassHeritage<'tree>>,
1197}
1198impl<'tree> ::treesitter_types::FromNode<'tree> for Class<'tree> {
1199 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1200 fn from_node(
1201 node: ::treesitter_types::tree_sitter::Node<'tree>,
1202 src: &'tree [u8],
1203 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1204 debug_assert_eq!(node.kind(), "class");
1205 Ok(Self {
1206 span: ::treesitter_types::Span::from(node),
1207 body: {
1208 let child = node
1209 .child_by_field_name("body")
1210 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1211 ::treesitter_types::runtime::maybe_grow_stack(|| {
1212 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)
1213 })?
1214 },
1215 decorator: {
1216 let mut cursor = node.walk();
1217 let mut items = ::std::vec::Vec::new();
1218 for child in node.children_by_field_name("decorator", &mut cursor) {
1219 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1220 <Decorator as ::treesitter_types::FromNode>::from_node(child, src)
1221 })?);
1222 }
1223 items
1224 },
1225 name: match node.child_by_field_name("name") {
1226 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1227 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1228 })?),
1229 None => None,
1230 },
1231 children: {
1232 #[allow(clippy::suspicious_else_formatting)]
1233 let non_field_children = {
1234 let mut cursor = node.walk();
1235 let mut result = ::std::vec::Vec::new();
1236 if cursor.goto_first_child() {
1237 loop {
1238 if cursor.field_name().is_none()
1239 && cursor.node().is_named()
1240 && !cursor.node().is_extra()
1241 {
1242 result.push(cursor.node());
1243 }
1244 if !cursor.goto_next_sibling() {
1245 break;
1246 }
1247 }
1248 }
1249 result
1250 };
1251 match non_field_children.first() {
1252 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1253 <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)
1254 })?),
1255 None => None,
1256 }
1257 },
1258 })
1259 }
1260}
1261impl ::treesitter_types::Spanned for Class<'_> {
1262 fn span(&self) -> ::treesitter_types::Span {
1263 self.span
1264 }
1265}
1266#[derive(Debug, Clone, PartialEq, Eq)]
1267pub struct ClassBody<'tree> {
1268 pub span: ::treesitter_types::Span,
1269 pub member: ::std::vec::Vec<ClassBodyMember<'tree>>,
1270}
1271impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBody<'tree> {
1272 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1273 fn from_node(
1274 node: ::treesitter_types::tree_sitter::Node<'tree>,
1275 src: &'tree [u8],
1276 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1277 debug_assert_eq!(node.kind(), "class_body");
1278 Ok(Self {
1279 span: ::treesitter_types::Span::from(node),
1280 member: {
1281 let mut cursor = node.walk();
1282 let mut items = ::std::vec::Vec::new();
1283 for child in node.children_by_field_name("member", &mut cursor) {
1284 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1285 <ClassBodyMember as ::treesitter_types::FromNode>::from_node(child, src)
1286 })?);
1287 }
1288 items
1289 },
1290 })
1291 }
1292}
1293impl ::treesitter_types::Spanned for ClassBody<'_> {
1294 fn span(&self) -> ::treesitter_types::Span {
1295 self.span
1296 }
1297}
1298#[derive(Debug, Clone, PartialEq, Eq)]
1299pub struct ClassDeclaration<'tree> {
1300 pub span: ::treesitter_types::Span,
1301 pub body: ClassBody<'tree>,
1302 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
1303 pub name: Identifier<'tree>,
1304 pub children: ::core::option::Option<ClassHeritage<'tree>>,
1305}
1306impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
1307 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1308 fn from_node(
1309 node: ::treesitter_types::tree_sitter::Node<'tree>,
1310 src: &'tree [u8],
1311 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1312 debug_assert_eq!(node.kind(), "class_declaration");
1313 Ok(Self {
1314 span: ::treesitter_types::Span::from(node),
1315 body: {
1316 let child = node
1317 .child_by_field_name("body")
1318 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1319 ::treesitter_types::runtime::maybe_grow_stack(|| {
1320 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)
1321 })?
1322 },
1323 decorator: {
1324 let mut cursor = node.walk();
1325 let mut items = ::std::vec::Vec::new();
1326 for child in node.children_by_field_name("decorator", &mut cursor) {
1327 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1328 <Decorator as ::treesitter_types::FromNode>::from_node(child, src)
1329 })?);
1330 }
1331 items
1332 },
1333 name: {
1334 let child = node
1335 .child_by_field_name("name")
1336 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1337 ::treesitter_types::runtime::maybe_grow_stack(|| {
1338 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1339 })?
1340 },
1341 children: {
1342 #[allow(clippy::suspicious_else_formatting)]
1343 let non_field_children = {
1344 let mut cursor = node.walk();
1345 let mut result = ::std::vec::Vec::new();
1346 if cursor.goto_first_child() {
1347 loop {
1348 if cursor.field_name().is_none()
1349 && cursor.node().is_named()
1350 && !cursor.node().is_extra()
1351 {
1352 result.push(cursor.node());
1353 }
1354 if !cursor.goto_next_sibling() {
1355 break;
1356 }
1357 }
1358 }
1359 result
1360 };
1361 match non_field_children.first() {
1362 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1363 <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)
1364 })?),
1365 None => None,
1366 }
1367 },
1368 })
1369 }
1370}
1371impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
1372 fn span(&self) -> ::treesitter_types::Span {
1373 self.span
1374 }
1375}
1376#[derive(Debug, Clone, PartialEq, Eq)]
1377pub struct ClassHeritage<'tree> {
1378 pub span: ::treesitter_types::Span,
1379 pub children: Expression<'tree>,
1380}
1381impl<'tree> ::treesitter_types::FromNode<'tree> for ClassHeritage<'tree> {
1382 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1383 fn from_node(
1384 node: ::treesitter_types::tree_sitter::Node<'tree>,
1385 src: &'tree [u8],
1386 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1387 debug_assert_eq!(node.kind(), "class_heritage");
1388 Ok(Self {
1389 span: ::treesitter_types::Span::from(node),
1390 children: {
1391 #[allow(clippy::suspicious_else_formatting)]
1392 let non_field_children = {
1393 let mut cursor = node.walk();
1394 let mut result = ::std::vec::Vec::new();
1395 if cursor.goto_first_child() {
1396 loop {
1397 if cursor.field_name().is_none()
1398 && cursor.node().is_named()
1399 && !cursor.node().is_extra()
1400 {
1401 result.push(cursor.node());
1402 }
1403 if !cursor.goto_next_sibling() {
1404 break;
1405 }
1406 }
1407 }
1408 result
1409 };
1410 let child = if let Some(&c) = non_field_children.first() {
1411 c
1412 } else {
1413 let mut fallback_cursor = node.walk();
1414 let mut fallback_child = None;
1415 if fallback_cursor.goto_first_child() {
1416 loop {
1417 if fallback_cursor.field_name().is_none()
1418 && !fallback_cursor.node().is_extra()
1419 {
1420 let candidate = fallback_cursor.node();
1421 #[allow(clippy::needless_question_mark)]
1422 if (|| -> ::core::result::Result<
1423 _,
1424 ::treesitter_types::ParseError,
1425 > {
1426 let child = candidate;
1427 Ok(
1428 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1429 child,
1430 src,
1431 ))?,
1432 )
1433 })()
1434 .is_ok()
1435 {
1436 fallback_child = Some(candidate);
1437 break;
1438 }
1439 }
1440 if !fallback_cursor.goto_next_sibling() {
1441 break;
1442 }
1443 }
1444 }
1445 if fallback_child.is_none() {
1446 let mut cursor2 = node.walk();
1447 if cursor2.goto_first_child() {
1448 loop {
1449 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1450 let candidate = cursor2.node();
1451 #[allow(clippy::needless_question_mark)]
1452 if (|| -> ::core::result::Result<
1453 _,
1454 ::treesitter_types::ParseError,
1455 > {
1456 let child = candidate;
1457 Ok(
1458 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1459 child,
1460 src,
1461 ))?,
1462 )
1463 })()
1464 .is_ok()
1465 {
1466 fallback_child = Some(candidate);
1467 break;
1468 }
1469 }
1470 if !cursor2.goto_next_sibling() {
1471 break;
1472 }
1473 }
1474 }
1475 }
1476 fallback_child.ok_or_else(|| {
1477 ::treesitter_types::ParseError::missing_field("children", node)
1478 })?
1479 };
1480 ::treesitter_types::runtime::maybe_grow_stack(|| {
1481 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1482 })?
1483 },
1484 })
1485 }
1486}
1487impl ::treesitter_types::Spanned for ClassHeritage<'_> {
1488 fn span(&self) -> ::treesitter_types::Span {
1489 self.span
1490 }
1491}
1492#[derive(Debug, Clone, PartialEq, Eq)]
1493pub struct ClassStaticBlock<'tree> {
1494 pub span: ::treesitter_types::Span,
1495 pub body: StatementBlock<'tree>,
1496}
1497impl<'tree> ::treesitter_types::FromNode<'tree> for ClassStaticBlock<'tree> {
1498 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1499 fn from_node(
1500 node: ::treesitter_types::tree_sitter::Node<'tree>,
1501 src: &'tree [u8],
1502 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1503 debug_assert_eq!(node.kind(), "class_static_block");
1504 Ok(Self {
1505 span: ::treesitter_types::Span::from(node),
1506 body: {
1507 let child = node
1508 .child_by_field_name("body")
1509 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1510 ::treesitter_types::runtime::maybe_grow_stack(|| {
1511 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)
1512 })?
1513 },
1514 })
1515 }
1516}
1517impl ::treesitter_types::Spanned for ClassStaticBlock<'_> {
1518 fn span(&self) -> ::treesitter_types::Span {
1519 self.span
1520 }
1521}
1522#[derive(Debug, Clone, PartialEq, Eq)]
1523pub struct ComputedPropertyName<'tree> {
1524 pub span: ::treesitter_types::Span,
1525 pub children: Expression<'tree>,
1526}
1527impl<'tree> ::treesitter_types::FromNode<'tree> for ComputedPropertyName<'tree> {
1528 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1529 fn from_node(
1530 node: ::treesitter_types::tree_sitter::Node<'tree>,
1531 src: &'tree [u8],
1532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1533 debug_assert_eq!(node.kind(), "computed_property_name");
1534 Ok(Self {
1535 span: ::treesitter_types::Span::from(node),
1536 children: {
1537 #[allow(clippy::suspicious_else_formatting)]
1538 let non_field_children = {
1539 let mut cursor = node.walk();
1540 let mut result = ::std::vec::Vec::new();
1541 if cursor.goto_first_child() {
1542 loop {
1543 if cursor.field_name().is_none()
1544 && cursor.node().is_named()
1545 && !cursor.node().is_extra()
1546 {
1547 result.push(cursor.node());
1548 }
1549 if !cursor.goto_next_sibling() {
1550 break;
1551 }
1552 }
1553 }
1554 result
1555 };
1556 let child = if let Some(&c) = non_field_children.first() {
1557 c
1558 } else {
1559 let mut fallback_cursor = node.walk();
1560 let mut fallback_child = None;
1561 if fallback_cursor.goto_first_child() {
1562 loop {
1563 if fallback_cursor.field_name().is_none()
1564 && !fallback_cursor.node().is_extra()
1565 {
1566 let candidate = fallback_cursor.node();
1567 #[allow(clippy::needless_question_mark)]
1568 if (|| -> ::core::result::Result<
1569 _,
1570 ::treesitter_types::ParseError,
1571 > {
1572 let child = candidate;
1573 Ok(
1574 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1575 child,
1576 src,
1577 ))?,
1578 )
1579 })()
1580 .is_ok()
1581 {
1582 fallback_child = Some(candidate);
1583 break;
1584 }
1585 }
1586 if !fallback_cursor.goto_next_sibling() {
1587 break;
1588 }
1589 }
1590 }
1591 if fallback_child.is_none() {
1592 let mut cursor2 = node.walk();
1593 if cursor2.goto_first_child() {
1594 loop {
1595 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1596 let candidate = cursor2.node();
1597 #[allow(clippy::needless_question_mark)]
1598 if (|| -> ::core::result::Result<
1599 _,
1600 ::treesitter_types::ParseError,
1601 > {
1602 let child = candidate;
1603 Ok(
1604 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1605 child,
1606 src,
1607 ))?,
1608 )
1609 })()
1610 .is_ok()
1611 {
1612 fallback_child = Some(candidate);
1613 break;
1614 }
1615 }
1616 if !cursor2.goto_next_sibling() {
1617 break;
1618 }
1619 }
1620 }
1621 }
1622 fallback_child.ok_or_else(|| {
1623 ::treesitter_types::ParseError::missing_field("children", node)
1624 })?
1625 };
1626 ::treesitter_types::runtime::maybe_grow_stack(|| {
1627 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1628 })?
1629 },
1630 })
1631 }
1632}
1633impl ::treesitter_types::Spanned for ComputedPropertyName<'_> {
1634 fn span(&self) -> ::treesitter_types::Span {
1635 self.span
1636 }
1637}
1638#[derive(Debug, Clone, PartialEq, Eq)]
1639pub struct ContinueStatement<'tree> {
1640 pub span: ::treesitter_types::Span,
1641 pub label: ::core::option::Option<StatementIdentifier<'tree>>,
1642}
1643impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
1644 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1645 fn from_node(
1646 node: ::treesitter_types::tree_sitter::Node<'tree>,
1647 src: &'tree [u8],
1648 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1649 debug_assert_eq!(node.kind(), "continue_statement");
1650 Ok(Self {
1651 span: ::treesitter_types::Span::from(node),
1652 label: match node.child_by_field_name("label") {
1653 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1654 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
1655 })?),
1656 None => None,
1657 },
1658 })
1659 }
1660}
1661impl ::treesitter_types::Spanned for ContinueStatement<'_> {
1662 fn span(&self) -> ::treesitter_types::Span {
1663 self.span
1664 }
1665}
1666#[derive(Debug, Clone, PartialEq, Eq)]
1667pub struct DebuggerStatement<'tree> {
1668 pub span: ::treesitter_types::Span,
1669 text: &'tree str,
1670}
1671impl<'tree> ::treesitter_types::FromNode<'tree> for DebuggerStatement<'tree> {
1672 fn from_node(
1673 node: ::treesitter_types::tree_sitter::Node<'tree>,
1674 src: &'tree [u8],
1675 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1676 debug_assert_eq!(node.kind(), "debugger_statement");
1677 Ok(Self {
1678 span: ::treesitter_types::Span::from(node),
1679 text: node.utf8_text(src)?,
1680 })
1681 }
1682}
1683impl<'tree> ::treesitter_types::LeafNode<'tree> for DebuggerStatement<'tree> {
1684 fn text(&self) -> &'tree str {
1685 self.text
1686 }
1687}
1688impl ::treesitter_types::Spanned for DebuggerStatement<'_> {
1689 fn span(&self) -> ::treesitter_types::Span {
1690 self.span
1691 }
1692}
1693#[derive(Debug, Clone, PartialEq, Eq)]
1694pub struct Decorator<'tree> {
1695 pub span: ::treesitter_types::Span,
1696 pub children: DecoratorChildren<'tree>,
1697}
1698impl<'tree> ::treesitter_types::FromNode<'tree> for Decorator<'tree> {
1699 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1700 fn from_node(
1701 node: ::treesitter_types::tree_sitter::Node<'tree>,
1702 src: &'tree [u8],
1703 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1704 debug_assert_eq!(node.kind(), "decorator");
1705 Ok(Self {
1706 span: ::treesitter_types::Span::from(node),
1707 children: {
1708 #[allow(clippy::suspicious_else_formatting)]
1709 let non_field_children = {
1710 let mut cursor = node.walk();
1711 let mut result = ::std::vec::Vec::new();
1712 if cursor.goto_first_child() {
1713 loop {
1714 if cursor.field_name().is_none()
1715 && cursor.node().is_named()
1716 && !cursor.node().is_extra()
1717 {
1718 result.push(cursor.node());
1719 }
1720 if !cursor.goto_next_sibling() {
1721 break;
1722 }
1723 }
1724 }
1725 result
1726 };
1727 let child = if let Some(&c) = non_field_children.first() {
1728 c
1729 } else {
1730 let mut fallback_cursor = node.walk();
1731 let mut fallback_child = None;
1732 if fallback_cursor.goto_first_child() {
1733 loop {
1734 if fallback_cursor.field_name().is_none()
1735 && !fallback_cursor.node().is_extra()
1736 {
1737 let candidate = fallback_cursor.node();
1738 #[allow(clippy::needless_question_mark)]
1739 if (|| -> ::core::result::Result<
1740 _,
1741 ::treesitter_types::ParseError,
1742 > {
1743 let child = candidate;
1744 Ok(
1745 ::treesitter_types::runtime::maybe_grow_stack(|| <DecoratorChildren as ::treesitter_types::FromNode>::from_node(
1746 child,
1747 src,
1748 ))?,
1749 )
1750 })()
1751 .is_ok()
1752 {
1753 fallback_child = Some(candidate);
1754 break;
1755 }
1756 }
1757 if !fallback_cursor.goto_next_sibling() {
1758 break;
1759 }
1760 }
1761 }
1762 if fallback_child.is_none() {
1763 let mut cursor2 = node.walk();
1764 if cursor2.goto_first_child() {
1765 loop {
1766 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1767 let candidate = cursor2.node();
1768 #[allow(clippy::needless_question_mark)]
1769 if (|| -> ::core::result::Result<
1770 _,
1771 ::treesitter_types::ParseError,
1772 > {
1773 let child = candidate;
1774 Ok(
1775 ::treesitter_types::runtime::maybe_grow_stack(|| <DecoratorChildren as ::treesitter_types::FromNode>::from_node(
1776 child,
1777 src,
1778 ))?,
1779 )
1780 })()
1781 .is_ok()
1782 {
1783 fallback_child = Some(candidate);
1784 break;
1785 }
1786 }
1787 if !cursor2.goto_next_sibling() {
1788 break;
1789 }
1790 }
1791 }
1792 }
1793 fallback_child.ok_or_else(|| {
1794 ::treesitter_types::ParseError::missing_field("children", node)
1795 })?
1796 };
1797 ::treesitter_types::runtime::maybe_grow_stack(|| {
1798 <DecoratorChildren as ::treesitter_types::FromNode>::from_node(child, src)
1799 })?
1800 },
1801 })
1802 }
1803}
1804impl ::treesitter_types::Spanned for Decorator<'_> {
1805 fn span(&self) -> ::treesitter_types::Span {
1806 self.span
1807 }
1808}
1809#[derive(Debug, Clone, PartialEq, Eq)]
1810pub struct DoStatement<'tree> {
1811 pub span: ::treesitter_types::Span,
1812 pub body: Statement<'tree>,
1813 pub condition: ParenthesizedExpression<'tree>,
1814}
1815impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
1816 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1817 fn from_node(
1818 node: ::treesitter_types::tree_sitter::Node<'tree>,
1819 src: &'tree [u8],
1820 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1821 debug_assert_eq!(node.kind(), "do_statement");
1822 Ok(Self {
1823 span: ::treesitter_types::Span::from(node),
1824 body: {
1825 let child = node
1826 .child_by_field_name("body")
1827 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1828 ::treesitter_types::runtime::maybe_grow_stack(|| {
1829 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
1830 })?
1831 },
1832 condition: {
1833 let child = node.child_by_field_name("condition").ok_or_else(|| {
1834 ::treesitter_types::ParseError::missing_field("condition", node)
1835 })?;
1836 ::treesitter_types::runtime::maybe_grow_stack(|| {
1837 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
1838 })?
1839 },
1840 })
1841 }
1842}
1843impl ::treesitter_types::Spanned for DoStatement<'_> {
1844 fn span(&self) -> ::treesitter_types::Span {
1845 self.span
1846 }
1847}
1848#[derive(Debug, Clone, PartialEq, Eq)]
1849pub struct ElseClause<'tree> {
1850 pub span: ::treesitter_types::Span,
1851 pub children: Statement<'tree>,
1852}
1853impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
1854 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1855 fn from_node(
1856 node: ::treesitter_types::tree_sitter::Node<'tree>,
1857 src: &'tree [u8],
1858 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1859 debug_assert_eq!(node.kind(), "else_clause");
1860 Ok(Self {
1861 span: ::treesitter_types::Span::from(node),
1862 children: {
1863 #[allow(clippy::suspicious_else_formatting)]
1864 let non_field_children = {
1865 let mut cursor = node.walk();
1866 let mut result = ::std::vec::Vec::new();
1867 if cursor.goto_first_child() {
1868 loop {
1869 if cursor.field_name().is_none()
1870 && cursor.node().is_named()
1871 && !cursor.node().is_extra()
1872 {
1873 result.push(cursor.node());
1874 }
1875 if !cursor.goto_next_sibling() {
1876 break;
1877 }
1878 }
1879 }
1880 result
1881 };
1882 let child = if let Some(&c) = non_field_children.first() {
1883 c
1884 } else {
1885 let mut fallback_cursor = node.walk();
1886 let mut fallback_child = None;
1887 if fallback_cursor.goto_first_child() {
1888 loop {
1889 if fallback_cursor.field_name().is_none()
1890 && !fallback_cursor.node().is_extra()
1891 {
1892 let candidate = fallback_cursor.node();
1893 #[allow(clippy::needless_question_mark)]
1894 if (|| -> ::core::result::Result<
1895 _,
1896 ::treesitter_types::ParseError,
1897 > {
1898 let child = candidate;
1899 Ok(
1900 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
1901 child,
1902 src,
1903 ))?,
1904 )
1905 })()
1906 .is_ok()
1907 {
1908 fallback_child = Some(candidate);
1909 break;
1910 }
1911 }
1912 if !fallback_cursor.goto_next_sibling() {
1913 break;
1914 }
1915 }
1916 }
1917 if fallback_child.is_none() {
1918 let mut cursor2 = node.walk();
1919 if cursor2.goto_first_child() {
1920 loop {
1921 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1922 let candidate = cursor2.node();
1923 #[allow(clippy::needless_question_mark)]
1924 if (|| -> ::core::result::Result<
1925 _,
1926 ::treesitter_types::ParseError,
1927 > {
1928 let child = candidate;
1929 Ok(
1930 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
1931 child,
1932 src,
1933 ))?,
1934 )
1935 })()
1936 .is_ok()
1937 {
1938 fallback_child = Some(candidate);
1939 break;
1940 }
1941 }
1942 if !cursor2.goto_next_sibling() {
1943 break;
1944 }
1945 }
1946 }
1947 }
1948 fallback_child.ok_or_else(|| {
1949 ::treesitter_types::ParseError::missing_field("children", node)
1950 })?
1951 };
1952 ::treesitter_types::runtime::maybe_grow_stack(|| {
1953 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
1954 })?
1955 },
1956 })
1957 }
1958}
1959impl ::treesitter_types::Spanned for ElseClause<'_> {
1960 fn span(&self) -> ::treesitter_types::Span {
1961 self.span
1962 }
1963}
1964#[derive(Debug, Clone, PartialEq, Eq)]
1965pub struct EmptyStatement<'tree> {
1966 pub span: ::treesitter_types::Span,
1967 text: &'tree str,
1968}
1969impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
1970 fn from_node(
1971 node: ::treesitter_types::tree_sitter::Node<'tree>,
1972 src: &'tree [u8],
1973 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1974 debug_assert_eq!(node.kind(), "empty_statement");
1975 Ok(Self {
1976 span: ::treesitter_types::Span::from(node),
1977 text: node.utf8_text(src)?,
1978 })
1979 }
1980}
1981impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
1982 fn text(&self) -> &'tree str {
1983 self.text
1984 }
1985}
1986impl ::treesitter_types::Spanned for EmptyStatement<'_> {
1987 fn span(&self) -> ::treesitter_types::Span {
1988 self.span
1989 }
1990}
1991#[derive(Debug, Clone, PartialEq, Eq)]
1992pub struct ExportClause<'tree> {
1993 pub span: ::treesitter_types::Span,
1994 pub children: ::std::vec::Vec<ExportSpecifier<'tree>>,
1995}
1996impl<'tree> ::treesitter_types::FromNode<'tree> for ExportClause<'tree> {
1997 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1998 fn from_node(
1999 node: ::treesitter_types::tree_sitter::Node<'tree>,
2000 src: &'tree [u8],
2001 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2002 debug_assert_eq!(node.kind(), "export_clause");
2003 Ok(Self {
2004 span: ::treesitter_types::Span::from(node),
2005 children: {
2006 #[allow(clippy::suspicious_else_formatting)]
2007 let non_field_children = {
2008 let mut cursor = node.walk();
2009 let mut result = ::std::vec::Vec::new();
2010 if cursor.goto_first_child() {
2011 loop {
2012 if cursor.field_name().is_none()
2013 && cursor.node().is_named()
2014 && !cursor.node().is_extra()
2015 {
2016 result.push(cursor.node());
2017 }
2018 if !cursor.goto_next_sibling() {
2019 break;
2020 }
2021 }
2022 }
2023 result
2024 };
2025 let mut items = ::std::vec::Vec::new();
2026 for child in non_field_children {
2027 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2028 <ExportSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
2029 })?);
2030 }
2031 items
2032 },
2033 })
2034 }
2035}
2036impl ::treesitter_types::Spanned for ExportClause<'_> {
2037 fn span(&self) -> ::treesitter_types::Span {
2038 self.span
2039 }
2040}
2041#[derive(Debug, Clone, PartialEq, Eq)]
2042pub struct ExportSpecifier<'tree> {
2043 pub span: ::treesitter_types::Span,
2044 pub alias: ::core::option::Option<ExportSpecifierAlias<'tree>>,
2045 pub name: ExportSpecifierName<'tree>,
2046}
2047impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifier<'tree> {
2048 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2049 fn from_node(
2050 node: ::treesitter_types::tree_sitter::Node<'tree>,
2051 src: &'tree [u8],
2052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2053 debug_assert_eq!(node.kind(), "export_specifier");
2054 Ok(Self {
2055 span: ::treesitter_types::Span::from(node),
2056 alias: match node.child_by_field_name("alias") {
2057 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2058 <ExportSpecifierAlias as ::treesitter_types::FromNode>::from_node(child, src)
2059 })?),
2060 None => None,
2061 },
2062 name: {
2063 let child = node
2064 .child_by_field_name("name")
2065 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2066 ::treesitter_types::runtime::maybe_grow_stack(|| {
2067 <ExportSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)
2068 })?
2069 },
2070 })
2071 }
2072}
2073impl ::treesitter_types::Spanned for ExportSpecifier<'_> {
2074 fn span(&self) -> ::treesitter_types::Span {
2075 self.span
2076 }
2077}
2078#[derive(Debug, Clone, PartialEq, Eq)]
2079pub struct ExportStatement<'tree> {
2080 pub span: ::treesitter_types::Span,
2081 pub declaration: ::core::option::Option<Declaration<'tree>>,
2082 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
2083 pub source: ::core::option::Option<String<'tree>>,
2084 pub value: ::core::option::Option<Expression<'tree>>,
2085 pub children: ::core::option::Option<ExportStatementChildren<'tree>>,
2086}
2087impl<'tree> ::treesitter_types::FromNode<'tree> for ExportStatement<'tree> {
2088 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2089 fn from_node(
2090 node: ::treesitter_types::tree_sitter::Node<'tree>,
2091 src: &'tree [u8],
2092 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2093 debug_assert_eq!(node.kind(), "export_statement");
2094 Ok(Self {
2095 span: ::treesitter_types::Span::from(node),
2096 declaration: match node.child_by_field_name("declaration") {
2097 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2098 <Declaration as ::treesitter_types::FromNode>::from_node(child, src)
2099 })?),
2100 None => None,
2101 },
2102 decorator: {
2103 let mut cursor = node.walk();
2104 let mut items = ::std::vec::Vec::new();
2105 for child in node.children_by_field_name("decorator", &mut cursor) {
2106 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2107 <Decorator as ::treesitter_types::FromNode>::from_node(child, src)
2108 })?);
2109 }
2110 items
2111 },
2112 source: match node.child_by_field_name("source") {
2113 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2114 <String as ::treesitter_types::FromNode>::from_node(child, src)
2115 })?),
2116 None => None,
2117 },
2118 value: match node.child_by_field_name("value") {
2119 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2120 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2121 })?),
2122 None => None,
2123 },
2124 children: {
2125 #[allow(clippy::suspicious_else_formatting)]
2126 let non_field_children = {
2127 let mut cursor = node.walk();
2128 let mut result = ::std::vec::Vec::new();
2129 if cursor.goto_first_child() {
2130 loop {
2131 if cursor.field_name().is_none()
2132 && cursor.node().is_named()
2133 && !cursor.node().is_extra()
2134 {
2135 result.push(cursor.node());
2136 }
2137 if !cursor.goto_next_sibling() {
2138 break;
2139 }
2140 }
2141 }
2142 result
2143 };
2144 match non_field_children.first() {
2145 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2146 <ExportStatementChildren as ::treesitter_types::FromNode>::from_node(
2147 child, src,
2148 )
2149 })?),
2150 None => None,
2151 }
2152 },
2153 })
2154 }
2155}
2156impl ::treesitter_types::Spanned for ExportStatement<'_> {
2157 fn span(&self) -> ::treesitter_types::Span {
2158 self.span
2159 }
2160}
2161#[derive(Debug, Clone, PartialEq, Eq)]
2162pub struct ExpressionStatement<'tree> {
2163 pub span: ::treesitter_types::Span,
2164 pub children: ExpressionStatementChildren<'tree>,
2165}
2166impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
2167 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2168 fn from_node(
2169 node: ::treesitter_types::tree_sitter::Node<'tree>,
2170 src: &'tree [u8],
2171 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2172 debug_assert_eq!(node.kind(), "expression_statement");
2173 Ok(Self {
2174 span: ::treesitter_types::Span::from(node),
2175 children: {
2176 #[allow(clippy::suspicious_else_formatting)]
2177 let non_field_children = {
2178 let mut cursor = node.walk();
2179 let mut result = ::std::vec::Vec::new();
2180 if cursor.goto_first_child() {
2181 loop {
2182 if cursor.field_name().is_none()
2183 && cursor.node().is_named()
2184 && !cursor.node().is_extra()
2185 {
2186 result.push(cursor.node());
2187 }
2188 if !cursor.goto_next_sibling() {
2189 break;
2190 }
2191 }
2192 }
2193 result
2194 };
2195 let child = if let Some(&c) = non_field_children.first() {
2196 c
2197 } else {
2198 let mut fallback_cursor = node.walk();
2199 let mut fallback_child = None;
2200 if fallback_cursor.goto_first_child() {
2201 loop {
2202 if fallback_cursor.field_name().is_none()
2203 && !fallback_cursor.node().is_extra()
2204 {
2205 let candidate = fallback_cursor.node();
2206 #[allow(clippy::needless_question_mark)]
2207 if (|| -> ::core::result::Result<
2208 _,
2209 ::treesitter_types::ParseError,
2210 > {
2211 let child = candidate;
2212 Ok(
2213 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
2214 child,
2215 src,
2216 ))?,
2217 )
2218 })()
2219 .is_ok()
2220 {
2221 fallback_child = Some(candidate);
2222 break;
2223 }
2224 }
2225 if !fallback_cursor.goto_next_sibling() {
2226 break;
2227 }
2228 }
2229 }
2230 if fallback_child.is_none() {
2231 let mut cursor2 = node.walk();
2232 if cursor2.goto_first_child() {
2233 loop {
2234 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2235 let candidate = cursor2.node();
2236 #[allow(clippy::needless_question_mark)]
2237 if (|| -> ::core::result::Result<
2238 _,
2239 ::treesitter_types::ParseError,
2240 > {
2241 let child = candidate;
2242 Ok(
2243 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
2244 child,
2245 src,
2246 ))?,
2247 )
2248 })()
2249 .is_ok()
2250 {
2251 fallback_child = Some(candidate);
2252 break;
2253 }
2254 }
2255 if !cursor2.goto_next_sibling() {
2256 break;
2257 }
2258 }
2259 }
2260 }
2261 fallback_child.ok_or_else(|| {
2262 ::treesitter_types::ParseError::missing_field("children", node)
2263 })?
2264 };
2265 ::treesitter_types::runtime::maybe_grow_stack(|| {
2266 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
2267 child, src,
2268 )
2269 })?
2270 },
2271 })
2272 }
2273}
2274impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
2275 fn span(&self) -> ::treesitter_types::Span {
2276 self.span
2277 }
2278}
2279#[derive(Debug, Clone, PartialEq, Eq)]
2280pub struct FieldDefinition<'tree> {
2281 pub span: ::treesitter_types::Span,
2282 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
2283 pub property: FieldDefinitionProperty<'tree>,
2284 pub value: ::core::option::Option<Expression<'tree>>,
2285}
2286impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDefinition<'tree> {
2287 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2288 fn from_node(
2289 node: ::treesitter_types::tree_sitter::Node<'tree>,
2290 src: &'tree [u8],
2291 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2292 debug_assert_eq!(node.kind(), "field_definition");
2293 Ok(Self {
2294 span: ::treesitter_types::Span::from(node),
2295 decorator: {
2296 let mut cursor = node.walk();
2297 let mut items = ::std::vec::Vec::new();
2298 for child in node.children_by_field_name("decorator", &mut cursor) {
2299 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2300 <Decorator as ::treesitter_types::FromNode>::from_node(child, src)
2301 })?);
2302 }
2303 items
2304 },
2305 property: {
2306 let child = node.child_by_field_name("property").ok_or_else(|| {
2307 ::treesitter_types::ParseError::missing_field("property", node)
2308 })?;
2309 ::treesitter_types::runtime::maybe_grow_stack(|| {
2310 <FieldDefinitionProperty as ::treesitter_types::FromNode>::from_node(child, src)
2311 })?
2312 },
2313 value: match node.child_by_field_name("value") {
2314 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2315 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2316 })?),
2317 None => None,
2318 },
2319 })
2320 }
2321}
2322impl ::treesitter_types::Spanned for FieldDefinition<'_> {
2323 fn span(&self) -> ::treesitter_types::Span {
2324 self.span
2325 }
2326}
2327#[derive(Debug, Clone, PartialEq, Eq)]
2328pub struct FinallyClause<'tree> {
2329 pub span: ::treesitter_types::Span,
2330 pub body: StatementBlock<'tree>,
2331}
2332impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
2333 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2334 fn from_node(
2335 node: ::treesitter_types::tree_sitter::Node<'tree>,
2336 src: &'tree [u8],
2337 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2338 debug_assert_eq!(node.kind(), "finally_clause");
2339 Ok(Self {
2340 span: ::treesitter_types::Span::from(node),
2341 body: {
2342 let child = node
2343 .child_by_field_name("body")
2344 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2345 ::treesitter_types::runtime::maybe_grow_stack(|| {
2346 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)
2347 })?
2348 },
2349 })
2350 }
2351}
2352impl ::treesitter_types::Spanned for FinallyClause<'_> {
2353 fn span(&self) -> ::treesitter_types::Span {
2354 self.span
2355 }
2356}
2357#[derive(Debug, Clone, PartialEq, Eq)]
2358pub struct ForInStatement<'tree> {
2359 pub span: ::treesitter_types::Span,
2360 pub body: Statement<'tree>,
2361 pub kind: ::std::vec::Vec<ForInStatementKind>,
2362 pub left: ForInStatementLeft<'tree>,
2363 pub operator: ForInStatementOperator,
2364 pub right: ForInStatementRight<'tree>,
2365 pub value: ::core::option::Option<Expression<'tree>>,
2366}
2367impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatement<'tree> {
2368 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2369 fn from_node(
2370 node: ::treesitter_types::tree_sitter::Node<'tree>,
2371 src: &'tree [u8],
2372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2373 debug_assert_eq!(node.kind(), "for_in_statement");
2374 Ok(Self {
2375 span: ::treesitter_types::Span::from(node),
2376 body: {
2377 let child = node
2378 .child_by_field_name("body")
2379 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2380 ::treesitter_types::runtime::maybe_grow_stack(|| {
2381 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2382 })?
2383 },
2384 kind: {
2385 let mut cursor = node.walk();
2386 let mut items = ::std::vec::Vec::new();
2387 for child in node.children_by_field_name("kind", &mut cursor) {
2388 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2389 <ForInStatementKind as ::treesitter_types::FromNode>::from_node(child, src)
2390 })?);
2391 }
2392 items
2393 },
2394 left: {
2395 let child = node
2396 .child_by_field_name("left")
2397 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2398 ::treesitter_types::runtime::maybe_grow_stack(|| {
2399 <ForInStatementLeft as ::treesitter_types::FromNode>::from_node(child, src)
2400 })?
2401 },
2402 operator: {
2403 let child = node.child_by_field_name("operator").ok_or_else(|| {
2404 ::treesitter_types::ParseError::missing_field("operator", node)
2405 })?;
2406 ::treesitter_types::runtime::maybe_grow_stack(|| {
2407 <ForInStatementOperator as ::treesitter_types::FromNode>::from_node(child, src)
2408 })?
2409 },
2410 right: {
2411 let child = node
2412 .child_by_field_name("right")
2413 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2414 ::treesitter_types::runtime::maybe_grow_stack(|| {
2415 <ForInStatementRight as ::treesitter_types::FromNode>::from_node(child, src)
2416 })?
2417 },
2418 value: match node.child_by_field_name("value") {
2419 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2420 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2421 })?),
2422 None => None,
2423 },
2424 })
2425 }
2426}
2427impl ::treesitter_types::Spanned for ForInStatement<'_> {
2428 fn span(&self) -> ::treesitter_types::Span {
2429 self.span
2430 }
2431}
2432#[derive(Debug, Clone, PartialEq, Eq)]
2433pub struct ForStatement<'tree> {
2434 pub span: ::treesitter_types::Span,
2435 pub body: Statement<'tree>,
2436 pub condition: ::std::vec::Vec<ForStatementCondition<'tree>>,
2437 pub increment: ::core::option::Option<ForStatementIncrement<'tree>>,
2438 pub initializer: ForStatementInitializer<'tree>,
2439}
2440impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
2441 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2442 fn from_node(
2443 node: ::treesitter_types::tree_sitter::Node<'tree>,
2444 src: &'tree [u8],
2445 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2446 debug_assert_eq!(node.kind(), "for_statement");
2447 Ok(Self {
2448 span: ::treesitter_types::Span::from(node),
2449 body: {
2450 let child = node
2451 .child_by_field_name("body")
2452 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2453 ::treesitter_types::runtime::maybe_grow_stack(|| {
2454 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2455 })?
2456 },
2457 condition: {
2458 let mut cursor = node.walk();
2459 let mut items = ::std::vec::Vec::new();
2460 for child in node.children_by_field_name("condition", &mut cursor) {
2461 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2462 <ForStatementCondition as ::treesitter_types::FromNode>::from_node(
2463 child, src,
2464 )
2465 })?);
2466 }
2467 items
2468 },
2469 increment: match node.child_by_field_name("increment") {
2470 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2471 <ForStatementIncrement as ::treesitter_types::FromNode>::from_node(child, src)
2472 })?),
2473 None => None,
2474 },
2475 initializer: {
2476 let child = node.child_by_field_name("initializer").ok_or_else(|| {
2477 ::treesitter_types::ParseError::missing_field("initializer", node)
2478 })?;
2479 ::treesitter_types::runtime::maybe_grow_stack(|| {
2480 <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(child, src)
2481 })?
2482 },
2483 })
2484 }
2485}
2486impl ::treesitter_types::Spanned for ForStatement<'_> {
2487 fn span(&self) -> ::treesitter_types::Span {
2488 self.span
2489 }
2490}
2491#[derive(Debug, Clone, PartialEq, Eq)]
2492pub struct FormalParameters<'tree> {
2493 pub span: ::treesitter_types::Span,
2494 pub children: ::std::vec::Vec<FormalParametersChildren<'tree>>,
2495}
2496impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameters<'tree> {
2497 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2498 fn from_node(
2499 node: ::treesitter_types::tree_sitter::Node<'tree>,
2500 src: &'tree [u8],
2501 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2502 debug_assert_eq!(node.kind(), "formal_parameters");
2503 Ok(Self {
2504 span: ::treesitter_types::Span::from(node),
2505 children: {
2506 #[allow(clippy::suspicious_else_formatting)]
2507 let non_field_children = {
2508 let mut cursor = node.walk();
2509 let mut result = ::std::vec::Vec::new();
2510 if cursor.goto_first_child() {
2511 loop {
2512 if cursor.field_name().is_none()
2513 && cursor.node().is_named()
2514 && !cursor.node().is_extra()
2515 {
2516 result.push(cursor.node());
2517 }
2518 if !cursor.goto_next_sibling() {
2519 break;
2520 }
2521 }
2522 }
2523 result
2524 };
2525 let mut items = ::std::vec::Vec::new();
2526 for child in non_field_children {
2527 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2528 <FormalParametersChildren as ::treesitter_types::FromNode>::from_node(
2529 child, src,
2530 )
2531 })?);
2532 }
2533 items
2534 },
2535 })
2536 }
2537}
2538impl ::treesitter_types::Spanned for FormalParameters<'_> {
2539 fn span(&self) -> ::treesitter_types::Span {
2540 self.span
2541 }
2542}
2543#[derive(Debug, Clone, PartialEq, Eq)]
2544pub struct FunctionDeclaration<'tree> {
2545 pub span: ::treesitter_types::Span,
2546 pub body: StatementBlock<'tree>,
2547 pub name: Identifier<'tree>,
2548 pub parameters: FormalParameters<'tree>,
2549}
2550impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaration<'tree> {
2551 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2552 fn from_node(
2553 node: ::treesitter_types::tree_sitter::Node<'tree>,
2554 src: &'tree [u8],
2555 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2556 debug_assert_eq!(node.kind(), "function_declaration");
2557 Ok(Self {
2558 span: ::treesitter_types::Span::from(node),
2559 body: {
2560 let child = node
2561 .child_by_field_name("body")
2562 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2563 ::treesitter_types::runtime::maybe_grow_stack(|| {
2564 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)
2565 })?
2566 },
2567 name: {
2568 let child = node
2569 .child_by_field_name("name")
2570 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2571 ::treesitter_types::runtime::maybe_grow_stack(|| {
2572 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2573 })?
2574 },
2575 parameters: {
2576 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2577 ::treesitter_types::ParseError::missing_field("parameters", node)
2578 })?;
2579 ::treesitter_types::runtime::maybe_grow_stack(|| {
2580 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
2581 })?
2582 },
2583 })
2584 }
2585}
2586impl ::treesitter_types::Spanned for FunctionDeclaration<'_> {
2587 fn span(&self) -> ::treesitter_types::Span {
2588 self.span
2589 }
2590}
2591#[derive(Debug, Clone, PartialEq, Eq)]
2592pub struct FunctionExpression<'tree> {
2593 pub span: ::treesitter_types::Span,
2594 pub body: StatementBlock<'tree>,
2595 pub name: ::core::option::Option<Identifier<'tree>>,
2596 pub parameters: FormalParameters<'tree>,
2597}
2598impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionExpression<'tree> {
2599 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2600 fn from_node(
2601 node: ::treesitter_types::tree_sitter::Node<'tree>,
2602 src: &'tree [u8],
2603 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2604 debug_assert_eq!(node.kind(), "function_expression");
2605 Ok(Self {
2606 span: ::treesitter_types::Span::from(node),
2607 body: {
2608 let child = node
2609 .child_by_field_name("body")
2610 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2611 ::treesitter_types::runtime::maybe_grow_stack(|| {
2612 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)
2613 })?
2614 },
2615 name: match node.child_by_field_name("name") {
2616 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2617 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2618 })?),
2619 None => None,
2620 },
2621 parameters: {
2622 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2623 ::treesitter_types::ParseError::missing_field("parameters", node)
2624 })?;
2625 ::treesitter_types::runtime::maybe_grow_stack(|| {
2626 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
2627 })?
2628 },
2629 })
2630 }
2631}
2632impl ::treesitter_types::Spanned for FunctionExpression<'_> {
2633 fn span(&self) -> ::treesitter_types::Span {
2634 self.span
2635 }
2636}
2637#[derive(Debug, Clone, PartialEq, Eq)]
2638pub struct GeneratorFunction<'tree> {
2639 pub span: ::treesitter_types::Span,
2640 pub body: StatementBlock<'tree>,
2641 pub name: ::core::option::Option<Identifier<'tree>>,
2642 pub parameters: FormalParameters<'tree>,
2643}
2644impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunction<'tree> {
2645 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2646 fn from_node(
2647 node: ::treesitter_types::tree_sitter::Node<'tree>,
2648 src: &'tree [u8],
2649 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2650 debug_assert_eq!(node.kind(), "generator_function");
2651 Ok(Self {
2652 span: ::treesitter_types::Span::from(node),
2653 body: {
2654 let child = node
2655 .child_by_field_name("body")
2656 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2657 ::treesitter_types::runtime::maybe_grow_stack(|| {
2658 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)
2659 })?
2660 },
2661 name: match node.child_by_field_name("name") {
2662 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2663 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2664 })?),
2665 None => None,
2666 },
2667 parameters: {
2668 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2669 ::treesitter_types::ParseError::missing_field("parameters", node)
2670 })?;
2671 ::treesitter_types::runtime::maybe_grow_stack(|| {
2672 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
2673 })?
2674 },
2675 })
2676 }
2677}
2678impl ::treesitter_types::Spanned for GeneratorFunction<'_> {
2679 fn span(&self) -> ::treesitter_types::Span {
2680 self.span
2681 }
2682}
2683#[derive(Debug, Clone, PartialEq, Eq)]
2684pub struct GeneratorFunctionDeclaration<'tree> {
2685 pub span: ::treesitter_types::Span,
2686 pub body: StatementBlock<'tree>,
2687 pub name: Identifier<'tree>,
2688 pub parameters: FormalParameters<'tree>,
2689}
2690impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunctionDeclaration<'tree> {
2691 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2692 fn from_node(
2693 node: ::treesitter_types::tree_sitter::Node<'tree>,
2694 src: &'tree [u8],
2695 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2696 debug_assert_eq!(node.kind(), "generator_function_declaration");
2697 Ok(Self {
2698 span: ::treesitter_types::Span::from(node),
2699 body: {
2700 let child = node
2701 .child_by_field_name("body")
2702 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2703 ::treesitter_types::runtime::maybe_grow_stack(|| {
2704 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)
2705 })?
2706 },
2707 name: {
2708 let child = node
2709 .child_by_field_name("name")
2710 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2711 ::treesitter_types::runtime::maybe_grow_stack(|| {
2712 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2713 })?
2714 },
2715 parameters: {
2716 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2717 ::treesitter_types::ParseError::missing_field("parameters", node)
2718 })?;
2719 ::treesitter_types::runtime::maybe_grow_stack(|| {
2720 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
2721 })?
2722 },
2723 })
2724 }
2725}
2726impl ::treesitter_types::Spanned for GeneratorFunctionDeclaration<'_> {
2727 fn span(&self) -> ::treesitter_types::Span {
2728 self.span
2729 }
2730}
2731#[derive(Debug, Clone, PartialEq, Eq)]
2732pub struct IfStatement<'tree> {
2733 pub span: ::treesitter_types::Span,
2734 pub alternative: ::core::option::Option<ElseClause<'tree>>,
2735 pub condition: ParenthesizedExpression<'tree>,
2736 pub consequence: Statement<'tree>,
2737}
2738impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
2739 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2740 fn from_node(
2741 node: ::treesitter_types::tree_sitter::Node<'tree>,
2742 src: &'tree [u8],
2743 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2744 debug_assert_eq!(node.kind(), "if_statement");
2745 Ok(Self {
2746 span: ::treesitter_types::Span::from(node),
2747 alternative: match node.child_by_field_name("alternative") {
2748 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2749 <ElseClause as ::treesitter_types::FromNode>::from_node(child, src)
2750 })?),
2751 None => None,
2752 },
2753 condition: {
2754 let child = node.child_by_field_name("condition").ok_or_else(|| {
2755 ::treesitter_types::ParseError::missing_field("condition", node)
2756 })?;
2757 ::treesitter_types::runtime::maybe_grow_stack(|| {
2758 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
2759 })?
2760 },
2761 consequence: {
2762 let child = node.child_by_field_name("consequence").ok_or_else(|| {
2763 ::treesitter_types::ParseError::missing_field("consequence", node)
2764 })?;
2765 ::treesitter_types::runtime::maybe_grow_stack(|| {
2766 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2767 })?
2768 },
2769 })
2770 }
2771}
2772impl ::treesitter_types::Spanned for IfStatement<'_> {
2773 fn span(&self) -> ::treesitter_types::Span {
2774 self.span
2775 }
2776}
2777#[derive(Debug, Clone, PartialEq, Eq)]
2778pub struct Import<'tree> {
2779 pub span: ::treesitter_types::Span,
2780 text: &'tree str,
2781}
2782impl<'tree> ::treesitter_types::FromNode<'tree> for Import<'tree> {
2783 fn from_node(
2784 node: ::treesitter_types::tree_sitter::Node<'tree>,
2785 src: &'tree [u8],
2786 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2787 debug_assert_eq!(node.kind(), "import");
2788 Ok(Self {
2789 span: ::treesitter_types::Span::from(node),
2790 text: node.utf8_text(src)?,
2791 })
2792 }
2793}
2794impl<'tree> ::treesitter_types::LeafNode<'tree> for Import<'tree> {
2795 fn text(&self) -> &'tree str {
2796 self.text
2797 }
2798}
2799impl ::treesitter_types::Spanned for Import<'_> {
2800 fn span(&self) -> ::treesitter_types::Span {
2801 self.span
2802 }
2803}
2804#[derive(Debug, Clone, PartialEq, Eq)]
2805pub struct ImportAttribute<'tree> {
2806 pub span: ::treesitter_types::Span,
2807 pub children: Object<'tree>,
2808}
2809impl<'tree> ::treesitter_types::FromNode<'tree> for ImportAttribute<'tree> {
2810 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2811 fn from_node(
2812 node: ::treesitter_types::tree_sitter::Node<'tree>,
2813 src: &'tree [u8],
2814 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2815 debug_assert_eq!(node.kind(), "import_attribute");
2816 Ok(Self {
2817 span: ::treesitter_types::Span::from(node),
2818 children: {
2819 #[allow(clippy::suspicious_else_formatting)]
2820 let non_field_children = {
2821 let mut cursor = node.walk();
2822 let mut result = ::std::vec::Vec::new();
2823 if cursor.goto_first_child() {
2824 loop {
2825 if cursor.field_name().is_none()
2826 && cursor.node().is_named()
2827 && !cursor.node().is_extra()
2828 {
2829 result.push(cursor.node());
2830 }
2831 if !cursor.goto_next_sibling() {
2832 break;
2833 }
2834 }
2835 }
2836 result
2837 };
2838 let child = if let Some(&c) = non_field_children.first() {
2839 c
2840 } else {
2841 let mut fallback_cursor = node.walk();
2842 let mut fallback_child = None;
2843 if fallback_cursor.goto_first_child() {
2844 loop {
2845 if fallback_cursor.field_name().is_none()
2846 && !fallback_cursor.node().is_extra()
2847 {
2848 let candidate = fallback_cursor.node();
2849 #[allow(clippy::needless_question_mark)]
2850 if (|| -> ::core::result::Result<
2851 _,
2852 ::treesitter_types::ParseError,
2853 > {
2854 let child = candidate;
2855 Ok(
2856 ::treesitter_types::runtime::maybe_grow_stack(|| <Object as ::treesitter_types::FromNode>::from_node(
2857 child,
2858 src,
2859 ))?,
2860 )
2861 })()
2862 .is_ok()
2863 {
2864 fallback_child = Some(candidate);
2865 break;
2866 }
2867 }
2868 if !fallback_cursor.goto_next_sibling() {
2869 break;
2870 }
2871 }
2872 }
2873 if fallback_child.is_none() {
2874 let mut cursor2 = node.walk();
2875 if cursor2.goto_first_child() {
2876 loop {
2877 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2878 let candidate = cursor2.node();
2879 #[allow(clippy::needless_question_mark)]
2880 if (|| -> ::core::result::Result<
2881 _,
2882 ::treesitter_types::ParseError,
2883 > {
2884 let child = candidate;
2885 Ok(
2886 ::treesitter_types::runtime::maybe_grow_stack(|| <Object as ::treesitter_types::FromNode>::from_node(
2887 child,
2888 src,
2889 ))?,
2890 )
2891 })()
2892 .is_ok()
2893 {
2894 fallback_child = Some(candidate);
2895 break;
2896 }
2897 }
2898 if !cursor2.goto_next_sibling() {
2899 break;
2900 }
2901 }
2902 }
2903 }
2904 fallback_child.ok_or_else(|| {
2905 ::treesitter_types::ParseError::missing_field("children", node)
2906 })?
2907 };
2908 ::treesitter_types::runtime::maybe_grow_stack(|| {
2909 <Object as ::treesitter_types::FromNode>::from_node(child, src)
2910 })?
2911 },
2912 })
2913 }
2914}
2915impl ::treesitter_types::Spanned for ImportAttribute<'_> {
2916 fn span(&self) -> ::treesitter_types::Span {
2917 self.span
2918 }
2919}
2920#[derive(Debug, Clone, PartialEq, Eq)]
2921pub struct ImportClause<'tree> {
2922 pub span: ::treesitter_types::Span,
2923 pub children: ::std::vec::Vec<ImportClauseChildren<'tree>>,
2924}
2925impl<'tree> ::treesitter_types::FromNode<'tree> for ImportClause<'tree> {
2926 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2927 fn from_node(
2928 node: ::treesitter_types::tree_sitter::Node<'tree>,
2929 src: &'tree [u8],
2930 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2931 debug_assert_eq!(node.kind(), "import_clause");
2932 Ok(Self {
2933 span: ::treesitter_types::Span::from(node),
2934 children: {
2935 #[allow(clippy::suspicious_else_formatting)]
2936 let non_field_children = {
2937 let mut cursor = node.walk();
2938 let mut result = ::std::vec::Vec::new();
2939 if cursor.goto_first_child() {
2940 loop {
2941 if cursor.field_name().is_none()
2942 && cursor.node().is_named()
2943 && !cursor.node().is_extra()
2944 {
2945 result.push(cursor.node());
2946 }
2947 if !cursor.goto_next_sibling() {
2948 break;
2949 }
2950 }
2951 }
2952 result
2953 };
2954 let mut items = ::std::vec::Vec::new();
2955 for child in non_field_children {
2956 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2957 <ImportClauseChildren as ::treesitter_types::FromNode>::from_node(
2958 child, src,
2959 )
2960 })?);
2961 }
2962 items
2963 },
2964 })
2965 }
2966}
2967impl ::treesitter_types::Spanned for ImportClause<'_> {
2968 fn span(&self) -> ::treesitter_types::Span {
2969 self.span
2970 }
2971}
2972#[derive(Debug, Clone, PartialEq, Eq)]
2973pub struct ImportSpecifier<'tree> {
2974 pub span: ::treesitter_types::Span,
2975 pub alias: ::core::option::Option<Identifier<'tree>>,
2976 pub name: ImportSpecifierName<'tree>,
2977}
2978impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecifier<'tree> {
2979 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2980 fn from_node(
2981 node: ::treesitter_types::tree_sitter::Node<'tree>,
2982 src: &'tree [u8],
2983 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2984 debug_assert_eq!(node.kind(), "import_specifier");
2985 Ok(Self {
2986 span: ::treesitter_types::Span::from(node),
2987 alias: match node.child_by_field_name("alias") {
2988 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2989 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2990 })?),
2991 None => None,
2992 },
2993 name: {
2994 let child = node
2995 .child_by_field_name("name")
2996 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2997 ::treesitter_types::runtime::maybe_grow_stack(|| {
2998 <ImportSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)
2999 })?
3000 },
3001 })
3002 }
3003}
3004impl ::treesitter_types::Spanned for ImportSpecifier<'_> {
3005 fn span(&self) -> ::treesitter_types::Span {
3006 self.span
3007 }
3008}
3009#[derive(Debug, Clone, PartialEq, Eq)]
3010pub struct ImportStatement<'tree> {
3011 pub span: ::treesitter_types::Span,
3012 pub source: String<'tree>,
3013 pub children: ::std::vec::Vec<ImportStatementChildren<'tree>>,
3014}
3015impl<'tree> ::treesitter_types::FromNode<'tree> for ImportStatement<'tree> {
3016 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3017 fn from_node(
3018 node: ::treesitter_types::tree_sitter::Node<'tree>,
3019 src: &'tree [u8],
3020 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3021 debug_assert_eq!(node.kind(), "import_statement");
3022 Ok(Self {
3023 span: ::treesitter_types::Span::from(node),
3024 source: {
3025 let child = node
3026 .child_by_field_name("source")
3027 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("source", node))?;
3028 ::treesitter_types::runtime::maybe_grow_stack(|| {
3029 <String as ::treesitter_types::FromNode>::from_node(child, src)
3030 })?
3031 },
3032 children: {
3033 #[allow(clippy::suspicious_else_formatting)]
3034 let non_field_children = {
3035 let mut cursor = node.walk();
3036 let mut result = ::std::vec::Vec::new();
3037 if cursor.goto_first_child() {
3038 loop {
3039 if cursor.field_name().is_none()
3040 && cursor.node().is_named()
3041 && !cursor.node().is_extra()
3042 {
3043 result.push(cursor.node());
3044 }
3045 if !cursor.goto_next_sibling() {
3046 break;
3047 }
3048 }
3049 }
3050 result
3051 };
3052 let mut items = ::std::vec::Vec::new();
3053 for child in non_field_children {
3054 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3055 <ImportStatementChildren as ::treesitter_types::FromNode>::from_node(
3056 child, src,
3057 )
3058 })?);
3059 }
3060 items
3061 },
3062 })
3063 }
3064}
3065impl ::treesitter_types::Spanned for ImportStatement<'_> {
3066 fn span(&self) -> ::treesitter_types::Span {
3067 self.span
3068 }
3069}
3070#[derive(Debug, Clone, PartialEq, Eq)]
3071pub struct JsxAttribute<'tree> {
3072 pub span: ::treesitter_types::Span,
3073 pub children: ::std::vec::Vec<JsxAttributeChildren<'tree>>,
3074}
3075impl<'tree> ::treesitter_types::FromNode<'tree> for JsxAttribute<'tree> {
3076 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3077 fn from_node(
3078 node: ::treesitter_types::tree_sitter::Node<'tree>,
3079 src: &'tree [u8],
3080 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3081 debug_assert_eq!(node.kind(), "jsx_attribute");
3082 Ok(Self {
3083 span: ::treesitter_types::Span::from(node),
3084 children: {
3085 #[allow(clippy::suspicious_else_formatting)]
3086 let non_field_children = {
3087 let mut cursor = node.walk();
3088 let mut result = ::std::vec::Vec::new();
3089 if cursor.goto_first_child() {
3090 loop {
3091 if cursor.field_name().is_none()
3092 && cursor.node().is_named()
3093 && !cursor.node().is_extra()
3094 {
3095 result.push(cursor.node());
3096 }
3097 if !cursor.goto_next_sibling() {
3098 break;
3099 }
3100 }
3101 }
3102 result
3103 };
3104 let mut items = ::std::vec::Vec::new();
3105 for child in non_field_children {
3106 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3107 <JsxAttributeChildren as ::treesitter_types::FromNode>::from_node(
3108 child, src,
3109 )
3110 })?);
3111 }
3112 items
3113 },
3114 })
3115 }
3116}
3117impl ::treesitter_types::Spanned for JsxAttribute<'_> {
3118 fn span(&self) -> ::treesitter_types::Span {
3119 self.span
3120 }
3121}
3122#[derive(Debug, Clone, PartialEq, Eq)]
3123pub struct JsxClosingElement<'tree> {
3124 pub span: ::treesitter_types::Span,
3125 pub name: ::core::option::Option<JsxClosingElementName<'tree>>,
3126}
3127impl<'tree> ::treesitter_types::FromNode<'tree> for JsxClosingElement<'tree> {
3128 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3129 fn from_node(
3130 node: ::treesitter_types::tree_sitter::Node<'tree>,
3131 src: &'tree [u8],
3132 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3133 debug_assert_eq!(node.kind(), "jsx_closing_element");
3134 Ok(Self {
3135 span: ::treesitter_types::Span::from(node),
3136 name: match node.child_by_field_name("name") {
3137 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3138 <JsxClosingElementName as ::treesitter_types::FromNode>::from_node(child, src)
3139 })?),
3140 None => None,
3141 },
3142 })
3143 }
3144}
3145impl ::treesitter_types::Spanned for JsxClosingElement<'_> {
3146 fn span(&self) -> ::treesitter_types::Span {
3147 self.span
3148 }
3149}
3150#[derive(Debug, Clone, PartialEq, Eq)]
3151pub struct JsxElement<'tree> {
3152 pub span: ::treesitter_types::Span,
3153 pub close_tag: JsxClosingElement<'tree>,
3154 pub open_tag: JsxOpeningElement<'tree>,
3155 pub children: ::std::vec::Vec<JsxElementChildren<'tree>>,
3156}
3157impl<'tree> ::treesitter_types::FromNode<'tree> for JsxElement<'tree> {
3158 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3159 fn from_node(
3160 node: ::treesitter_types::tree_sitter::Node<'tree>,
3161 src: &'tree [u8],
3162 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3163 debug_assert_eq!(node.kind(), "jsx_element");
3164 Ok(Self {
3165 span: ::treesitter_types::Span::from(node),
3166 close_tag: {
3167 let child = node.child_by_field_name("close_tag").ok_or_else(|| {
3168 ::treesitter_types::ParseError::missing_field("close_tag", node)
3169 })?;
3170 ::treesitter_types::runtime::maybe_grow_stack(|| {
3171 <JsxClosingElement as ::treesitter_types::FromNode>::from_node(child, src)
3172 })?
3173 },
3174 open_tag: {
3175 let child = node.child_by_field_name("open_tag").ok_or_else(|| {
3176 ::treesitter_types::ParseError::missing_field("open_tag", node)
3177 })?;
3178 ::treesitter_types::runtime::maybe_grow_stack(|| {
3179 <JsxOpeningElement as ::treesitter_types::FromNode>::from_node(child, src)
3180 })?
3181 },
3182 children: {
3183 #[allow(clippy::suspicious_else_formatting)]
3184 let non_field_children = {
3185 let mut cursor = node.walk();
3186 let mut result = ::std::vec::Vec::new();
3187 if cursor.goto_first_child() {
3188 loop {
3189 if cursor.field_name().is_none()
3190 && cursor.node().is_named()
3191 && !cursor.node().is_extra()
3192 {
3193 result.push(cursor.node());
3194 }
3195 if !cursor.goto_next_sibling() {
3196 break;
3197 }
3198 }
3199 }
3200 result
3201 };
3202 let mut items = ::std::vec::Vec::new();
3203 for child in non_field_children {
3204 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3205 <JsxElementChildren as ::treesitter_types::FromNode>::from_node(child, src)
3206 })?);
3207 }
3208 items
3209 },
3210 })
3211 }
3212}
3213impl ::treesitter_types::Spanned for JsxElement<'_> {
3214 fn span(&self) -> ::treesitter_types::Span {
3215 self.span
3216 }
3217}
3218#[derive(Debug, Clone, PartialEq, Eq)]
3219pub struct JsxExpression<'tree> {
3220 pub span: ::treesitter_types::Span,
3221 pub children: ::core::option::Option<JsxExpressionChildren<'tree>>,
3222}
3223impl<'tree> ::treesitter_types::FromNode<'tree> for JsxExpression<'tree> {
3224 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3225 fn from_node(
3226 node: ::treesitter_types::tree_sitter::Node<'tree>,
3227 src: &'tree [u8],
3228 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3229 debug_assert_eq!(node.kind(), "jsx_expression");
3230 Ok(Self {
3231 span: ::treesitter_types::Span::from(node),
3232 children: {
3233 #[allow(clippy::suspicious_else_formatting)]
3234 let non_field_children = {
3235 let mut cursor = node.walk();
3236 let mut result = ::std::vec::Vec::new();
3237 if cursor.goto_first_child() {
3238 loop {
3239 if cursor.field_name().is_none()
3240 && cursor.node().is_named()
3241 && !cursor.node().is_extra()
3242 {
3243 result.push(cursor.node());
3244 }
3245 if !cursor.goto_next_sibling() {
3246 break;
3247 }
3248 }
3249 }
3250 result
3251 };
3252 match non_field_children.first() {
3253 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3254 <JsxExpressionChildren as ::treesitter_types::FromNode>::from_node(
3255 child, src,
3256 )
3257 })?),
3258 None => None,
3259 }
3260 },
3261 })
3262 }
3263}
3264impl ::treesitter_types::Spanned for JsxExpression<'_> {
3265 fn span(&self) -> ::treesitter_types::Span {
3266 self.span
3267 }
3268}
3269#[derive(Debug, Clone, PartialEq, Eq)]
3270pub struct JsxNamespaceName<'tree> {
3271 pub span: ::treesitter_types::Span,
3272 pub children: ::std::vec::Vec<Identifier<'tree>>,
3273}
3274impl<'tree> ::treesitter_types::FromNode<'tree> for JsxNamespaceName<'tree> {
3275 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3276 fn from_node(
3277 node: ::treesitter_types::tree_sitter::Node<'tree>,
3278 src: &'tree [u8],
3279 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3280 debug_assert_eq!(node.kind(), "jsx_namespace_name");
3281 Ok(Self {
3282 span: ::treesitter_types::Span::from(node),
3283 children: {
3284 #[allow(clippy::suspicious_else_formatting)]
3285 let non_field_children = {
3286 let mut cursor = node.walk();
3287 let mut result = ::std::vec::Vec::new();
3288 if cursor.goto_first_child() {
3289 loop {
3290 if cursor.field_name().is_none()
3291 && cursor.node().is_named()
3292 && !cursor.node().is_extra()
3293 {
3294 result.push(cursor.node());
3295 }
3296 if !cursor.goto_next_sibling() {
3297 break;
3298 }
3299 }
3300 }
3301 result
3302 };
3303 let mut items = ::std::vec::Vec::new();
3304 for child in non_field_children {
3305 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3306 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3307 })?);
3308 }
3309 items
3310 },
3311 })
3312 }
3313}
3314impl ::treesitter_types::Spanned for JsxNamespaceName<'_> {
3315 fn span(&self) -> ::treesitter_types::Span {
3316 self.span
3317 }
3318}
3319#[derive(Debug, Clone, PartialEq, Eq)]
3320pub struct JsxOpeningElement<'tree> {
3321 pub span: ::treesitter_types::Span,
3322 pub attribute: ::std::vec::Vec<JsxOpeningElementAttribute<'tree>>,
3323 pub name: ::core::option::Option<JsxOpeningElementName<'tree>>,
3324}
3325impl<'tree> ::treesitter_types::FromNode<'tree> for JsxOpeningElement<'tree> {
3326 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3327 fn from_node(
3328 node: ::treesitter_types::tree_sitter::Node<'tree>,
3329 src: &'tree [u8],
3330 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3331 debug_assert_eq!(node.kind(), "jsx_opening_element");
3332 Ok(Self {
3333 span: ::treesitter_types::Span::from(node),
3334 attribute: {
3335 let mut cursor = node.walk();
3336 let mut items = ::std::vec::Vec::new();
3337 for child in node.children_by_field_name("attribute", &mut cursor) {
3338 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3339 <JsxOpeningElementAttribute as ::treesitter_types::FromNode>::from_node(
3340 child, src,
3341 )
3342 })?);
3343 }
3344 items
3345 },
3346 name: match node.child_by_field_name("name") {
3347 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3348 <JsxOpeningElementName as ::treesitter_types::FromNode>::from_node(child, src)
3349 })?),
3350 None => None,
3351 },
3352 })
3353 }
3354}
3355impl ::treesitter_types::Spanned for JsxOpeningElement<'_> {
3356 fn span(&self) -> ::treesitter_types::Span {
3357 self.span
3358 }
3359}
3360#[derive(Debug, Clone, PartialEq, Eq)]
3361pub struct JsxSelfClosingElement<'tree> {
3362 pub span: ::treesitter_types::Span,
3363 pub attribute: ::std::vec::Vec<JsxSelfClosingElementAttribute<'tree>>,
3364 pub name: JsxSelfClosingElementName<'tree>,
3365}
3366impl<'tree> ::treesitter_types::FromNode<'tree> for JsxSelfClosingElement<'tree> {
3367 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3368 fn from_node(
3369 node: ::treesitter_types::tree_sitter::Node<'tree>,
3370 src: &'tree [u8],
3371 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3372 debug_assert_eq!(node.kind(), "jsx_self_closing_element");
3373 Ok(Self {
3374 span: ::treesitter_types::Span::from(node),
3375 attribute: {
3376 let mut cursor = node.walk();
3377 let mut items = ::std::vec::Vec::new();
3378 for child in node.children_by_field_name("attribute", &mut cursor) {
3379 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3380 <JsxSelfClosingElementAttribute as ::treesitter_types::FromNode>::from_node(
3381 child, src,
3382 )
3383 })?);
3384 }
3385 items
3386 },
3387 name: {
3388 let child = node
3389 .child_by_field_name("name")
3390 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3391 ::treesitter_types::runtime::maybe_grow_stack(|| {
3392 <JsxSelfClosingElementName as ::treesitter_types::FromNode>::from_node(
3393 child, src,
3394 )
3395 })?
3396 },
3397 })
3398 }
3399}
3400impl ::treesitter_types::Spanned for JsxSelfClosingElement<'_> {
3401 fn span(&self) -> ::treesitter_types::Span {
3402 self.span
3403 }
3404}
3405#[derive(Debug, Clone, PartialEq, Eq)]
3406pub struct LabeledStatement<'tree> {
3407 pub span: ::treesitter_types::Span,
3408 pub body: Statement<'tree>,
3409 pub label: StatementIdentifier<'tree>,
3410}
3411impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
3412 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3413 fn from_node(
3414 node: ::treesitter_types::tree_sitter::Node<'tree>,
3415 src: &'tree [u8],
3416 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3417 debug_assert_eq!(node.kind(), "labeled_statement");
3418 Ok(Self {
3419 span: ::treesitter_types::Span::from(node),
3420 body: {
3421 let child = node
3422 .child_by_field_name("body")
3423 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3424 ::treesitter_types::runtime::maybe_grow_stack(|| {
3425 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3426 })?
3427 },
3428 label: {
3429 let child = node
3430 .child_by_field_name("label")
3431 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
3432 ::treesitter_types::runtime::maybe_grow_stack(|| {
3433 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
3434 })?
3435 },
3436 })
3437 }
3438}
3439impl ::treesitter_types::Spanned for LabeledStatement<'_> {
3440 fn span(&self) -> ::treesitter_types::Span {
3441 self.span
3442 }
3443}
3444#[derive(Debug, Clone, PartialEq, Eq)]
3445pub struct LexicalDeclaration<'tree> {
3446 pub span: ::treesitter_types::Span,
3447 pub kind: LexicalDeclarationKind,
3448 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
3449}
3450impl<'tree> ::treesitter_types::FromNode<'tree> for LexicalDeclaration<'tree> {
3451 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3452 fn from_node(
3453 node: ::treesitter_types::tree_sitter::Node<'tree>,
3454 src: &'tree [u8],
3455 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3456 debug_assert_eq!(node.kind(), "lexical_declaration");
3457 Ok(Self {
3458 span: ::treesitter_types::Span::from(node),
3459 kind: {
3460 let child = node
3461 .child_by_field_name("kind")
3462 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("kind", node))?;
3463 ::treesitter_types::runtime::maybe_grow_stack(|| {
3464 <LexicalDeclarationKind as ::treesitter_types::FromNode>::from_node(child, src)
3465 })?
3466 },
3467 children: {
3468 #[allow(clippy::suspicious_else_formatting)]
3469 let non_field_children = {
3470 let mut cursor = node.walk();
3471 let mut result = ::std::vec::Vec::new();
3472 if cursor.goto_first_child() {
3473 loop {
3474 if cursor.field_name().is_none()
3475 && cursor.node().is_named()
3476 && !cursor.node().is_extra()
3477 {
3478 result.push(cursor.node());
3479 }
3480 if !cursor.goto_next_sibling() {
3481 break;
3482 }
3483 }
3484 }
3485 result
3486 };
3487 let mut items = ::std::vec::Vec::new();
3488 for child in non_field_children {
3489 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3490 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
3491 })?);
3492 }
3493 items
3494 },
3495 })
3496 }
3497}
3498impl ::treesitter_types::Spanned for LexicalDeclaration<'_> {
3499 fn span(&self) -> ::treesitter_types::Span {
3500 self.span
3501 }
3502}
3503#[derive(Debug, Clone, PartialEq, Eq)]
3504pub struct MemberExpression<'tree> {
3505 pub span: ::treesitter_types::Span,
3506 pub object: MemberExpressionObject<'tree>,
3507 pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
3508 pub property: MemberExpressionProperty<'tree>,
3509}
3510impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpression<'tree> {
3511 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3512 fn from_node(
3513 node: ::treesitter_types::tree_sitter::Node<'tree>,
3514 src: &'tree [u8],
3515 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3516 debug_assert_eq!(node.kind(), "member_expression");
3517 Ok(Self {
3518 span: ::treesitter_types::Span::from(node),
3519 object: {
3520 let child = node
3521 .child_by_field_name("object")
3522 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
3523 ::treesitter_types::runtime::maybe_grow_stack(|| {
3524 <MemberExpressionObject as ::treesitter_types::FromNode>::from_node(child, src)
3525 })?
3526 },
3527 optional_chain: match node.child_by_field_name("optional_chain") {
3528 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3529 <OptionalChain as ::treesitter_types::FromNode>::from_node(child, src)
3530 })?),
3531 None => None,
3532 },
3533 property: {
3534 let child = node.child_by_field_name("property").ok_or_else(|| {
3535 ::treesitter_types::ParseError::missing_field("property", node)
3536 })?;
3537 ::treesitter_types::runtime::maybe_grow_stack(|| {
3538 <MemberExpressionProperty as ::treesitter_types::FromNode>::from_node(
3539 child, src,
3540 )
3541 })?
3542 },
3543 })
3544 }
3545}
3546impl ::treesitter_types::Spanned for MemberExpression<'_> {
3547 fn span(&self) -> ::treesitter_types::Span {
3548 self.span
3549 }
3550}
3551#[derive(Debug, Clone, PartialEq, Eq)]
3552pub struct MetaProperty<'tree> {
3553 pub span: ::treesitter_types::Span,
3554 text: &'tree str,
3555}
3556impl<'tree> ::treesitter_types::FromNode<'tree> for MetaProperty<'tree> {
3557 fn from_node(
3558 node: ::treesitter_types::tree_sitter::Node<'tree>,
3559 src: &'tree [u8],
3560 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3561 debug_assert_eq!(node.kind(), "meta_property");
3562 Ok(Self {
3563 span: ::treesitter_types::Span::from(node),
3564 text: node.utf8_text(src)?,
3565 })
3566 }
3567}
3568impl<'tree> ::treesitter_types::LeafNode<'tree> for MetaProperty<'tree> {
3569 fn text(&self) -> &'tree str {
3570 self.text
3571 }
3572}
3573impl ::treesitter_types::Spanned for MetaProperty<'_> {
3574 fn span(&self) -> ::treesitter_types::Span {
3575 self.span
3576 }
3577}
3578#[derive(Debug, Clone, PartialEq, Eq)]
3579pub struct MethodDefinition<'tree> {
3580 pub span: ::treesitter_types::Span,
3581 pub body: StatementBlock<'tree>,
3582 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
3583 pub name: MethodDefinitionName<'tree>,
3584 pub parameters: FormalParameters<'tree>,
3585}
3586impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinition<'tree> {
3587 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3588 fn from_node(
3589 node: ::treesitter_types::tree_sitter::Node<'tree>,
3590 src: &'tree [u8],
3591 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3592 debug_assert_eq!(node.kind(), "method_definition");
3593 Ok(Self {
3594 span: ::treesitter_types::Span::from(node),
3595 body: {
3596 let child = node
3597 .child_by_field_name("body")
3598 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3599 ::treesitter_types::runtime::maybe_grow_stack(|| {
3600 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)
3601 })?
3602 },
3603 decorator: {
3604 let mut cursor = node.walk();
3605 let mut items = ::std::vec::Vec::new();
3606 for child in node.children_by_field_name("decorator", &mut cursor) {
3607 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3608 <Decorator as ::treesitter_types::FromNode>::from_node(child, src)
3609 })?);
3610 }
3611 items
3612 },
3613 name: {
3614 let child = node
3615 .child_by_field_name("name")
3616 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3617 ::treesitter_types::runtime::maybe_grow_stack(|| {
3618 <MethodDefinitionName as ::treesitter_types::FromNode>::from_node(child, src)
3619 })?
3620 },
3621 parameters: {
3622 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3623 ::treesitter_types::ParseError::missing_field("parameters", node)
3624 })?;
3625 ::treesitter_types::runtime::maybe_grow_stack(|| {
3626 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
3627 })?
3628 },
3629 })
3630 }
3631}
3632impl ::treesitter_types::Spanned for MethodDefinition<'_> {
3633 fn span(&self) -> ::treesitter_types::Span {
3634 self.span
3635 }
3636}
3637#[derive(Debug, Clone, PartialEq, Eq)]
3638pub struct NamedImports<'tree> {
3639 pub span: ::treesitter_types::Span,
3640 pub children: ::std::vec::Vec<ImportSpecifier<'tree>>,
3641}
3642impl<'tree> ::treesitter_types::FromNode<'tree> for NamedImports<'tree> {
3643 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3644 fn from_node(
3645 node: ::treesitter_types::tree_sitter::Node<'tree>,
3646 src: &'tree [u8],
3647 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3648 debug_assert_eq!(node.kind(), "named_imports");
3649 Ok(Self {
3650 span: ::treesitter_types::Span::from(node),
3651 children: {
3652 #[allow(clippy::suspicious_else_formatting)]
3653 let non_field_children = {
3654 let mut cursor = node.walk();
3655 let mut result = ::std::vec::Vec::new();
3656 if cursor.goto_first_child() {
3657 loop {
3658 if cursor.field_name().is_none()
3659 && cursor.node().is_named()
3660 && !cursor.node().is_extra()
3661 {
3662 result.push(cursor.node());
3663 }
3664 if !cursor.goto_next_sibling() {
3665 break;
3666 }
3667 }
3668 }
3669 result
3670 };
3671 let mut items = ::std::vec::Vec::new();
3672 for child in non_field_children {
3673 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3674 <ImportSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
3675 })?);
3676 }
3677 items
3678 },
3679 })
3680 }
3681}
3682impl ::treesitter_types::Spanned for NamedImports<'_> {
3683 fn span(&self) -> ::treesitter_types::Span {
3684 self.span
3685 }
3686}
3687#[derive(Debug, Clone, PartialEq, Eq)]
3688pub struct NamespaceExport<'tree> {
3689 pub span: ::treesitter_types::Span,
3690 pub children: ::core::option::Option<NamespaceExportChildren<'tree>>,
3691}
3692impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceExport<'tree> {
3693 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3694 fn from_node(
3695 node: ::treesitter_types::tree_sitter::Node<'tree>,
3696 src: &'tree [u8],
3697 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3698 debug_assert_eq!(node.kind(), "namespace_export");
3699 Ok(Self {
3700 span: ::treesitter_types::Span::from(node),
3701 children: {
3702 #[allow(clippy::suspicious_else_formatting)]
3703 let non_field_children = {
3704 let mut cursor = node.walk();
3705 let mut result = ::std::vec::Vec::new();
3706 if cursor.goto_first_child() {
3707 loop {
3708 if cursor.field_name().is_none()
3709 && cursor.node().is_named()
3710 && !cursor.node().is_extra()
3711 {
3712 result.push(cursor.node());
3713 }
3714 if !cursor.goto_next_sibling() {
3715 break;
3716 }
3717 }
3718 }
3719 result
3720 };
3721 match non_field_children.first() {
3722 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3723 <NamespaceExportChildren as ::treesitter_types::FromNode>::from_node(
3724 child, src,
3725 )
3726 })?),
3727 None => None,
3728 }
3729 },
3730 })
3731 }
3732}
3733impl ::treesitter_types::Spanned for NamespaceExport<'_> {
3734 fn span(&self) -> ::treesitter_types::Span {
3735 self.span
3736 }
3737}
3738#[derive(Debug, Clone, PartialEq, Eq)]
3739pub struct NamespaceImport<'tree> {
3740 pub span: ::treesitter_types::Span,
3741 pub children: Identifier<'tree>,
3742}
3743impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceImport<'tree> {
3744 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3745 fn from_node(
3746 node: ::treesitter_types::tree_sitter::Node<'tree>,
3747 src: &'tree [u8],
3748 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3749 debug_assert_eq!(node.kind(), "namespace_import");
3750 Ok(Self {
3751 span: ::treesitter_types::Span::from(node),
3752 children: {
3753 #[allow(clippy::suspicious_else_formatting)]
3754 let non_field_children = {
3755 let mut cursor = node.walk();
3756 let mut result = ::std::vec::Vec::new();
3757 if cursor.goto_first_child() {
3758 loop {
3759 if cursor.field_name().is_none()
3760 && cursor.node().is_named()
3761 && !cursor.node().is_extra()
3762 {
3763 result.push(cursor.node());
3764 }
3765 if !cursor.goto_next_sibling() {
3766 break;
3767 }
3768 }
3769 }
3770 result
3771 };
3772 let child = if let Some(&c) = non_field_children.first() {
3773 c
3774 } else {
3775 let mut fallback_cursor = node.walk();
3776 let mut fallback_child = None;
3777 if fallback_cursor.goto_first_child() {
3778 loop {
3779 if fallback_cursor.field_name().is_none()
3780 && !fallback_cursor.node().is_extra()
3781 {
3782 let candidate = fallback_cursor.node();
3783 #[allow(clippy::needless_question_mark)]
3784 if (|| -> ::core::result::Result<
3785 _,
3786 ::treesitter_types::ParseError,
3787 > {
3788 let child = candidate;
3789 Ok(
3790 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
3791 child,
3792 src,
3793 ))?,
3794 )
3795 })()
3796 .is_ok()
3797 {
3798 fallback_child = Some(candidate);
3799 break;
3800 }
3801 }
3802 if !fallback_cursor.goto_next_sibling() {
3803 break;
3804 }
3805 }
3806 }
3807 if fallback_child.is_none() {
3808 let mut cursor2 = node.walk();
3809 if cursor2.goto_first_child() {
3810 loop {
3811 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3812 let candidate = cursor2.node();
3813 #[allow(clippy::needless_question_mark)]
3814 if (|| -> ::core::result::Result<
3815 _,
3816 ::treesitter_types::ParseError,
3817 > {
3818 let child = candidate;
3819 Ok(
3820 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
3821 child,
3822 src,
3823 ))?,
3824 )
3825 })()
3826 .is_ok()
3827 {
3828 fallback_child = Some(candidate);
3829 break;
3830 }
3831 }
3832 if !cursor2.goto_next_sibling() {
3833 break;
3834 }
3835 }
3836 }
3837 }
3838 fallback_child.ok_or_else(|| {
3839 ::treesitter_types::ParseError::missing_field("children", node)
3840 })?
3841 };
3842 ::treesitter_types::runtime::maybe_grow_stack(|| {
3843 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3844 })?
3845 },
3846 })
3847 }
3848}
3849impl ::treesitter_types::Spanned for NamespaceImport<'_> {
3850 fn span(&self) -> ::treesitter_types::Span {
3851 self.span
3852 }
3853}
3854#[derive(Debug, Clone, PartialEq, Eq)]
3855pub struct NewExpression<'tree> {
3856 pub span: ::treesitter_types::Span,
3857 pub arguments: ::core::option::Option<Arguments<'tree>>,
3858 pub constructor: NewExpressionConstructor<'tree>,
3859}
3860impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpression<'tree> {
3861 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3862 fn from_node(
3863 node: ::treesitter_types::tree_sitter::Node<'tree>,
3864 src: &'tree [u8],
3865 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3866 debug_assert_eq!(node.kind(), "new_expression");
3867 Ok(Self {
3868 span: ::treesitter_types::Span::from(node),
3869 arguments: match node.child_by_field_name("arguments") {
3870 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3871 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)
3872 })?),
3873 None => None,
3874 },
3875 constructor: {
3876 let child = node.child_by_field_name("constructor").ok_or_else(|| {
3877 ::treesitter_types::ParseError::missing_field("constructor", node)
3878 })?;
3879 ::treesitter_types::runtime::maybe_grow_stack(|| {
3880 <NewExpressionConstructor as ::treesitter_types::FromNode>::from_node(
3881 child, src,
3882 )
3883 })?
3884 },
3885 })
3886 }
3887}
3888impl ::treesitter_types::Spanned for NewExpression<'_> {
3889 fn span(&self) -> ::treesitter_types::Span {
3890 self.span
3891 }
3892}
3893#[derive(Debug, Clone, PartialEq, Eq)]
3894pub struct Object<'tree> {
3895 pub span: ::treesitter_types::Span,
3896 pub children: ::std::vec::Vec<ObjectChildren<'tree>>,
3897}
3898impl<'tree> ::treesitter_types::FromNode<'tree> for Object<'tree> {
3899 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3900 fn from_node(
3901 node: ::treesitter_types::tree_sitter::Node<'tree>,
3902 src: &'tree [u8],
3903 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3904 debug_assert_eq!(node.kind(), "object");
3905 Ok(Self {
3906 span: ::treesitter_types::Span::from(node),
3907 children: {
3908 #[allow(clippy::suspicious_else_formatting)]
3909 let non_field_children = {
3910 let mut cursor = node.walk();
3911 let mut result = ::std::vec::Vec::new();
3912 if cursor.goto_first_child() {
3913 loop {
3914 if cursor.field_name().is_none()
3915 && cursor.node().is_named()
3916 && !cursor.node().is_extra()
3917 {
3918 result.push(cursor.node());
3919 }
3920 if !cursor.goto_next_sibling() {
3921 break;
3922 }
3923 }
3924 }
3925 result
3926 };
3927 let mut items = ::std::vec::Vec::new();
3928 for child in non_field_children {
3929 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3930 <ObjectChildren as ::treesitter_types::FromNode>::from_node(child, src)
3931 })?);
3932 }
3933 items
3934 },
3935 })
3936 }
3937}
3938impl ::treesitter_types::Spanned for Object<'_> {
3939 fn span(&self) -> ::treesitter_types::Span {
3940 self.span
3941 }
3942}
3943#[derive(Debug, Clone, PartialEq, Eq)]
3944pub struct ObjectAssignmentPattern<'tree> {
3945 pub span: ::treesitter_types::Span,
3946 pub left: ObjectAssignmentPatternLeft<'tree>,
3947 pub right: Expression<'tree>,
3948}
3949impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectAssignmentPattern<'tree> {
3950 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3951 fn from_node(
3952 node: ::treesitter_types::tree_sitter::Node<'tree>,
3953 src: &'tree [u8],
3954 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3955 debug_assert_eq!(node.kind(), "object_assignment_pattern");
3956 Ok(Self {
3957 span: ::treesitter_types::Span::from(node),
3958 left: {
3959 let child = node
3960 .child_by_field_name("left")
3961 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
3962 ::treesitter_types::runtime::maybe_grow_stack(|| {
3963 <ObjectAssignmentPatternLeft as ::treesitter_types::FromNode>::from_node(
3964 child, src,
3965 )
3966 })?
3967 },
3968 right: {
3969 let child = node
3970 .child_by_field_name("right")
3971 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
3972 ::treesitter_types::runtime::maybe_grow_stack(|| {
3973 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3974 })?
3975 },
3976 })
3977 }
3978}
3979impl ::treesitter_types::Spanned for ObjectAssignmentPattern<'_> {
3980 fn span(&self) -> ::treesitter_types::Span {
3981 self.span
3982 }
3983}
3984#[derive(Debug, Clone, PartialEq, Eq)]
3985pub struct ObjectPattern<'tree> {
3986 pub span: ::treesitter_types::Span,
3987 pub children: ::std::vec::Vec<ObjectPatternChildren<'tree>>,
3988}
3989impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectPattern<'tree> {
3990 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3991 fn from_node(
3992 node: ::treesitter_types::tree_sitter::Node<'tree>,
3993 src: &'tree [u8],
3994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3995 debug_assert_eq!(node.kind(), "object_pattern");
3996 Ok(Self {
3997 span: ::treesitter_types::Span::from(node),
3998 children: {
3999 #[allow(clippy::suspicious_else_formatting)]
4000 let non_field_children = {
4001 let mut cursor = node.walk();
4002 let mut result = ::std::vec::Vec::new();
4003 if cursor.goto_first_child() {
4004 loop {
4005 if cursor.field_name().is_none()
4006 && cursor.node().is_named()
4007 && !cursor.node().is_extra()
4008 {
4009 result.push(cursor.node());
4010 }
4011 if !cursor.goto_next_sibling() {
4012 break;
4013 }
4014 }
4015 }
4016 result
4017 };
4018 let mut items = ::std::vec::Vec::new();
4019 for child in non_field_children {
4020 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4021 <ObjectPatternChildren as ::treesitter_types::FromNode>::from_node(
4022 child, src,
4023 )
4024 })?);
4025 }
4026 items
4027 },
4028 })
4029 }
4030}
4031impl ::treesitter_types::Spanned for ObjectPattern<'_> {
4032 fn span(&self) -> ::treesitter_types::Span {
4033 self.span
4034 }
4035}
4036#[derive(Debug, Clone, PartialEq, Eq)]
4037pub struct Pair<'tree> {
4038 pub span: ::treesitter_types::Span,
4039 pub key: PairKey<'tree>,
4040 pub value: Expression<'tree>,
4041}
4042impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
4043 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4044 fn from_node(
4045 node: ::treesitter_types::tree_sitter::Node<'tree>,
4046 src: &'tree [u8],
4047 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4048 debug_assert_eq!(node.kind(), "pair");
4049 Ok(Self {
4050 span: ::treesitter_types::Span::from(node),
4051 key: {
4052 let child = node
4053 .child_by_field_name("key")
4054 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
4055 ::treesitter_types::runtime::maybe_grow_stack(|| {
4056 <PairKey as ::treesitter_types::FromNode>::from_node(child, src)
4057 })?
4058 },
4059 value: {
4060 let child = node
4061 .child_by_field_name("value")
4062 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4063 ::treesitter_types::runtime::maybe_grow_stack(|| {
4064 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4065 })?
4066 },
4067 })
4068 }
4069}
4070impl ::treesitter_types::Spanned for Pair<'_> {
4071 fn span(&self) -> ::treesitter_types::Span {
4072 self.span
4073 }
4074}
4075#[derive(Debug, Clone, PartialEq, Eq)]
4076pub struct PairPattern<'tree> {
4077 pub span: ::treesitter_types::Span,
4078 pub key: PairPatternKey<'tree>,
4079 pub value: PairPatternValue<'tree>,
4080}
4081impl<'tree> ::treesitter_types::FromNode<'tree> for PairPattern<'tree> {
4082 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4083 fn from_node(
4084 node: ::treesitter_types::tree_sitter::Node<'tree>,
4085 src: &'tree [u8],
4086 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4087 debug_assert_eq!(node.kind(), "pair_pattern");
4088 Ok(Self {
4089 span: ::treesitter_types::Span::from(node),
4090 key: {
4091 let child = node
4092 .child_by_field_name("key")
4093 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
4094 ::treesitter_types::runtime::maybe_grow_stack(|| {
4095 <PairPatternKey as ::treesitter_types::FromNode>::from_node(child, src)
4096 })?
4097 },
4098 value: {
4099 let child = node
4100 .child_by_field_name("value")
4101 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4102 ::treesitter_types::runtime::maybe_grow_stack(|| {
4103 <PairPatternValue as ::treesitter_types::FromNode>::from_node(child, src)
4104 })?
4105 },
4106 })
4107 }
4108}
4109impl ::treesitter_types::Spanned for PairPattern<'_> {
4110 fn span(&self) -> ::treesitter_types::Span {
4111 self.span
4112 }
4113}
4114#[derive(Debug, Clone, PartialEq, Eq)]
4115pub struct ParenthesizedExpression<'tree> {
4116 pub span: ::treesitter_types::Span,
4117 pub children: ParenthesizedExpressionChildren<'tree>,
4118}
4119impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
4120 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4121 fn from_node(
4122 node: ::treesitter_types::tree_sitter::Node<'tree>,
4123 src: &'tree [u8],
4124 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4125 debug_assert_eq!(node.kind(), "parenthesized_expression");
4126 Ok(Self {
4127 span: ::treesitter_types::Span::from(node),
4128 children: {
4129 #[allow(clippy::suspicious_else_formatting)]
4130 let non_field_children = {
4131 let mut cursor = node.walk();
4132 let mut result = ::std::vec::Vec::new();
4133 if cursor.goto_first_child() {
4134 loop {
4135 if cursor.field_name().is_none()
4136 && cursor.node().is_named()
4137 && !cursor.node().is_extra()
4138 {
4139 result.push(cursor.node());
4140 }
4141 if !cursor.goto_next_sibling() {
4142 break;
4143 }
4144 }
4145 }
4146 result
4147 };
4148 let child = if let Some(&c) = non_field_children.first() {
4149 c
4150 } else {
4151 let mut fallback_cursor = node.walk();
4152 let mut fallback_child = None;
4153 if fallback_cursor.goto_first_child() {
4154 loop {
4155 if fallback_cursor.field_name().is_none()
4156 && !fallback_cursor.node().is_extra()
4157 {
4158 let candidate = fallback_cursor.node();
4159 #[allow(clippy::needless_question_mark)]
4160 if (|| -> ::core::result::Result<
4161 _,
4162 ::treesitter_types::ParseError,
4163 > {
4164 let child = candidate;
4165 Ok(
4166 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
4167 child,
4168 src,
4169 ))?,
4170 )
4171 })()
4172 .is_ok()
4173 {
4174 fallback_child = Some(candidate);
4175 break;
4176 }
4177 }
4178 if !fallback_cursor.goto_next_sibling() {
4179 break;
4180 }
4181 }
4182 }
4183 if fallback_child.is_none() {
4184 let mut cursor2 = node.walk();
4185 if cursor2.goto_first_child() {
4186 loop {
4187 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4188 let candidate = cursor2.node();
4189 #[allow(clippy::needless_question_mark)]
4190 if (|| -> ::core::result::Result<
4191 _,
4192 ::treesitter_types::ParseError,
4193 > {
4194 let child = candidate;
4195 Ok(
4196 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
4197 child,
4198 src,
4199 ))?,
4200 )
4201 })()
4202 .is_ok()
4203 {
4204 fallback_child = Some(candidate);
4205 break;
4206 }
4207 }
4208 if !cursor2.goto_next_sibling() {
4209 break;
4210 }
4211 }
4212 }
4213 }
4214 fallback_child.ok_or_else(|| {
4215 ::treesitter_types::ParseError::missing_field("children", node)
4216 })?
4217 };
4218 ::treesitter_types::runtime::maybe_grow_stack(|| {
4219 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
4220 child, src,
4221 )
4222 })?
4223 },
4224 })
4225 }
4226}
4227impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
4228 fn span(&self) -> ::treesitter_types::Span {
4229 self.span
4230 }
4231}
4232#[derive(Debug, Clone, PartialEq, Eq)]
4233pub struct Program<'tree> {
4234 pub span: ::treesitter_types::Span,
4235 pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
4236}
4237impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
4238 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4239 fn from_node(
4240 node: ::treesitter_types::tree_sitter::Node<'tree>,
4241 src: &'tree [u8],
4242 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4243 debug_assert_eq!(node.kind(), "program");
4244 Ok(Self {
4245 span: ::treesitter_types::Span::from(node),
4246 children: {
4247 #[allow(clippy::suspicious_else_formatting)]
4248 let non_field_children = {
4249 let mut cursor = node.walk();
4250 let mut result = ::std::vec::Vec::new();
4251 if cursor.goto_first_child() {
4252 loop {
4253 if cursor.field_name().is_none()
4254 && cursor.node().is_named()
4255 && !cursor.node().is_extra()
4256 {
4257 result.push(cursor.node());
4258 }
4259 if !cursor.goto_next_sibling() {
4260 break;
4261 }
4262 }
4263 }
4264 result
4265 };
4266 let mut items = ::std::vec::Vec::new();
4267 for child in non_field_children {
4268 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4269 <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)
4270 })?);
4271 }
4272 items
4273 },
4274 })
4275 }
4276}
4277impl ::treesitter_types::Spanned for Program<'_> {
4278 fn span(&self) -> ::treesitter_types::Span {
4279 self.span
4280 }
4281}
4282#[derive(Debug, Clone, PartialEq, Eq)]
4283pub struct Regex<'tree> {
4284 pub span: ::treesitter_types::Span,
4285 pub flags: ::core::option::Option<RegexFlags<'tree>>,
4286 pub pattern: RegexPattern<'tree>,
4287}
4288impl<'tree> ::treesitter_types::FromNode<'tree> for Regex<'tree> {
4289 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4290 fn from_node(
4291 node: ::treesitter_types::tree_sitter::Node<'tree>,
4292 src: &'tree [u8],
4293 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4294 debug_assert_eq!(node.kind(), "regex");
4295 Ok(Self {
4296 span: ::treesitter_types::Span::from(node),
4297 flags: match node.child_by_field_name("flags") {
4298 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4299 <RegexFlags as ::treesitter_types::FromNode>::from_node(child, src)
4300 })?),
4301 None => None,
4302 },
4303 pattern: {
4304 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4305 ::treesitter_types::ParseError::missing_field("pattern", node)
4306 })?;
4307 ::treesitter_types::runtime::maybe_grow_stack(|| {
4308 <RegexPattern as ::treesitter_types::FromNode>::from_node(child, src)
4309 })?
4310 },
4311 })
4312 }
4313}
4314impl ::treesitter_types::Spanned for Regex<'_> {
4315 fn span(&self) -> ::treesitter_types::Span {
4316 self.span
4317 }
4318}
4319#[derive(Debug, Clone, PartialEq, Eq)]
4320pub struct RestPattern<'tree> {
4321 pub span: ::treesitter_types::Span,
4322 pub children: RestPatternChildren<'tree>,
4323}
4324impl<'tree> ::treesitter_types::FromNode<'tree> for RestPattern<'tree> {
4325 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4326 fn from_node(
4327 node: ::treesitter_types::tree_sitter::Node<'tree>,
4328 src: &'tree [u8],
4329 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4330 debug_assert_eq!(node.kind(), "rest_pattern");
4331 Ok(Self {
4332 span: ::treesitter_types::Span::from(node),
4333 children: {
4334 #[allow(clippy::suspicious_else_formatting)]
4335 let non_field_children = {
4336 let mut cursor = node.walk();
4337 let mut result = ::std::vec::Vec::new();
4338 if cursor.goto_first_child() {
4339 loop {
4340 if cursor.field_name().is_none()
4341 && cursor.node().is_named()
4342 && !cursor.node().is_extra()
4343 {
4344 result.push(cursor.node());
4345 }
4346 if !cursor.goto_next_sibling() {
4347 break;
4348 }
4349 }
4350 }
4351 result
4352 };
4353 let child = if let Some(&c) = non_field_children.first() {
4354 c
4355 } else {
4356 let mut fallback_cursor = node.walk();
4357 let mut fallback_child = None;
4358 if fallback_cursor.goto_first_child() {
4359 loop {
4360 if fallback_cursor.field_name().is_none()
4361 && !fallback_cursor.node().is_extra()
4362 {
4363 let candidate = fallback_cursor.node();
4364 #[allow(clippy::needless_question_mark)]
4365 if (|| -> ::core::result::Result<
4366 _,
4367 ::treesitter_types::ParseError,
4368 > {
4369 let child = candidate;
4370 Ok(
4371 ::treesitter_types::runtime::maybe_grow_stack(|| <RestPatternChildren as ::treesitter_types::FromNode>::from_node(
4372 child,
4373 src,
4374 ))?,
4375 )
4376 })()
4377 .is_ok()
4378 {
4379 fallback_child = Some(candidate);
4380 break;
4381 }
4382 }
4383 if !fallback_cursor.goto_next_sibling() {
4384 break;
4385 }
4386 }
4387 }
4388 if fallback_child.is_none() {
4389 let mut cursor2 = node.walk();
4390 if cursor2.goto_first_child() {
4391 loop {
4392 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4393 let candidate = cursor2.node();
4394 #[allow(clippy::needless_question_mark)]
4395 if (|| -> ::core::result::Result<
4396 _,
4397 ::treesitter_types::ParseError,
4398 > {
4399 let child = candidate;
4400 Ok(
4401 ::treesitter_types::runtime::maybe_grow_stack(|| <RestPatternChildren as ::treesitter_types::FromNode>::from_node(
4402 child,
4403 src,
4404 ))?,
4405 )
4406 })()
4407 .is_ok()
4408 {
4409 fallback_child = Some(candidate);
4410 break;
4411 }
4412 }
4413 if !cursor2.goto_next_sibling() {
4414 break;
4415 }
4416 }
4417 }
4418 }
4419 fallback_child.ok_or_else(|| {
4420 ::treesitter_types::ParseError::missing_field("children", node)
4421 })?
4422 };
4423 ::treesitter_types::runtime::maybe_grow_stack(|| {
4424 <RestPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
4425 })?
4426 },
4427 })
4428 }
4429}
4430impl ::treesitter_types::Spanned for RestPattern<'_> {
4431 fn span(&self) -> ::treesitter_types::Span {
4432 self.span
4433 }
4434}
4435#[derive(Debug, Clone, PartialEq, Eq)]
4436pub struct ReturnStatement<'tree> {
4437 pub span: ::treesitter_types::Span,
4438 pub children: ::core::option::Option<ReturnStatementChildren<'tree>>,
4439}
4440impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
4441 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4442 fn from_node(
4443 node: ::treesitter_types::tree_sitter::Node<'tree>,
4444 src: &'tree [u8],
4445 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4446 debug_assert_eq!(node.kind(), "return_statement");
4447 Ok(Self {
4448 span: ::treesitter_types::Span::from(node),
4449 children: {
4450 #[allow(clippy::suspicious_else_formatting)]
4451 let non_field_children = {
4452 let mut cursor = node.walk();
4453 let mut result = ::std::vec::Vec::new();
4454 if cursor.goto_first_child() {
4455 loop {
4456 if cursor.field_name().is_none()
4457 && cursor.node().is_named()
4458 && !cursor.node().is_extra()
4459 {
4460 result.push(cursor.node());
4461 }
4462 if !cursor.goto_next_sibling() {
4463 break;
4464 }
4465 }
4466 }
4467 result
4468 };
4469 match non_field_children.first() {
4470 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4471 <ReturnStatementChildren as ::treesitter_types::FromNode>::from_node(
4472 child, src,
4473 )
4474 })?),
4475 None => None,
4476 }
4477 },
4478 })
4479 }
4480}
4481impl ::treesitter_types::Spanned for ReturnStatement<'_> {
4482 fn span(&self) -> ::treesitter_types::Span {
4483 self.span
4484 }
4485}
4486#[derive(Debug, Clone, PartialEq, Eq)]
4487pub struct SequenceExpression<'tree> {
4488 pub span: ::treesitter_types::Span,
4489 pub children: ::std::vec::Vec<Expression<'tree>>,
4490}
4491impl<'tree> ::treesitter_types::FromNode<'tree> for SequenceExpression<'tree> {
4492 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4493 fn from_node(
4494 node: ::treesitter_types::tree_sitter::Node<'tree>,
4495 src: &'tree [u8],
4496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4497 debug_assert_eq!(node.kind(), "sequence_expression");
4498 Ok(Self {
4499 span: ::treesitter_types::Span::from(node),
4500 children: {
4501 #[allow(clippy::suspicious_else_formatting)]
4502 let non_field_children = {
4503 let mut cursor = node.walk();
4504 let mut result = ::std::vec::Vec::new();
4505 if cursor.goto_first_child() {
4506 loop {
4507 if cursor.field_name().is_none()
4508 && cursor.node().is_named()
4509 && !cursor.node().is_extra()
4510 {
4511 result.push(cursor.node());
4512 }
4513 if !cursor.goto_next_sibling() {
4514 break;
4515 }
4516 }
4517 }
4518 result
4519 };
4520 let mut items = ::std::vec::Vec::new();
4521 for child in non_field_children {
4522 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4523 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4524 })?);
4525 }
4526 items
4527 },
4528 })
4529 }
4530}
4531impl ::treesitter_types::Spanned for SequenceExpression<'_> {
4532 fn span(&self) -> ::treesitter_types::Span {
4533 self.span
4534 }
4535}
4536#[derive(Debug, Clone, PartialEq, Eq)]
4537pub struct SpreadElement<'tree> {
4538 pub span: ::treesitter_types::Span,
4539 pub children: Expression<'tree>,
4540}
4541impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadElement<'tree> {
4542 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4543 fn from_node(
4544 node: ::treesitter_types::tree_sitter::Node<'tree>,
4545 src: &'tree [u8],
4546 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4547 debug_assert_eq!(node.kind(), "spread_element");
4548 Ok(Self {
4549 span: ::treesitter_types::Span::from(node),
4550 children: {
4551 #[allow(clippy::suspicious_else_formatting)]
4552 let non_field_children = {
4553 let mut cursor = node.walk();
4554 let mut result = ::std::vec::Vec::new();
4555 if cursor.goto_first_child() {
4556 loop {
4557 if cursor.field_name().is_none()
4558 && cursor.node().is_named()
4559 && !cursor.node().is_extra()
4560 {
4561 result.push(cursor.node());
4562 }
4563 if !cursor.goto_next_sibling() {
4564 break;
4565 }
4566 }
4567 }
4568 result
4569 };
4570 let child = if let Some(&c) = non_field_children.first() {
4571 c
4572 } else {
4573 let mut fallback_cursor = node.walk();
4574 let mut fallback_child = None;
4575 if fallback_cursor.goto_first_child() {
4576 loop {
4577 if fallback_cursor.field_name().is_none()
4578 && !fallback_cursor.node().is_extra()
4579 {
4580 let candidate = fallback_cursor.node();
4581 #[allow(clippy::needless_question_mark)]
4582 if (|| -> ::core::result::Result<
4583 _,
4584 ::treesitter_types::ParseError,
4585 > {
4586 let child = candidate;
4587 Ok(
4588 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
4589 child,
4590 src,
4591 ))?,
4592 )
4593 })()
4594 .is_ok()
4595 {
4596 fallback_child = Some(candidate);
4597 break;
4598 }
4599 }
4600 if !fallback_cursor.goto_next_sibling() {
4601 break;
4602 }
4603 }
4604 }
4605 if fallback_child.is_none() {
4606 let mut cursor2 = node.walk();
4607 if cursor2.goto_first_child() {
4608 loop {
4609 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4610 let candidate = cursor2.node();
4611 #[allow(clippy::needless_question_mark)]
4612 if (|| -> ::core::result::Result<
4613 _,
4614 ::treesitter_types::ParseError,
4615 > {
4616 let child = candidate;
4617 Ok(
4618 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
4619 child,
4620 src,
4621 ))?,
4622 )
4623 })()
4624 .is_ok()
4625 {
4626 fallback_child = Some(candidate);
4627 break;
4628 }
4629 }
4630 if !cursor2.goto_next_sibling() {
4631 break;
4632 }
4633 }
4634 }
4635 }
4636 fallback_child.ok_or_else(|| {
4637 ::treesitter_types::ParseError::missing_field("children", node)
4638 })?
4639 };
4640 ::treesitter_types::runtime::maybe_grow_stack(|| {
4641 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4642 })?
4643 },
4644 })
4645 }
4646}
4647impl ::treesitter_types::Spanned for SpreadElement<'_> {
4648 fn span(&self) -> ::treesitter_types::Span {
4649 self.span
4650 }
4651}
4652#[derive(Debug, Clone, PartialEq, Eq)]
4653pub struct StatementBlock<'tree> {
4654 pub span: ::treesitter_types::Span,
4655 pub children: ::std::vec::Vec<Statement<'tree>>,
4656}
4657impl<'tree> ::treesitter_types::FromNode<'tree> for StatementBlock<'tree> {
4658 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4659 fn from_node(
4660 node: ::treesitter_types::tree_sitter::Node<'tree>,
4661 src: &'tree [u8],
4662 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4663 debug_assert_eq!(node.kind(), "statement_block");
4664 Ok(Self {
4665 span: ::treesitter_types::Span::from(node),
4666 children: {
4667 #[allow(clippy::suspicious_else_formatting)]
4668 let non_field_children = {
4669 let mut cursor = node.walk();
4670 let mut result = ::std::vec::Vec::new();
4671 if cursor.goto_first_child() {
4672 loop {
4673 if cursor.field_name().is_none()
4674 && cursor.node().is_named()
4675 && !cursor.node().is_extra()
4676 {
4677 result.push(cursor.node());
4678 }
4679 if !cursor.goto_next_sibling() {
4680 break;
4681 }
4682 }
4683 }
4684 result
4685 };
4686 let mut items = ::std::vec::Vec::new();
4687 for child in non_field_children {
4688 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4689 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4690 })?);
4691 }
4692 items
4693 },
4694 })
4695 }
4696}
4697impl ::treesitter_types::Spanned for StatementBlock<'_> {
4698 fn span(&self) -> ::treesitter_types::Span {
4699 self.span
4700 }
4701}
4702#[derive(Debug, Clone, PartialEq, Eq)]
4703pub struct String<'tree> {
4704 pub span: ::treesitter_types::Span,
4705 pub children: ::std::vec::Vec<StringChildren<'tree>>,
4706}
4707impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
4708 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4709 fn from_node(
4710 node: ::treesitter_types::tree_sitter::Node<'tree>,
4711 src: &'tree [u8],
4712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4713 debug_assert_eq!(node.kind(), "string");
4714 Ok(Self {
4715 span: ::treesitter_types::Span::from(node),
4716 children: {
4717 #[allow(clippy::suspicious_else_formatting)]
4718 let non_field_children = {
4719 let mut cursor = node.walk();
4720 let mut result = ::std::vec::Vec::new();
4721 if cursor.goto_first_child() {
4722 loop {
4723 if cursor.field_name().is_none()
4724 && cursor.node().is_named()
4725 && !cursor.node().is_extra()
4726 {
4727 result.push(cursor.node());
4728 }
4729 if !cursor.goto_next_sibling() {
4730 break;
4731 }
4732 }
4733 }
4734 result
4735 };
4736 let mut items = ::std::vec::Vec::new();
4737 for child in non_field_children {
4738 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4739 <StringChildren as ::treesitter_types::FromNode>::from_node(child, src)
4740 })?);
4741 }
4742 items
4743 },
4744 })
4745 }
4746}
4747impl ::treesitter_types::Spanned for String<'_> {
4748 fn span(&self) -> ::treesitter_types::Span {
4749 self.span
4750 }
4751}
4752#[derive(Debug, Clone, PartialEq, Eq)]
4753pub struct SubscriptExpression<'tree> {
4754 pub span: ::treesitter_types::Span,
4755 pub index: SubscriptExpressionIndex<'tree>,
4756 pub object: Expression<'tree>,
4757 pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
4758}
4759impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpression<'tree> {
4760 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4761 fn from_node(
4762 node: ::treesitter_types::tree_sitter::Node<'tree>,
4763 src: &'tree [u8],
4764 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4765 debug_assert_eq!(node.kind(), "subscript_expression");
4766 Ok(Self {
4767 span: ::treesitter_types::Span::from(node),
4768 index: {
4769 let child = node
4770 .child_by_field_name("index")
4771 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("index", node))?;
4772 ::treesitter_types::runtime::maybe_grow_stack(|| {
4773 <SubscriptExpressionIndex as ::treesitter_types::FromNode>::from_node(
4774 child, src,
4775 )
4776 })?
4777 },
4778 object: {
4779 let child = node
4780 .child_by_field_name("object")
4781 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
4782 ::treesitter_types::runtime::maybe_grow_stack(|| {
4783 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4784 })?
4785 },
4786 optional_chain: match node.child_by_field_name("optional_chain") {
4787 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4788 <OptionalChain as ::treesitter_types::FromNode>::from_node(child, src)
4789 })?),
4790 None => None,
4791 },
4792 })
4793 }
4794}
4795impl ::treesitter_types::Spanned for SubscriptExpression<'_> {
4796 fn span(&self) -> ::treesitter_types::Span {
4797 self.span
4798 }
4799}
4800#[derive(Debug, Clone, PartialEq, Eq)]
4801pub struct SwitchBody<'tree> {
4802 pub span: ::treesitter_types::Span,
4803 pub children: ::std::vec::Vec<SwitchBodyChildren<'tree>>,
4804}
4805impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBody<'tree> {
4806 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4807 fn from_node(
4808 node: ::treesitter_types::tree_sitter::Node<'tree>,
4809 src: &'tree [u8],
4810 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4811 debug_assert_eq!(node.kind(), "switch_body");
4812 Ok(Self {
4813 span: ::treesitter_types::Span::from(node),
4814 children: {
4815 #[allow(clippy::suspicious_else_formatting)]
4816 let non_field_children = {
4817 let mut cursor = node.walk();
4818 let mut result = ::std::vec::Vec::new();
4819 if cursor.goto_first_child() {
4820 loop {
4821 if cursor.field_name().is_none()
4822 && cursor.node().is_named()
4823 && !cursor.node().is_extra()
4824 {
4825 result.push(cursor.node());
4826 }
4827 if !cursor.goto_next_sibling() {
4828 break;
4829 }
4830 }
4831 }
4832 result
4833 };
4834 let mut items = ::std::vec::Vec::new();
4835 for child in non_field_children {
4836 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4837 <SwitchBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)
4838 })?);
4839 }
4840 items
4841 },
4842 })
4843 }
4844}
4845impl ::treesitter_types::Spanned for SwitchBody<'_> {
4846 fn span(&self) -> ::treesitter_types::Span {
4847 self.span
4848 }
4849}
4850#[derive(Debug, Clone, PartialEq, Eq)]
4851pub struct SwitchCase<'tree> {
4852 pub span: ::treesitter_types::Span,
4853 pub body: ::std::vec::Vec<Statement<'tree>>,
4854 pub value: SwitchCaseValue<'tree>,
4855}
4856impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchCase<'tree> {
4857 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4858 fn from_node(
4859 node: ::treesitter_types::tree_sitter::Node<'tree>,
4860 src: &'tree [u8],
4861 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4862 debug_assert_eq!(node.kind(), "switch_case");
4863 Ok(Self {
4864 span: ::treesitter_types::Span::from(node),
4865 body: {
4866 let mut cursor = node.walk();
4867 let mut items = ::std::vec::Vec::new();
4868 for child in node.children_by_field_name("body", &mut cursor) {
4869 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4870 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4871 })?);
4872 }
4873 items
4874 },
4875 value: {
4876 let child = node
4877 .child_by_field_name("value")
4878 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4879 ::treesitter_types::runtime::maybe_grow_stack(|| {
4880 <SwitchCaseValue as ::treesitter_types::FromNode>::from_node(child, src)
4881 })?
4882 },
4883 })
4884 }
4885}
4886impl ::treesitter_types::Spanned for SwitchCase<'_> {
4887 fn span(&self) -> ::treesitter_types::Span {
4888 self.span
4889 }
4890}
4891#[derive(Debug, Clone, PartialEq, Eq)]
4892pub struct SwitchDefault<'tree> {
4893 pub span: ::treesitter_types::Span,
4894 pub body: ::std::vec::Vec<Statement<'tree>>,
4895}
4896impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchDefault<'tree> {
4897 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4898 fn from_node(
4899 node: ::treesitter_types::tree_sitter::Node<'tree>,
4900 src: &'tree [u8],
4901 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4902 debug_assert_eq!(node.kind(), "switch_default");
4903 Ok(Self {
4904 span: ::treesitter_types::Span::from(node),
4905 body: {
4906 let mut cursor = node.walk();
4907 let mut items = ::std::vec::Vec::new();
4908 for child in node.children_by_field_name("body", &mut cursor) {
4909 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4910 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4911 })?);
4912 }
4913 items
4914 },
4915 })
4916 }
4917}
4918impl ::treesitter_types::Spanned for SwitchDefault<'_> {
4919 fn span(&self) -> ::treesitter_types::Span {
4920 self.span
4921 }
4922}
4923#[derive(Debug, Clone, PartialEq, Eq)]
4924pub struct SwitchStatement<'tree> {
4925 pub span: ::treesitter_types::Span,
4926 pub body: SwitchBody<'tree>,
4927 pub value: ParenthesizedExpression<'tree>,
4928}
4929impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
4930 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4931 fn from_node(
4932 node: ::treesitter_types::tree_sitter::Node<'tree>,
4933 src: &'tree [u8],
4934 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4935 debug_assert_eq!(node.kind(), "switch_statement");
4936 Ok(Self {
4937 span: ::treesitter_types::Span::from(node),
4938 body: {
4939 let child = node
4940 .child_by_field_name("body")
4941 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4942 ::treesitter_types::runtime::maybe_grow_stack(|| {
4943 <SwitchBody as ::treesitter_types::FromNode>::from_node(child, src)
4944 })?
4945 },
4946 value: {
4947 let child = node
4948 .child_by_field_name("value")
4949 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4950 ::treesitter_types::runtime::maybe_grow_stack(|| {
4951 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
4952 })?
4953 },
4954 })
4955 }
4956}
4957impl ::treesitter_types::Spanned for SwitchStatement<'_> {
4958 fn span(&self) -> ::treesitter_types::Span {
4959 self.span
4960 }
4961}
4962#[derive(Debug, Clone, PartialEq, Eq)]
4963pub struct TemplateString<'tree> {
4964 pub span: ::treesitter_types::Span,
4965 pub children: ::std::vec::Vec<TemplateStringChildren<'tree>>,
4966}
4967impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateString<'tree> {
4968 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4969 fn from_node(
4970 node: ::treesitter_types::tree_sitter::Node<'tree>,
4971 src: &'tree [u8],
4972 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4973 debug_assert_eq!(node.kind(), "template_string");
4974 Ok(Self {
4975 span: ::treesitter_types::Span::from(node),
4976 children: {
4977 #[allow(clippy::suspicious_else_formatting)]
4978 let non_field_children = {
4979 let mut cursor = node.walk();
4980 let mut result = ::std::vec::Vec::new();
4981 if cursor.goto_first_child() {
4982 loop {
4983 if cursor.field_name().is_none()
4984 && cursor.node().is_named()
4985 && !cursor.node().is_extra()
4986 {
4987 result.push(cursor.node());
4988 }
4989 if !cursor.goto_next_sibling() {
4990 break;
4991 }
4992 }
4993 }
4994 result
4995 };
4996 let mut items = ::std::vec::Vec::new();
4997 for child in non_field_children {
4998 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4999 <TemplateStringChildren as ::treesitter_types::FromNode>::from_node(
5000 child, src,
5001 )
5002 })?);
5003 }
5004 items
5005 },
5006 })
5007 }
5008}
5009impl ::treesitter_types::Spanned for TemplateString<'_> {
5010 fn span(&self) -> ::treesitter_types::Span {
5011 self.span
5012 }
5013}
5014#[derive(Debug, Clone, PartialEq, Eq)]
5015pub struct TemplateSubstitution<'tree> {
5016 pub span: ::treesitter_types::Span,
5017 pub children: TemplateSubstitutionChildren<'tree>,
5018}
5019impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateSubstitution<'tree> {
5020 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5021 fn from_node(
5022 node: ::treesitter_types::tree_sitter::Node<'tree>,
5023 src: &'tree [u8],
5024 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5025 debug_assert_eq!(node.kind(), "template_substitution");
5026 Ok(Self {
5027 span: ::treesitter_types::Span::from(node),
5028 children: {
5029 #[allow(clippy::suspicious_else_formatting)]
5030 let non_field_children = {
5031 let mut cursor = node.walk();
5032 let mut result = ::std::vec::Vec::new();
5033 if cursor.goto_first_child() {
5034 loop {
5035 if cursor.field_name().is_none()
5036 && cursor.node().is_named()
5037 && !cursor.node().is_extra()
5038 {
5039 result.push(cursor.node());
5040 }
5041 if !cursor.goto_next_sibling() {
5042 break;
5043 }
5044 }
5045 }
5046 result
5047 };
5048 let child = if let Some(&c) = non_field_children.first() {
5049 c
5050 } else {
5051 let mut fallback_cursor = node.walk();
5052 let mut fallback_child = None;
5053 if fallback_cursor.goto_first_child() {
5054 loop {
5055 if fallback_cursor.field_name().is_none()
5056 && !fallback_cursor.node().is_extra()
5057 {
5058 let candidate = fallback_cursor.node();
5059 #[allow(clippy::needless_question_mark)]
5060 if (|| -> ::core::result::Result<
5061 _,
5062 ::treesitter_types::ParseError,
5063 > {
5064 let child = candidate;
5065 Ok(
5066 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateSubstitutionChildren as ::treesitter_types::FromNode>::from_node(
5067 child,
5068 src,
5069 ))?,
5070 )
5071 })()
5072 .is_ok()
5073 {
5074 fallback_child = Some(candidate);
5075 break;
5076 }
5077 }
5078 if !fallback_cursor.goto_next_sibling() {
5079 break;
5080 }
5081 }
5082 }
5083 if fallback_child.is_none() {
5084 let mut cursor2 = node.walk();
5085 if cursor2.goto_first_child() {
5086 loop {
5087 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5088 let candidate = cursor2.node();
5089 #[allow(clippy::needless_question_mark)]
5090 if (|| -> ::core::result::Result<
5091 _,
5092 ::treesitter_types::ParseError,
5093 > {
5094 let child = candidate;
5095 Ok(
5096 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateSubstitutionChildren as ::treesitter_types::FromNode>::from_node(
5097 child,
5098 src,
5099 ))?,
5100 )
5101 })()
5102 .is_ok()
5103 {
5104 fallback_child = Some(candidate);
5105 break;
5106 }
5107 }
5108 if !cursor2.goto_next_sibling() {
5109 break;
5110 }
5111 }
5112 }
5113 }
5114 fallback_child.ok_or_else(|| {
5115 ::treesitter_types::ParseError::missing_field("children", node)
5116 })?
5117 };
5118 ::treesitter_types::runtime::maybe_grow_stack(|| {
5119 <TemplateSubstitutionChildren as ::treesitter_types::FromNode>::from_node(
5120 child, src,
5121 )
5122 })?
5123 },
5124 })
5125 }
5126}
5127impl ::treesitter_types::Spanned for TemplateSubstitution<'_> {
5128 fn span(&self) -> ::treesitter_types::Span {
5129 self.span
5130 }
5131}
5132#[derive(Debug, Clone, PartialEq, Eq)]
5133pub struct TernaryExpression<'tree> {
5134 pub span: ::treesitter_types::Span,
5135 pub alternative: Expression<'tree>,
5136 pub condition: Expression<'tree>,
5137 pub consequence: Expression<'tree>,
5138}
5139impl<'tree> ::treesitter_types::FromNode<'tree> for TernaryExpression<'tree> {
5140 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5141 fn from_node(
5142 node: ::treesitter_types::tree_sitter::Node<'tree>,
5143 src: &'tree [u8],
5144 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5145 debug_assert_eq!(node.kind(), "ternary_expression");
5146 Ok(Self {
5147 span: ::treesitter_types::Span::from(node),
5148 alternative: {
5149 let child = node.child_by_field_name("alternative").ok_or_else(|| {
5150 ::treesitter_types::ParseError::missing_field("alternative", node)
5151 })?;
5152 ::treesitter_types::runtime::maybe_grow_stack(|| {
5153 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5154 })?
5155 },
5156 condition: {
5157 let child = node.child_by_field_name("condition").ok_or_else(|| {
5158 ::treesitter_types::ParseError::missing_field("condition", node)
5159 })?;
5160 ::treesitter_types::runtime::maybe_grow_stack(|| {
5161 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5162 })?
5163 },
5164 consequence: {
5165 let child = node.child_by_field_name("consequence").ok_or_else(|| {
5166 ::treesitter_types::ParseError::missing_field("consequence", node)
5167 })?;
5168 ::treesitter_types::runtime::maybe_grow_stack(|| {
5169 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5170 })?
5171 },
5172 })
5173 }
5174}
5175impl ::treesitter_types::Spanned for TernaryExpression<'_> {
5176 fn span(&self) -> ::treesitter_types::Span {
5177 self.span
5178 }
5179}
5180#[derive(Debug, Clone, PartialEq, Eq)]
5181pub struct ThrowStatement<'tree> {
5182 pub span: ::treesitter_types::Span,
5183 pub children: ThrowStatementChildren<'tree>,
5184}
5185impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
5186 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5187 fn from_node(
5188 node: ::treesitter_types::tree_sitter::Node<'tree>,
5189 src: &'tree [u8],
5190 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5191 debug_assert_eq!(node.kind(), "throw_statement");
5192 Ok(Self {
5193 span: ::treesitter_types::Span::from(node),
5194 children: {
5195 #[allow(clippy::suspicious_else_formatting)]
5196 let non_field_children = {
5197 let mut cursor = node.walk();
5198 let mut result = ::std::vec::Vec::new();
5199 if cursor.goto_first_child() {
5200 loop {
5201 if cursor.field_name().is_none()
5202 && cursor.node().is_named()
5203 && !cursor.node().is_extra()
5204 {
5205 result.push(cursor.node());
5206 }
5207 if !cursor.goto_next_sibling() {
5208 break;
5209 }
5210 }
5211 }
5212 result
5213 };
5214 let child = if let Some(&c) = non_field_children.first() {
5215 c
5216 } else {
5217 let mut fallback_cursor = node.walk();
5218 let mut fallback_child = None;
5219 if fallback_cursor.goto_first_child() {
5220 loop {
5221 if fallback_cursor.field_name().is_none()
5222 && !fallback_cursor.node().is_extra()
5223 {
5224 let candidate = fallback_cursor.node();
5225 #[allow(clippy::needless_question_mark)]
5226 if (|| -> ::core::result::Result<
5227 _,
5228 ::treesitter_types::ParseError,
5229 > {
5230 let child = candidate;
5231 Ok(
5232 ::treesitter_types::runtime::maybe_grow_stack(|| <ThrowStatementChildren as ::treesitter_types::FromNode>::from_node(
5233 child,
5234 src,
5235 ))?,
5236 )
5237 })()
5238 .is_ok()
5239 {
5240 fallback_child = Some(candidate);
5241 break;
5242 }
5243 }
5244 if !fallback_cursor.goto_next_sibling() {
5245 break;
5246 }
5247 }
5248 }
5249 if fallback_child.is_none() {
5250 let mut cursor2 = node.walk();
5251 if cursor2.goto_first_child() {
5252 loop {
5253 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5254 let candidate = cursor2.node();
5255 #[allow(clippy::needless_question_mark)]
5256 if (|| -> ::core::result::Result<
5257 _,
5258 ::treesitter_types::ParseError,
5259 > {
5260 let child = candidate;
5261 Ok(
5262 ::treesitter_types::runtime::maybe_grow_stack(|| <ThrowStatementChildren as ::treesitter_types::FromNode>::from_node(
5263 child,
5264 src,
5265 ))?,
5266 )
5267 })()
5268 .is_ok()
5269 {
5270 fallback_child = Some(candidate);
5271 break;
5272 }
5273 }
5274 if !cursor2.goto_next_sibling() {
5275 break;
5276 }
5277 }
5278 }
5279 }
5280 fallback_child.ok_or_else(|| {
5281 ::treesitter_types::ParseError::missing_field("children", node)
5282 })?
5283 };
5284 ::treesitter_types::runtime::maybe_grow_stack(|| {
5285 <ThrowStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)
5286 })?
5287 },
5288 })
5289 }
5290}
5291impl ::treesitter_types::Spanned for ThrowStatement<'_> {
5292 fn span(&self) -> ::treesitter_types::Span {
5293 self.span
5294 }
5295}
5296#[derive(Debug, Clone, PartialEq, Eq)]
5297pub struct TryStatement<'tree> {
5298 pub span: ::treesitter_types::Span,
5299 pub body: StatementBlock<'tree>,
5300 pub finalizer: ::core::option::Option<FinallyClause<'tree>>,
5301 pub handler: ::core::option::Option<CatchClause<'tree>>,
5302}
5303impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
5304 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5305 fn from_node(
5306 node: ::treesitter_types::tree_sitter::Node<'tree>,
5307 src: &'tree [u8],
5308 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5309 debug_assert_eq!(node.kind(), "try_statement");
5310 Ok(Self {
5311 span: ::treesitter_types::Span::from(node),
5312 body: {
5313 let child = node
5314 .child_by_field_name("body")
5315 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5316 ::treesitter_types::runtime::maybe_grow_stack(|| {
5317 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)
5318 })?
5319 },
5320 finalizer: match node.child_by_field_name("finalizer") {
5321 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5322 <FinallyClause as ::treesitter_types::FromNode>::from_node(child, src)
5323 })?),
5324 None => None,
5325 },
5326 handler: match node.child_by_field_name("handler") {
5327 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5328 <CatchClause as ::treesitter_types::FromNode>::from_node(child, src)
5329 })?),
5330 None => None,
5331 },
5332 })
5333 }
5334}
5335impl ::treesitter_types::Spanned for TryStatement<'_> {
5336 fn span(&self) -> ::treesitter_types::Span {
5337 self.span
5338 }
5339}
5340#[derive(Debug, Clone, PartialEq, Eq)]
5341pub struct UnaryExpression<'tree> {
5342 pub span: ::treesitter_types::Span,
5343 pub argument: Expression<'tree>,
5344 pub operator: UnaryExpressionOperator,
5345}
5346impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
5347 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5348 fn from_node(
5349 node: ::treesitter_types::tree_sitter::Node<'tree>,
5350 src: &'tree [u8],
5351 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5352 debug_assert_eq!(node.kind(), "unary_expression");
5353 Ok(Self {
5354 span: ::treesitter_types::Span::from(node),
5355 argument: {
5356 let child = node.child_by_field_name("argument").ok_or_else(|| {
5357 ::treesitter_types::ParseError::missing_field("argument", node)
5358 })?;
5359 ::treesitter_types::runtime::maybe_grow_stack(|| {
5360 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5361 })?
5362 },
5363 operator: {
5364 let child = node.child_by_field_name("operator").ok_or_else(|| {
5365 ::treesitter_types::ParseError::missing_field("operator", node)
5366 })?;
5367 ::treesitter_types::runtime::maybe_grow_stack(|| {
5368 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
5369 })?
5370 },
5371 })
5372 }
5373}
5374impl ::treesitter_types::Spanned for UnaryExpression<'_> {
5375 fn span(&self) -> ::treesitter_types::Span {
5376 self.span
5377 }
5378}
5379#[derive(Debug, Clone, PartialEq, Eq)]
5380pub struct UpdateExpression<'tree> {
5381 pub span: ::treesitter_types::Span,
5382 pub argument: Expression<'tree>,
5383 pub operator: UpdateExpressionOperator,
5384}
5385impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
5386 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5387 fn from_node(
5388 node: ::treesitter_types::tree_sitter::Node<'tree>,
5389 src: &'tree [u8],
5390 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5391 debug_assert_eq!(node.kind(), "update_expression");
5392 Ok(Self {
5393 span: ::treesitter_types::Span::from(node),
5394 argument: {
5395 let child = node.child_by_field_name("argument").ok_or_else(|| {
5396 ::treesitter_types::ParseError::missing_field("argument", node)
5397 })?;
5398 ::treesitter_types::runtime::maybe_grow_stack(|| {
5399 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5400 })?
5401 },
5402 operator: {
5403 let child = node.child_by_field_name("operator").ok_or_else(|| {
5404 ::treesitter_types::ParseError::missing_field("operator", node)
5405 })?;
5406 ::treesitter_types::runtime::maybe_grow_stack(|| {
5407 <UpdateExpressionOperator as ::treesitter_types::FromNode>::from_node(
5408 child, src,
5409 )
5410 })?
5411 },
5412 })
5413 }
5414}
5415impl ::treesitter_types::Spanned for UpdateExpression<'_> {
5416 fn span(&self) -> ::treesitter_types::Span {
5417 self.span
5418 }
5419}
5420#[derive(Debug, Clone, PartialEq, Eq)]
5421pub struct UsingDeclaration<'tree> {
5422 pub span: ::treesitter_types::Span,
5423 pub kind: ::std::vec::Vec<UsingDeclarationKind>,
5424 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
5425}
5426impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDeclaration<'tree> {
5427 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5428 fn from_node(
5429 node: ::treesitter_types::tree_sitter::Node<'tree>,
5430 src: &'tree [u8],
5431 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5432 debug_assert_eq!(node.kind(), "using_declaration");
5433 Ok(Self {
5434 span: ::treesitter_types::Span::from(node),
5435 kind: {
5436 let mut cursor = node.walk();
5437 let mut items = ::std::vec::Vec::new();
5438 for child in node.children_by_field_name("kind", &mut cursor) {
5439 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5440 <UsingDeclarationKind as ::treesitter_types::FromNode>::from_node(
5441 child, src,
5442 )
5443 })?);
5444 }
5445 items
5446 },
5447 children: {
5448 #[allow(clippy::suspicious_else_formatting)]
5449 let non_field_children = {
5450 let mut cursor = node.walk();
5451 let mut result = ::std::vec::Vec::new();
5452 if cursor.goto_first_child() {
5453 loop {
5454 if cursor.field_name().is_none()
5455 && cursor.node().is_named()
5456 && !cursor.node().is_extra()
5457 {
5458 result.push(cursor.node());
5459 }
5460 if !cursor.goto_next_sibling() {
5461 break;
5462 }
5463 }
5464 }
5465 result
5466 };
5467 let mut items = ::std::vec::Vec::new();
5468 for child in non_field_children {
5469 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5470 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
5471 })?);
5472 }
5473 items
5474 },
5475 })
5476 }
5477}
5478impl ::treesitter_types::Spanned for UsingDeclaration<'_> {
5479 fn span(&self) -> ::treesitter_types::Span {
5480 self.span
5481 }
5482}
5483#[derive(Debug, Clone, PartialEq, Eq)]
5484pub struct VariableDeclaration<'tree> {
5485 pub span: ::treesitter_types::Span,
5486 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
5487}
5488impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaration<'tree> {
5489 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5490 fn from_node(
5491 node: ::treesitter_types::tree_sitter::Node<'tree>,
5492 src: &'tree [u8],
5493 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5494 debug_assert_eq!(node.kind(), "variable_declaration");
5495 Ok(Self {
5496 span: ::treesitter_types::Span::from(node),
5497 children: {
5498 #[allow(clippy::suspicious_else_formatting)]
5499 let non_field_children = {
5500 let mut cursor = node.walk();
5501 let mut result = ::std::vec::Vec::new();
5502 if cursor.goto_first_child() {
5503 loop {
5504 if cursor.field_name().is_none()
5505 && cursor.node().is_named()
5506 && !cursor.node().is_extra()
5507 {
5508 result.push(cursor.node());
5509 }
5510 if !cursor.goto_next_sibling() {
5511 break;
5512 }
5513 }
5514 }
5515 result
5516 };
5517 let mut items = ::std::vec::Vec::new();
5518 for child in non_field_children {
5519 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5520 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
5521 })?);
5522 }
5523 items
5524 },
5525 })
5526 }
5527}
5528impl ::treesitter_types::Spanned for VariableDeclaration<'_> {
5529 fn span(&self) -> ::treesitter_types::Span {
5530 self.span
5531 }
5532}
5533#[derive(Debug, Clone, PartialEq, Eq)]
5534pub struct VariableDeclarator<'tree> {
5535 pub span: ::treesitter_types::Span,
5536 pub name: VariableDeclaratorName<'tree>,
5537 pub value: ::core::option::Option<Expression<'tree>>,
5538}
5539impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
5540 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5541 fn from_node(
5542 node: ::treesitter_types::tree_sitter::Node<'tree>,
5543 src: &'tree [u8],
5544 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5545 debug_assert_eq!(node.kind(), "variable_declarator");
5546 Ok(Self {
5547 span: ::treesitter_types::Span::from(node),
5548 name: {
5549 let child = node
5550 .child_by_field_name("name")
5551 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5552 ::treesitter_types::runtime::maybe_grow_stack(|| {
5553 <VariableDeclaratorName as ::treesitter_types::FromNode>::from_node(child, src)
5554 })?
5555 },
5556 value: match node.child_by_field_name("value") {
5557 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5558 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5559 })?),
5560 None => None,
5561 },
5562 })
5563 }
5564}
5565impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
5566 fn span(&self) -> ::treesitter_types::Span {
5567 self.span
5568 }
5569}
5570#[derive(Debug, Clone, PartialEq, Eq)]
5571pub struct WhileStatement<'tree> {
5572 pub span: ::treesitter_types::Span,
5573 pub body: Statement<'tree>,
5574 pub condition: ParenthesizedExpression<'tree>,
5575}
5576impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
5577 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5578 fn from_node(
5579 node: ::treesitter_types::tree_sitter::Node<'tree>,
5580 src: &'tree [u8],
5581 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5582 debug_assert_eq!(node.kind(), "while_statement");
5583 Ok(Self {
5584 span: ::treesitter_types::Span::from(node),
5585 body: {
5586 let child = node
5587 .child_by_field_name("body")
5588 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5589 ::treesitter_types::runtime::maybe_grow_stack(|| {
5590 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5591 })?
5592 },
5593 condition: {
5594 let child = node.child_by_field_name("condition").ok_or_else(|| {
5595 ::treesitter_types::ParseError::missing_field("condition", node)
5596 })?;
5597 ::treesitter_types::runtime::maybe_grow_stack(|| {
5598 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
5599 })?
5600 },
5601 })
5602 }
5603}
5604impl ::treesitter_types::Spanned for WhileStatement<'_> {
5605 fn span(&self) -> ::treesitter_types::Span {
5606 self.span
5607 }
5608}
5609#[derive(Debug, Clone, PartialEq, Eq)]
5610pub struct WithStatement<'tree> {
5611 pub span: ::treesitter_types::Span,
5612 pub body: Statement<'tree>,
5613 pub object: ParenthesizedExpression<'tree>,
5614}
5615impl<'tree> ::treesitter_types::FromNode<'tree> for WithStatement<'tree> {
5616 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5617 fn from_node(
5618 node: ::treesitter_types::tree_sitter::Node<'tree>,
5619 src: &'tree [u8],
5620 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5621 debug_assert_eq!(node.kind(), "with_statement");
5622 Ok(Self {
5623 span: ::treesitter_types::Span::from(node),
5624 body: {
5625 let child = node
5626 .child_by_field_name("body")
5627 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5628 ::treesitter_types::runtime::maybe_grow_stack(|| {
5629 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5630 })?
5631 },
5632 object: {
5633 let child = node
5634 .child_by_field_name("object")
5635 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5636 ::treesitter_types::runtime::maybe_grow_stack(|| {
5637 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
5638 })?
5639 },
5640 })
5641 }
5642}
5643impl ::treesitter_types::Spanned for WithStatement<'_> {
5644 fn span(&self) -> ::treesitter_types::Span {
5645 self.span
5646 }
5647}
5648#[derive(Debug, Clone, PartialEq, Eq)]
5649pub struct YieldExpression<'tree> {
5650 pub span: ::treesitter_types::Span,
5651 pub children: ::core::option::Option<Expression<'tree>>,
5652}
5653impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpression<'tree> {
5654 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5655 fn from_node(
5656 node: ::treesitter_types::tree_sitter::Node<'tree>,
5657 src: &'tree [u8],
5658 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5659 debug_assert_eq!(node.kind(), "yield_expression");
5660 Ok(Self {
5661 span: ::treesitter_types::Span::from(node),
5662 children: {
5663 #[allow(clippy::suspicious_else_formatting)]
5664 let non_field_children = {
5665 let mut cursor = node.walk();
5666 let mut result = ::std::vec::Vec::new();
5667 if cursor.goto_first_child() {
5668 loop {
5669 if cursor.field_name().is_none()
5670 && cursor.node().is_named()
5671 && !cursor.node().is_extra()
5672 {
5673 result.push(cursor.node());
5674 }
5675 if !cursor.goto_next_sibling() {
5676 break;
5677 }
5678 }
5679 }
5680 result
5681 };
5682 match non_field_children.first() {
5683 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5684 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5685 })?),
5686 None => None,
5687 }
5688 },
5689 })
5690 }
5691}
5692impl ::treesitter_types::Spanned for YieldExpression<'_> {
5693 fn span(&self) -> ::treesitter_types::Span {
5694 self.span
5695 }
5696}
5697#[derive(Debug, Clone, PartialEq, Eq)]
5698pub struct Comment<'tree> {
5699 pub span: ::treesitter_types::Span,
5700 text: &'tree str,
5701}
5702impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
5703 fn from_node(
5704 node: ::treesitter_types::tree_sitter::Node<'tree>,
5705 src: &'tree [u8],
5706 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5707 debug_assert_eq!(node.kind(), "comment");
5708 Ok(Self {
5709 span: ::treesitter_types::Span::from(node),
5710 text: node.utf8_text(src)?,
5711 })
5712 }
5713}
5714impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
5715 fn text(&self) -> &'tree str {
5716 self.text
5717 }
5718}
5719impl ::treesitter_types::Spanned for Comment<'_> {
5720 fn span(&self) -> ::treesitter_types::Span {
5721 self.span
5722 }
5723}
5724#[derive(Debug, Clone, PartialEq, Eq)]
5725pub struct EscapeSequence<'tree> {
5726 pub span: ::treesitter_types::Span,
5727 text: &'tree str,
5728}
5729impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
5730 fn from_node(
5731 node: ::treesitter_types::tree_sitter::Node<'tree>,
5732 src: &'tree [u8],
5733 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5734 debug_assert_eq!(node.kind(), "escape_sequence");
5735 Ok(Self {
5736 span: ::treesitter_types::Span::from(node),
5737 text: node.utf8_text(src)?,
5738 })
5739 }
5740}
5741impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
5742 fn text(&self) -> &'tree str {
5743 self.text
5744 }
5745}
5746impl ::treesitter_types::Spanned for EscapeSequence<'_> {
5747 fn span(&self) -> ::treesitter_types::Span {
5748 self.span
5749 }
5750}
5751#[derive(Debug, Clone, PartialEq, Eq)]
5752pub struct False<'tree> {
5753 pub span: ::treesitter_types::Span,
5754 text: &'tree str,
5755}
5756impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
5757 fn from_node(
5758 node: ::treesitter_types::tree_sitter::Node<'tree>,
5759 src: &'tree [u8],
5760 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5761 debug_assert_eq!(node.kind(), "false");
5762 Ok(Self {
5763 span: ::treesitter_types::Span::from(node),
5764 text: node.utf8_text(src)?,
5765 })
5766 }
5767}
5768impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
5769 fn text(&self) -> &'tree str {
5770 self.text
5771 }
5772}
5773impl ::treesitter_types::Spanned for False<'_> {
5774 fn span(&self) -> ::treesitter_types::Span {
5775 self.span
5776 }
5777}
5778#[derive(Debug, Clone, PartialEq, Eq)]
5779pub struct HashBangLine<'tree> {
5780 pub span: ::treesitter_types::Span,
5781 text: &'tree str,
5782}
5783impl<'tree> ::treesitter_types::FromNode<'tree> for HashBangLine<'tree> {
5784 fn from_node(
5785 node: ::treesitter_types::tree_sitter::Node<'tree>,
5786 src: &'tree [u8],
5787 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5788 debug_assert_eq!(node.kind(), "hash_bang_line");
5789 Ok(Self {
5790 span: ::treesitter_types::Span::from(node),
5791 text: node.utf8_text(src)?,
5792 })
5793 }
5794}
5795impl<'tree> ::treesitter_types::LeafNode<'tree> for HashBangLine<'tree> {
5796 fn text(&self) -> &'tree str {
5797 self.text
5798 }
5799}
5800impl ::treesitter_types::Spanned for HashBangLine<'_> {
5801 fn span(&self) -> ::treesitter_types::Span {
5802 self.span
5803 }
5804}
5805#[derive(Debug, Clone, PartialEq, Eq)]
5806pub struct HtmlCharacterReference<'tree> {
5807 pub span: ::treesitter_types::Span,
5808 text: &'tree str,
5809}
5810impl<'tree> ::treesitter_types::FromNode<'tree> for HtmlCharacterReference<'tree> {
5811 fn from_node(
5812 node: ::treesitter_types::tree_sitter::Node<'tree>,
5813 src: &'tree [u8],
5814 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5815 debug_assert_eq!(node.kind(), "html_character_reference");
5816 Ok(Self {
5817 span: ::treesitter_types::Span::from(node),
5818 text: node.utf8_text(src)?,
5819 })
5820 }
5821}
5822impl<'tree> ::treesitter_types::LeafNode<'tree> for HtmlCharacterReference<'tree> {
5823 fn text(&self) -> &'tree str {
5824 self.text
5825 }
5826}
5827impl ::treesitter_types::Spanned for HtmlCharacterReference<'_> {
5828 fn span(&self) -> ::treesitter_types::Span {
5829 self.span
5830 }
5831}
5832#[derive(Debug, Clone, PartialEq, Eq)]
5833pub struct HtmlComment<'tree> {
5834 pub span: ::treesitter_types::Span,
5835 text: &'tree str,
5836}
5837impl<'tree> ::treesitter_types::FromNode<'tree> for HtmlComment<'tree> {
5838 fn from_node(
5839 node: ::treesitter_types::tree_sitter::Node<'tree>,
5840 src: &'tree [u8],
5841 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5842 debug_assert_eq!(node.kind(), "html_comment");
5843 Ok(Self {
5844 span: ::treesitter_types::Span::from(node),
5845 text: node.utf8_text(src)?,
5846 })
5847 }
5848}
5849impl<'tree> ::treesitter_types::LeafNode<'tree> for HtmlComment<'tree> {
5850 fn text(&self) -> &'tree str {
5851 self.text
5852 }
5853}
5854impl ::treesitter_types::Spanned for HtmlComment<'_> {
5855 fn span(&self) -> ::treesitter_types::Span {
5856 self.span
5857 }
5858}
5859#[derive(Debug, Clone, PartialEq, Eq)]
5860pub struct Identifier<'tree> {
5861 pub span: ::treesitter_types::Span,
5862 text: &'tree str,
5863}
5864impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
5865 fn from_node(
5866 node: ::treesitter_types::tree_sitter::Node<'tree>,
5867 src: &'tree [u8],
5868 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5869 debug_assert_eq!(node.kind(), "identifier");
5870 Ok(Self {
5871 span: ::treesitter_types::Span::from(node),
5872 text: node.utf8_text(src)?,
5873 })
5874 }
5875}
5876impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
5877 fn text(&self) -> &'tree str {
5878 self.text
5879 }
5880}
5881impl ::treesitter_types::Spanned for Identifier<'_> {
5882 fn span(&self) -> ::treesitter_types::Span {
5883 self.span
5884 }
5885}
5886#[derive(Debug, Clone, PartialEq, Eq)]
5887pub struct JsxText<'tree> {
5888 pub span: ::treesitter_types::Span,
5889 text: &'tree str,
5890}
5891impl<'tree> ::treesitter_types::FromNode<'tree> for JsxText<'tree> {
5892 fn from_node(
5893 node: ::treesitter_types::tree_sitter::Node<'tree>,
5894 src: &'tree [u8],
5895 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5896 debug_assert_eq!(node.kind(), "jsx_text");
5897 Ok(Self {
5898 span: ::treesitter_types::Span::from(node),
5899 text: node.utf8_text(src)?,
5900 })
5901 }
5902}
5903impl<'tree> ::treesitter_types::LeafNode<'tree> for JsxText<'tree> {
5904 fn text(&self) -> &'tree str {
5905 self.text
5906 }
5907}
5908impl ::treesitter_types::Spanned for JsxText<'_> {
5909 fn span(&self) -> ::treesitter_types::Span {
5910 self.span
5911 }
5912}
5913#[derive(Debug, Clone, PartialEq, Eq)]
5914pub struct Null<'tree> {
5915 pub span: ::treesitter_types::Span,
5916 text: &'tree str,
5917}
5918impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
5919 fn from_node(
5920 node: ::treesitter_types::tree_sitter::Node<'tree>,
5921 src: &'tree [u8],
5922 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5923 debug_assert_eq!(node.kind(), "null");
5924 Ok(Self {
5925 span: ::treesitter_types::Span::from(node),
5926 text: node.utf8_text(src)?,
5927 })
5928 }
5929}
5930impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
5931 fn text(&self) -> &'tree str {
5932 self.text
5933 }
5934}
5935impl ::treesitter_types::Spanned for Null<'_> {
5936 fn span(&self) -> ::treesitter_types::Span {
5937 self.span
5938 }
5939}
5940#[derive(Debug, Clone, PartialEq, Eq)]
5941pub struct Number<'tree> {
5942 pub span: ::treesitter_types::Span,
5943 text: &'tree str,
5944}
5945impl<'tree> ::treesitter_types::FromNode<'tree> for Number<'tree> {
5946 fn from_node(
5947 node: ::treesitter_types::tree_sitter::Node<'tree>,
5948 src: &'tree [u8],
5949 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5950 debug_assert_eq!(node.kind(), "number");
5951 Ok(Self {
5952 span: ::treesitter_types::Span::from(node),
5953 text: node.utf8_text(src)?,
5954 })
5955 }
5956}
5957impl<'tree> ::treesitter_types::LeafNode<'tree> for Number<'tree> {
5958 fn text(&self) -> &'tree str {
5959 self.text
5960 }
5961}
5962impl ::treesitter_types::Spanned for Number<'_> {
5963 fn span(&self) -> ::treesitter_types::Span {
5964 self.span
5965 }
5966}
5967#[derive(Debug, Clone, PartialEq, Eq)]
5968pub struct OptionalChain<'tree> {
5969 pub span: ::treesitter_types::Span,
5970 text: &'tree str,
5971}
5972impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalChain<'tree> {
5973 fn from_node(
5974 node: ::treesitter_types::tree_sitter::Node<'tree>,
5975 src: &'tree [u8],
5976 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5977 debug_assert_eq!(node.kind(), "optional_chain");
5978 Ok(Self {
5979 span: ::treesitter_types::Span::from(node),
5980 text: node.utf8_text(src)?,
5981 })
5982 }
5983}
5984impl<'tree> ::treesitter_types::LeafNode<'tree> for OptionalChain<'tree> {
5985 fn text(&self) -> &'tree str {
5986 self.text
5987 }
5988}
5989impl ::treesitter_types::Spanned for OptionalChain<'_> {
5990 fn span(&self) -> ::treesitter_types::Span {
5991 self.span
5992 }
5993}
5994#[derive(Debug, Clone, PartialEq, Eq)]
5995pub struct PrivatePropertyIdentifier<'tree> {
5996 pub span: ::treesitter_types::Span,
5997 text: &'tree str,
5998}
5999impl<'tree> ::treesitter_types::FromNode<'tree> for PrivatePropertyIdentifier<'tree> {
6000 fn from_node(
6001 node: ::treesitter_types::tree_sitter::Node<'tree>,
6002 src: &'tree [u8],
6003 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6004 debug_assert_eq!(node.kind(), "private_property_identifier");
6005 Ok(Self {
6006 span: ::treesitter_types::Span::from(node),
6007 text: node.utf8_text(src)?,
6008 })
6009 }
6010}
6011impl<'tree> ::treesitter_types::LeafNode<'tree> for PrivatePropertyIdentifier<'tree> {
6012 fn text(&self) -> &'tree str {
6013 self.text
6014 }
6015}
6016impl ::treesitter_types::Spanned for PrivatePropertyIdentifier<'_> {
6017 fn span(&self) -> ::treesitter_types::Span {
6018 self.span
6019 }
6020}
6021#[derive(Debug, Clone, PartialEq, Eq)]
6022pub struct PropertyIdentifier<'tree> {
6023 pub span: ::treesitter_types::Span,
6024 text: &'tree str,
6025}
6026impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyIdentifier<'tree> {
6027 fn from_node(
6028 node: ::treesitter_types::tree_sitter::Node<'tree>,
6029 src: &'tree [u8],
6030 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6031 debug_assert_eq!(node.kind(), "property_identifier");
6032 Ok(Self {
6033 span: ::treesitter_types::Span::from(node),
6034 text: node.utf8_text(src)?,
6035 })
6036 }
6037}
6038impl<'tree> ::treesitter_types::LeafNode<'tree> for PropertyIdentifier<'tree> {
6039 fn text(&self) -> &'tree str {
6040 self.text
6041 }
6042}
6043impl ::treesitter_types::Spanned for PropertyIdentifier<'_> {
6044 fn span(&self) -> ::treesitter_types::Span {
6045 self.span
6046 }
6047}
6048#[derive(Debug, Clone, PartialEq, Eq)]
6049pub struct RegexFlags<'tree> {
6050 pub span: ::treesitter_types::Span,
6051 text: &'tree str,
6052}
6053impl<'tree> ::treesitter_types::FromNode<'tree> for RegexFlags<'tree> {
6054 fn from_node(
6055 node: ::treesitter_types::tree_sitter::Node<'tree>,
6056 src: &'tree [u8],
6057 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6058 debug_assert_eq!(node.kind(), "regex_flags");
6059 Ok(Self {
6060 span: ::treesitter_types::Span::from(node),
6061 text: node.utf8_text(src)?,
6062 })
6063 }
6064}
6065impl<'tree> ::treesitter_types::LeafNode<'tree> for RegexFlags<'tree> {
6066 fn text(&self) -> &'tree str {
6067 self.text
6068 }
6069}
6070impl ::treesitter_types::Spanned for RegexFlags<'_> {
6071 fn span(&self) -> ::treesitter_types::Span {
6072 self.span
6073 }
6074}
6075#[derive(Debug, Clone, PartialEq, Eq)]
6076pub struct RegexPattern<'tree> {
6077 pub span: ::treesitter_types::Span,
6078 text: &'tree str,
6079}
6080impl<'tree> ::treesitter_types::FromNode<'tree> for RegexPattern<'tree> {
6081 fn from_node(
6082 node: ::treesitter_types::tree_sitter::Node<'tree>,
6083 src: &'tree [u8],
6084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6085 debug_assert_eq!(node.kind(), "regex_pattern");
6086 Ok(Self {
6087 span: ::treesitter_types::Span::from(node),
6088 text: node.utf8_text(src)?,
6089 })
6090 }
6091}
6092impl<'tree> ::treesitter_types::LeafNode<'tree> for RegexPattern<'tree> {
6093 fn text(&self) -> &'tree str {
6094 self.text
6095 }
6096}
6097impl ::treesitter_types::Spanned for RegexPattern<'_> {
6098 fn span(&self) -> ::treesitter_types::Span {
6099 self.span
6100 }
6101}
6102#[derive(Debug, Clone, PartialEq, Eq)]
6103pub struct ShorthandPropertyIdentifier<'tree> {
6104 pub span: ::treesitter_types::Span,
6105 text: &'tree str,
6106}
6107impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandPropertyIdentifier<'tree> {
6108 fn from_node(
6109 node: ::treesitter_types::tree_sitter::Node<'tree>,
6110 src: &'tree [u8],
6111 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6112 debug_assert_eq!(node.kind(), "shorthand_property_identifier");
6113 Ok(Self {
6114 span: ::treesitter_types::Span::from(node),
6115 text: node.utf8_text(src)?,
6116 })
6117 }
6118}
6119impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandPropertyIdentifier<'tree> {
6120 fn text(&self) -> &'tree str {
6121 self.text
6122 }
6123}
6124impl ::treesitter_types::Spanned for ShorthandPropertyIdentifier<'_> {
6125 fn span(&self) -> ::treesitter_types::Span {
6126 self.span
6127 }
6128}
6129#[derive(Debug, Clone, PartialEq, Eq)]
6130pub struct ShorthandPropertyIdentifierPattern<'tree> {
6131 pub span: ::treesitter_types::Span,
6132 text: &'tree str,
6133}
6134impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandPropertyIdentifierPattern<'tree> {
6135 fn from_node(
6136 node: ::treesitter_types::tree_sitter::Node<'tree>,
6137 src: &'tree [u8],
6138 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6139 debug_assert_eq!(node.kind(), "shorthand_property_identifier_pattern");
6140 Ok(Self {
6141 span: ::treesitter_types::Span::from(node),
6142 text: node.utf8_text(src)?,
6143 })
6144 }
6145}
6146impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandPropertyIdentifierPattern<'tree> {
6147 fn text(&self) -> &'tree str {
6148 self.text
6149 }
6150}
6151impl ::treesitter_types::Spanned for ShorthandPropertyIdentifierPattern<'_> {
6152 fn span(&self) -> ::treesitter_types::Span {
6153 self.span
6154 }
6155}
6156#[derive(Debug, Clone, PartialEq, Eq)]
6157pub struct StatementIdentifier<'tree> {
6158 pub span: ::treesitter_types::Span,
6159 text: &'tree str,
6160}
6161impl<'tree> ::treesitter_types::FromNode<'tree> for StatementIdentifier<'tree> {
6162 fn from_node(
6163 node: ::treesitter_types::tree_sitter::Node<'tree>,
6164 src: &'tree [u8],
6165 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6166 debug_assert_eq!(node.kind(), "statement_identifier");
6167 Ok(Self {
6168 span: ::treesitter_types::Span::from(node),
6169 text: node.utf8_text(src)?,
6170 })
6171 }
6172}
6173impl<'tree> ::treesitter_types::LeafNode<'tree> for StatementIdentifier<'tree> {
6174 fn text(&self) -> &'tree str {
6175 self.text
6176 }
6177}
6178impl ::treesitter_types::Spanned for StatementIdentifier<'_> {
6179 fn span(&self) -> ::treesitter_types::Span {
6180 self.span
6181 }
6182}
6183#[derive(Debug, Clone, PartialEq, Eq)]
6184pub struct StringFragment<'tree> {
6185 pub span: ::treesitter_types::Span,
6186 text: &'tree str,
6187}
6188impl<'tree> ::treesitter_types::FromNode<'tree> for StringFragment<'tree> {
6189 fn from_node(
6190 node: ::treesitter_types::tree_sitter::Node<'tree>,
6191 src: &'tree [u8],
6192 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6193 debug_assert_eq!(node.kind(), "string_fragment");
6194 Ok(Self {
6195 span: ::treesitter_types::Span::from(node),
6196 text: node.utf8_text(src)?,
6197 })
6198 }
6199}
6200impl<'tree> ::treesitter_types::LeafNode<'tree> for StringFragment<'tree> {
6201 fn text(&self) -> &'tree str {
6202 self.text
6203 }
6204}
6205impl ::treesitter_types::Spanned for StringFragment<'_> {
6206 fn span(&self) -> ::treesitter_types::Span {
6207 self.span
6208 }
6209}
6210#[derive(Debug, Clone, PartialEq, Eq)]
6211pub struct Super<'tree> {
6212 pub span: ::treesitter_types::Span,
6213 text: &'tree str,
6214}
6215impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
6216 fn from_node(
6217 node: ::treesitter_types::tree_sitter::Node<'tree>,
6218 src: &'tree [u8],
6219 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6220 debug_assert_eq!(node.kind(), "super");
6221 Ok(Self {
6222 span: ::treesitter_types::Span::from(node),
6223 text: node.utf8_text(src)?,
6224 })
6225 }
6226}
6227impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
6228 fn text(&self) -> &'tree str {
6229 self.text
6230 }
6231}
6232impl ::treesitter_types::Spanned for Super<'_> {
6233 fn span(&self) -> ::treesitter_types::Span {
6234 self.span
6235 }
6236}
6237#[derive(Debug, Clone, PartialEq, Eq)]
6238pub struct This<'tree> {
6239 pub span: ::treesitter_types::Span,
6240 text: &'tree str,
6241}
6242impl<'tree> ::treesitter_types::FromNode<'tree> for This<'tree> {
6243 fn from_node(
6244 node: ::treesitter_types::tree_sitter::Node<'tree>,
6245 src: &'tree [u8],
6246 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6247 debug_assert_eq!(node.kind(), "this");
6248 Ok(Self {
6249 span: ::treesitter_types::Span::from(node),
6250 text: node.utf8_text(src)?,
6251 })
6252 }
6253}
6254impl<'tree> ::treesitter_types::LeafNode<'tree> for This<'tree> {
6255 fn text(&self) -> &'tree str {
6256 self.text
6257 }
6258}
6259impl ::treesitter_types::Spanned for This<'_> {
6260 fn span(&self) -> ::treesitter_types::Span {
6261 self.span
6262 }
6263}
6264#[derive(Debug, Clone, PartialEq, Eq)]
6265pub struct True<'tree> {
6266 pub span: ::treesitter_types::Span,
6267 text: &'tree str,
6268}
6269impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
6270 fn from_node(
6271 node: ::treesitter_types::tree_sitter::Node<'tree>,
6272 src: &'tree [u8],
6273 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6274 debug_assert_eq!(node.kind(), "true");
6275 Ok(Self {
6276 span: ::treesitter_types::Span::from(node),
6277 text: node.utf8_text(src)?,
6278 })
6279 }
6280}
6281impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
6282 fn text(&self) -> &'tree str {
6283 self.text
6284 }
6285}
6286impl ::treesitter_types::Spanned for True<'_> {
6287 fn span(&self) -> ::treesitter_types::Span {
6288 self.span
6289 }
6290}
6291#[derive(Debug, Clone, PartialEq, Eq)]
6292pub struct Undefined<'tree> {
6293 pub span: ::treesitter_types::Span,
6294 text: &'tree str,
6295}
6296impl<'tree> ::treesitter_types::FromNode<'tree> for Undefined<'tree> {
6297 fn from_node(
6298 node: ::treesitter_types::tree_sitter::Node<'tree>,
6299 src: &'tree [u8],
6300 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6301 debug_assert_eq!(node.kind(), "undefined");
6302 Ok(Self {
6303 span: ::treesitter_types::Span::from(node),
6304 text: node.utf8_text(src)?,
6305 })
6306 }
6307}
6308impl<'tree> ::treesitter_types::LeafNode<'tree> for Undefined<'tree> {
6309 fn text(&self) -> &'tree str {
6310 self.text
6311 }
6312}
6313impl ::treesitter_types::Spanned for Undefined<'_> {
6314 fn span(&self) -> ::treesitter_types::Span {
6315 self.span
6316 }
6317}
6318#[derive(Debug, Clone, PartialEq, Eq)]
6319pub enum ArgumentsChildren<'tree> {
6320 Expression(::std::boxed::Box<Expression<'tree>>),
6321 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
6322}
6323impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
6324 #[allow(clippy::collapsible_else_if)]
6325 fn from_node(
6326 node: ::treesitter_types::tree_sitter::Node<'tree>,
6327 src: &'tree [u8],
6328 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6329 match node.kind() {
6330 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
6331 ::treesitter_types::runtime::maybe_grow_stack(|| {
6332 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
6333 })?,
6334 ))),
6335 _other => {
6336 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6337 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
6338 }) {
6339 Ok(Self::Expression(::std::boxed::Box::new(v)))
6340 } else {
6341 Err(::treesitter_types::ParseError::unexpected_kind(
6342 _other, node,
6343 ))
6344 }
6345 }
6346 }
6347 }
6348}
6349impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
6350 fn span(&self) -> ::treesitter_types::Span {
6351 match self {
6352 Self::Expression(inner) => inner.span(),
6353 Self::SpreadElement(inner) => inner.span(),
6354 }
6355 }
6356}
6357#[derive(Debug, Clone, PartialEq, Eq)]
6358pub enum ArrayChildren<'tree> {
6359 Expression(::std::boxed::Box<Expression<'tree>>),
6360 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
6361}
6362impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayChildren<'tree> {
6363 #[allow(clippy::collapsible_else_if)]
6364 fn from_node(
6365 node: ::treesitter_types::tree_sitter::Node<'tree>,
6366 src: &'tree [u8],
6367 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6368 match node.kind() {
6369 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
6370 ::treesitter_types::runtime::maybe_grow_stack(|| {
6371 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
6372 })?,
6373 ))),
6374 _other => {
6375 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6376 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
6377 }) {
6378 Ok(Self::Expression(::std::boxed::Box::new(v)))
6379 } else {
6380 Err(::treesitter_types::ParseError::unexpected_kind(
6381 _other, node,
6382 ))
6383 }
6384 }
6385 }
6386 }
6387}
6388impl ::treesitter_types::Spanned for ArrayChildren<'_> {
6389 fn span(&self) -> ::treesitter_types::Span {
6390 match self {
6391 Self::Expression(inner) => inner.span(),
6392 Self::SpreadElement(inner) => inner.span(),
6393 }
6394 }
6395}
6396#[derive(Debug, Clone, PartialEq, Eq)]
6397pub enum ArrayPatternChildren<'tree> {
6398 AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
6399 Pattern(::std::boxed::Box<Pattern<'tree>>),
6400}
6401impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPatternChildren<'tree> {
6402 #[allow(clippy::collapsible_else_if)]
6403 fn from_node(
6404 node: ::treesitter_types::tree_sitter::Node<'tree>,
6405 src: &'tree [u8],
6406 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6407 match node.kind() {
6408 "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
6409 ::treesitter_types::runtime::maybe_grow_stack(|| {
6410 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
6411 })?,
6412 ))),
6413 _other => {
6414 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6415 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
6416 }) {
6417 Ok(Self::Pattern(::std::boxed::Box::new(v)))
6418 } else {
6419 Err(::treesitter_types::ParseError::unexpected_kind(
6420 _other, node,
6421 ))
6422 }
6423 }
6424 }
6425 }
6426}
6427impl ::treesitter_types::Spanned for ArrayPatternChildren<'_> {
6428 fn span(&self) -> ::treesitter_types::Span {
6429 match self {
6430 Self::AssignmentPattern(inner) => inner.span(),
6431 Self::Pattern(inner) => inner.span(),
6432 }
6433 }
6434}
6435#[derive(Debug, Clone, PartialEq, Eq)]
6436pub enum ArrowFunctionBody<'tree> {
6437 Expression(::std::boxed::Box<Expression<'tree>>),
6438 StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
6439}
6440impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunctionBody<'tree> {
6441 #[allow(clippy::collapsible_else_if)]
6442 fn from_node(
6443 node: ::treesitter_types::tree_sitter::Node<'tree>,
6444 src: &'tree [u8],
6445 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6446 match node.kind() {
6447 "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
6448 ::treesitter_types::runtime::maybe_grow_stack(|| {
6449 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)
6450 })?,
6451 ))),
6452 _other => {
6453 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6454 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
6455 }) {
6456 Ok(Self::Expression(::std::boxed::Box::new(v)))
6457 } else {
6458 Err(::treesitter_types::ParseError::unexpected_kind(
6459 _other, node,
6460 ))
6461 }
6462 }
6463 }
6464 }
6465}
6466impl ::treesitter_types::Spanned for ArrowFunctionBody<'_> {
6467 fn span(&self) -> ::treesitter_types::Span {
6468 match self {
6469 Self::Expression(inner) => inner.span(),
6470 Self::StatementBlock(inner) => inner.span(),
6471 }
6472 }
6473}
6474#[derive(Debug, Clone, PartialEq, Eq)]
6475pub enum AssignmentExpressionLeft<'tree> {
6476 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
6477 Identifier(::std::boxed::Box<Identifier<'tree>>),
6478 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
6479 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
6480 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
6481 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
6482 Undefined(::std::boxed::Box<Undefined<'tree>>),
6483}
6484impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
6485 #[allow(clippy::collapsible_else_if)]
6486 fn from_node(
6487 node: ::treesitter_types::tree_sitter::Node<'tree>,
6488 src: &'tree [u8],
6489 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6490 match node.kind() {
6491 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
6492 ::treesitter_types::runtime::maybe_grow_stack(|| {
6493 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
6494 })?,
6495 ))),
6496 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6497 ::treesitter_types::runtime::maybe_grow_stack(|| {
6498 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
6499 })?,
6500 ))),
6501 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
6502 ::treesitter_types::runtime::maybe_grow_stack(|| {
6503 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
6504 })?,
6505 ))),
6506 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
6507 ::treesitter_types::runtime::maybe_grow_stack(|| {
6508 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
6509 })?,
6510 ))),
6511 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
6512 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
6513 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
6514 })?),
6515 )),
6516 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
6517 ::treesitter_types::runtime::maybe_grow_stack(|| {
6518 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
6519 })?,
6520 ))),
6521 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
6522 ::treesitter_types::runtime::maybe_grow_stack(|| {
6523 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)
6524 })?,
6525 ))),
6526 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6527 }
6528 }
6529}
6530impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
6531 fn span(&self) -> ::treesitter_types::Span {
6532 match self {
6533 Self::ArrayPattern(inner) => inner.span(),
6534 Self::Identifier(inner) => inner.span(),
6535 Self::MemberExpression(inner) => inner.span(),
6536 Self::ObjectPattern(inner) => inner.span(),
6537 Self::ParenthesizedExpression(inner) => inner.span(),
6538 Self::SubscriptExpression(inner) => inner.span(),
6539 Self::Undefined(inner) => inner.span(),
6540 }
6541 }
6542}
6543#[derive(Debug, Clone, PartialEq, Eq)]
6544pub enum AugmentedAssignmentExpressionLeft<'tree> {
6545 Identifier(::std::boxed::Box<Identifier<'tree>>),
6546 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
6547 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
6548 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
6549}
6550impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionLeft<'tree> {
6551 #[allow(clippy::collapsible_else_if)]
6552 fn from_node(
6553 node: ::treesitter_types::tree_sitter::Node<'tree>,
6554 src: &'tree [u8],
6555 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6556 match node.kind() {
6557 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6558 ::treesitter_types::runtime::maybe_grow_stack(|| {
6559 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
6560 })?,
6561 ))),
6562 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
6563 ::treesitter_types::runtime::maybe_grow_stack(|| {
6564 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
6565 })?,
6566 ))),
6567 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
6568 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
6569 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
6570 })?),
6571 )),
6572 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
6573 ::treesitter_types::runtime::maybe_grow_stack(|| {
6574 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
6575 })?,
6576 ))),
6577 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6578 }
6579 }
6580}
6581impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionLeft<'_> {
6582 fn span(&self) -> ::treesitter_types::Span {
6583 match self {
6584 Self::Identifier(inner) => inner.span(),
6585 Self::MemberExpression(inner) => inner.span(),
6586 Self::ParenthesizedExpression(inner) => inner.span(),
6587 Self::SubscriptExpression(inner) => inner.span(),
6588 }
6589 }
6590}
6591#[derive(Debug, Clone, PartialEq, Eq)]
6592pub enum AugmentedAssignmentExpressionOperator {
6593 PercentEq(::treesitter_types::Span),
6594 AmpAmpEq(::treesitter_types::Span),
6595 AmpEq(::treesitter_types::Span),
6596 StarStarEq(::treesitter_types::Span),
6597 StarEq(::treesitter_types::Span),
6598 PlusEq(::treesitter_types::Span),
6599 MinusEq(::treesitter_types::Span),
6600 SlashEq(::treesitter_types::Span),
6601 ShlEq(::treesitter_types::Span),
6602 ShrEq(::treesitter_types::Span),
6603 GtGtGtEq(::treesitter_types::Span),
6604 QuestionQuestionEq(::treesitter_types::Span),
6605 CaretEq(::treesitter_types::Span),
6606 PipeEq(::treesitter_types::Span),
6607 PipePipeEq(::treesitter_types::Span),
6608}
6609impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionOperator {
6610 #[allow(clippy::collapsible_else_if)]
6611 fn from_node(
6612 node: ::treesitter_types::tree_sitter::Node<'tree>,
6613 _src: &'tree [u8],
6614 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6615 match node.kind() {
6616 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
6617 "&&=" => Ok(Self::AmpAmpEq(::treesitter_types::Span::from(node))),
6618 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
6619 "**=" => Ok(Self::StarStarEq(::treesitter_types::Span::from(node))),
6620 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
6621 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
6622 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
6623 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
6624 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
6625 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
6626 ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
6627 "??=" => Ok(Self::QuestionQuestionEq(::treesitter_types::Span::from(
6628 node,
6629 ))),
6630 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
6631 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
6632 "||=" => Ok(Self::PipePipeEq(::treesitter_types::Span::from(node))),
6633 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6634 }
6635 }
6636}
6637impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionOperator {
6638 fn span(&self) -> ::treesitter_types::Span {
6639 match self {
6640 Self::PercentEq(span) => *span,
6641 Self::AmpAmpEq(span) => *span,
6642 Self::AmpEq(span) => *span,
6643 Self::StarStarEq(span) => *span,
6644 Self::StarEq(span) => *span,
6645 Self::PlusEq(span) => *span,
6646 Self::MinusEq(span) => *span,
6647 Self::SlashEq(span) => *span,
6648 Self::ShlEq(span) => *span,
6649 Self::ShrEq(span) => *span,
6650 Self::GtGtGtEq(span) => *span,
6651 Self::QuestionQuestionEq(span) => *span,
6652 Self::CaretEq(span) => *span,
6653 Self::PipeEq(span) => *span,
6654 Self::PipePipeEq(span) => *span,
6655 }
6656 }
6657}
6658#[derive(Debug, Clone, PartialEq, Eq)]
6659pub enum BinaryExpressionLeft<'tree> {
6660 Expression(::std::boxed::Box<Expression<'tree>>),
6661 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
6662}
6663impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
6664 #[allow(clippy::collapsible_else_if)]
6665 fn from_node(
6666 node: ::treesitter_types::tree_sitter::Node<'tree>,
6667 src: &'tree [u8],
6668 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6669 match node.kind() {
6670 "private_property_identifier" => Ok(Self::PrivatePropertyIdentifier(
6671 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
6672 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
6673 node, src,
6674 )
6675 })?),
6676 )),
6677 _other => {
6678 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6679 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
6680 }) {
6681 Ok(Self::Expression(::std::boxed::Box::new(v)))
6682 } else {
6683 Err(::treesitter_types::ParseError::unexpected_kind(
6684 _other, node,
6685 ))
6686 }
6687 }
6688 }
6689 }
6690}
6691impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
6692 fn span(&self) -> ::treesitter_types::Span {
6693 match self {
6694 Self::Expression(inner) => inner.span(),
6695 Self::PrivatePropertyIdentifier(inner) => inner.span(),
6696 }
6697 }
6698}
6699#[derive(Debug, Clone, PartialEq, Eq)]
6700pub enum BinaryExpressionOperator {
6701 NotEq(::treesitter_types::Span),
6702 BangEqEq(::treesitter_types::Span),
6703 Percent(::treesitter_types::Span),
6704 Amp(::treesitter_types::Span),
6705 AmpAmp(::treesitter_types::Span),
6706 Star(::treesitter_types::Span),
6707 StarStar(::treesitter_types::Span),
6708 Plus(::treesitter_types::Span),
6709 Minus(::treesitter_types::Span),
6710 Slash(::treesitter_types::Span),
6711 Lt(::treesitter_types::Span),
6712 Shl(::treesitter_types::Span),
6713 LtEq(::treesitter_types::Span),
6714 EqEq(::treesitter_types::Span),
6715 EqEqEq(::treesitter_types::Span),
6716 Gt(::treesitter_types::Span),
6717 GtEq(::treesitter_types::Span),
6718 Shr(::treesitter_types::Span),
6719 GtGtGt(::treesitter_types::Span),
6720 QuestionQuestion(::treesitter_types::Span),
6721 Caret(::treesitter_types::Span),
6722 In(::treesitter_types::Span),
6723 Instanceof(::treesitter_types::Span),
6724 Pipe(::treesitter_types::Span),
6725 PipePipe(::treesitter_types::Span),
6726}
6727impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
6728 #[allow(clippy::collapsible_else_if)]
6729 fn from_node(
6730 node: ::treesitter_types::tree_sitter::Node<'tree>,
6731 _src: &'tree [u8],
6732 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6733 match node.kind() {
6734 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
6735 "!==" => Ok(Self::BangEqEq(::treesitter_types::Span::from(node))),
6736 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
6737 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
6738 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
6739 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
6740 "**" => Ok(Self::StarStar(::treesitter_types::Span::from(node))),
6741 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
6742 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
6743 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
6744 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
6745 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
6746 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
6747 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
6748 "===" => Ok(Self::EqEqEq(::treesitter_types::Span::from(node))),
6749 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
6750 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
6751 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
6752 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
6753 "??" => Ok(Self::QuestionQuestion(::treesitter_types::Span::from(node))),
6754 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
6755 "in" => Ok(Self::In(::treesitter_types::Span::from(node))),
6756 "instanceof" => Ok(Self::Instanceof(::treesitter_types::Span::from(node))),
6757 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
6758 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
6759 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6760 }
6761 }
6762}
6763impl ::treesitter_types::Spanned for BinaryExpressionOperator {
6764 fn span(&self) -> ::treesitter_types::Span {
6765 match self {
6766 Self::NotEq(span) => *span,
6767 Self::BangEqEq(span) => *span,
6768 Self::Percent(span) => *span,
6769 Self::Amp(span) => *span,
6770 Self::AmpAmp(span) => *span,
6771 Self::Star(span) => *span,
6772 Self::StarStar(span) => *span,
6773 Self::Plus(span) => *span,
6774 Self::Minus(span) => *span,
6775 Self::Slash(span) => *span,
6776 Self::Lt(span) => *span,
6777 Self::Shl(span) => *span,
6778 Self::LtEq(span) => *span,
6779 Self::EqEq(span) => *span,
6780 Self::EqEqEq(span) => *span,
6781 Self::Gt(span) => *span,
6782 Self::GtEq(span) => *span,
6783 Self::Shr(span) => *span,
6784 Self::GtGtGt(span) => *span,
6785 Self::QuestionQuestion(span) => *span,
6786 Self::Caret(span) => *span,
6787 Self::In(span) => *span,
6788 Self::Instanceof(span) => *span,
6789 Self::Pipe(span) => *span,
6790 Self::PipePipe(span) => *span,
6791 }
6792 }
6793}
6794#[derive(Debug, Clone, PartialEq, Eq)]
6795pub enum CallExpressionArguments<'tree> {
6796 Arguments(::std::boxed::Box<Arguments<'tree>>),
6797 TemplateString(::std::boxed::Box<TemplateString<'tree>>),
6798}
6799impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionArguments<'tree> {
6800 #[allow(clippy::collapsible_else_if)]
6801 fn from_node(
6802 node: ::treesitter_types::tree_sitter::Node<'tree>,
6803 src: &'tree [u8],
6804 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6805 match node.kind() {
6806 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
6807 ::treesitter_types::runtime::maybe_grow_stack(|| {
6808 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
6809 })?,
6810 ))),
6811 "template_string" => Ok(Self::TemplateString(::std::boxed::Box::new(
6812 ::treesitter_types::runtime::maybe_grow_stack(|| {
6813 <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)
6814 })?,
6815 ))),
6816 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6817 }
6818 }
6819}
6820impl ::treesitter_types::Spanned for CallExpressionArguments<'_> {
6821 fn span(&self) -> ::treesitter_types::Span {
6822 match self {
6823 Self::Arguments(inner) => inner.span(),
6824 Self::TemplateString(inner) => inner.span(),
6825 }
6826 }
6827}
6828#[derive(Debug, Clone, PartialEq, Eq)]
6829pub enum CallExpressionFunction<'tree> {
6830 Expression(::std::boxed::Box<Expression<'tree>>),
6831 Import(::std::boxed::Box<Import<'tree>>),
6832}
6833impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionFunction<'tree> {
6834 #[allow(clippy::collapsible_else_if)]
6835 fn from_node(
6836 node: ::treesitter_types::tree_sitter::Node<'tree>,
6837 src: &'tree [u8],
6838 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6839 match node.kind() {
6840 "import" => Ok(Self::Import(::std::boxed::Box::new(
6841 ::treesitter_types::runtime::maybe_grow_stack(|| {
6842 <Import as ::treesitter_types::FromNode>::from_node(node, src)
6843 })?,
6844 ))),
6845 _other => {
6846 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6847 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
6848 }) {
6849 Ok(Self::Expression(::std::boxed::Box::new(v)))
6850 } else {
6851 Err(::treesitter_types::ParseError::unexpected_kind(
6852 _other, node,
6853 ))
6854 }
6855 }
6856 }
6857 }
6858}
6859impl ::treesitter_types::Spanned for CallExpressionFunction<'_> {
6860 fn span(&self) -> ::treesitter_types::Span {
6861 match self {
6862 Self::Expression(inner) => inner.span(),
6863 Self::Import(inner) => inner.span(),
6864 }
6865 }
6866}
6867#[derive(Debug, Clone, PartialEq, Eq)]
6868pub enum CatchClauseParameter<'tree> {
6869 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
6870 Identifier(::std::boxed::Box<Identifier<'tree>>),
6871 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
6872}
6873impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClauseParameter<'tree> {
6874 #[allow(clippy::collapsible_else_if)]
6875 fn from_node(
6876 node: ::treesitter_types::tree_sitter::Node<'tree>,
6877 src: &'tree [u8],
6878 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6879 match node.kind() {
6880 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
6881 ::treesitter_types::runtime::maybe_grow_stack(|| {
6882 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
6883 })?,
6884 ))),
6885 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6886 ::treesitter_types::runtime::maybe_grow_stack(|| {
6887 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
6888 })?,
6889 ))),
6890 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
6891 ::treesitter_types::runtime::maybe_grow_stack(|| {
6892 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
6893 })?,
6894 ))),
6895 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6896 }
6897 }
6898}
6899impl ::treesitter_types::Spanned for CatchClauseParameter<'_> {
6900 fn span(&self) -> ::treesitter_types::Span {
6901 match self {
6902 Self::ArrayPattern(inner) => inner.span(),
6903 Self::Identifier(inner) => inner.span(),
6904 Self::ObjectPattern(inner) => inner.span(),
6905 }
6906 }
6907}
6908#[derive(Debug, Clone, PartialEq, Eq)]
6909pub enum ClassBodyMember<'tree> {
6910 ClassStaticBlock(::std::boxed::Box<ClassStaticBlock<'tree>>),
6911 FieldDefinition(::std::boxed::Box<FieldDefinition<'tree>>),
6912 MethodDefinition(::std::boxed::Box<MethodDefinition<'tree>>),
6913}
6914impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBodyMember<'tree> {
6915 #[allow(clippy::collapsible_else_if)]
6916 fn from_node(
6917 node: ::treesitter_types::tree_sitter::Node<'tree>,
6918 src: &'tree [u8],
6919 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6920 match node.kind() {
6921 "class_static_block" => Ok(Self::ClassStaticBlock(::std::boxed::Box::new(
6922 ::treesitter_types::runtime::maybe_grow_stack(|| {
6923 <ClassStaticBlock as ::treesitter_types::FromNode>::from_node(node, src)
6924 })?,
6925 ))),
6926 "field_definition" => Ok(Self::FieldDefinition(::std::boxed::Box::new(
6927 ::treesitter_types::runtime::maybe_grow_stack(|| {
6928 <FieldDefinition as ::treesitter_types::FromNode>::from_node(node, src)
6929 })?,
6930 ))),
6931 "method_definition" => Ok(Self::MethodDefinition(::std::boxed::Box::new(
6932 ::treesitter_types::runtime::maybe_grow_stack(|| {
6933 <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)
6934 })?,
6935 ))),
6936 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6937 }
6938 }
6939}
6940impl ::treesitter_types::Spanned for ClassBodyMember<'_> {
6941 fn span(&self) -> ::treesitter_types::Span {
6942 match self {
6943 Self::ClassStaticBlock(inner) => inner.span(),
6944 Self::FieldDefinition(inner) => inner.span(),
6945 Self::MethodDefinition(inner) => inner.span(),
6946 }
6947 }
6948}
6949#[derive(Debug, Clone, PartialEq, Eq)]
6950pub enum DecoratorChildren<'tree> {
6951 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
6952 Identifier(::std::boxed::Box<Identifier<'tree>>),
6953 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
6954}
6955impl<'tree> ::treesitter_types::FromNode<'tree> for DecoratorChildren<'tree> {
6956 #[allow(clippy::collapsible_else_if)]
6957 fn from_node(
6958 node: ::treesitter_types::tree_sitter::Node<'tree>,
6959 src: &'tree [u8],
6960 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6961 match node.kind() {
6962 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
6963 ::treesitter_types::runtime::maybe_grow_stack(|| {
6964 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
6965 })?,
6966 ))),
6967 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6968 ::treesitter_types::runtime::maybe_grow_stack(|| {
6969 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
6970 })?,
6971 ))),
6972 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
6973 ::treesitter_types::runtime::maybe_grow_stack(|| {
6974 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
6975 })?,
6976 ))),
6977 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6978 }
6979 }
6980}
6981impl ::treesitter_types::Spanned for DecoratorChildren<'_> {
6982 fn span(&self) -> ::treesitter_types::Span {
6983 match self {
6984 Self::CallExpression(inner) => inner.span(),
6985 Self::Identifier(inner) => inner.span(),
6986 Self::MemberExpression(inner) => inner.span(),
6987 }
6988 }
6989}
6990#[derive(Debug, Clone, PartialEq, Eq)]
6991pub enum ExportSpecifierAlias<'tree> {
6992 Default(::treesitter_types::Span),
6993 Identifier(::std::boxed::Box<Identifier<'tree>>),
6994 String(::std::boxed::Box<String<'tree>>),
6995}
6996impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifierAlias<'tree> {
6997 #[allow(clippy::collapsible_else_if)]
6998 fn from_node(
6999 node: ::treesitter_types::tree_sitter::Node<'tree>,
7000 src: &'tree [u8],
7001 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7002 match node.kind() {
7003 "default" => Ok(Self::Default(::treesitter_types::Span::from(node))),
7004 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7005 ::treesitter_types::runtime::maybe_grow_stack(|| {
7006 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7007 })?,
7008 ))),
7009 "string" => Ok(Self::String(::std::boxed::Box::new(
7010 ::treesitter_types::runtime::maybe_grow_stack(|| {
7011 <String as ::treesitter_types::FromNode>::from_node(node, src)
7012 })?,
7013 ))),
7014 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7015 }
7016 }
7017}
7018impl ::treesitter_types::Spanned for ExportSpecifierAlias<'_> {
7019 fn span(&self) -> ::treesitter_types::Span {
7020 match self {
7021 Self::Default(span) => *span,
7022 Self::Identifier(inner) => inner.span(),
7023 Self::String(inner) => inner.span(),
7024 }
7025 }
7026}
7027#[derive(Debug, Clone, PartialEq, Eq)]
7028pub enum ExportSpecifierName<'tree> {
7029 Default(::treesitter_types::Span),
7030 Identifier(::std::boxed::Box<Identifier<'tree>>),
7031 String(::std::boxed::Box<String<'tree>>),
7032}
7033impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifierName<'tree> {
7034 #[allow(clippy::collapsible_else_if)]
7035 fn from_node(
7036 node: ::treesitter_types::tree_sitter::Node<'tree>,
7037 src: &'tree [u8],
7038 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7039 match node.kind() {
7040 "default" => Ok(Self::Default(::treesitter_types::Span::from(node))),
7041 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7042 ::treesitter_types::runtime::maybe_grow_stack(|| {
7043 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7044 })?,
7045 ))),
7046 "string" => Ok(Self::String(::std::boxed::Box::new(
7047 ::treesitter_types::runtime::maybe_grow_stack(|| {
7048 <String as ::treesitter_types::FromNode>::from_node(node, src)
7049 })?,
7050 ))),
7051 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7052 }
7053 }
7054}
7055impl ::treesitter_types::Spanned for ExportSpecifierName<'_> {
7056 fn span(&self) -> ::treesitter_types::Span {
7057 match self {
7058 Self::Default(span) => *span,
7059 Self::Identifier(inner) => inner.span(),
7060 Self::String(inner) => inner.span(),
7061 }
7062 }
7063}
7064#[derive(Debug, Clone, PartialEq, Eq)]
7065pub enum ExportStatementChildren<'tree> {
7066 ExportClause(::std::boxed::Box<ExportClause<'tree>>),
7067 NamespaceExport(::std::boxed::Box<NamespaceExport<'tree>>),
7068}
7069impl<'tree> ::treesitter_types::FromNode<'tree> for ExportStatementChildren<'tree> {
7070 #[allow(clippy::collapsible_else_if)]
7071 fn from_node(
7072 node: ::treesitter_types::tree_sitter::Node<'tree>,
7073 src: &'tree [u8],
7074 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7075 match node.kind() {
7076 "export_clause" => Ok(Self::ExportClause(::std::boxed::Box::new(
7077 ::treesitter_types::runtime::maybe_grow_stack(|| {
7078 <ExportClause as ::treesitter_types::FromNode>::from_node(node, src)
7079 })?,
7080 ))),
7081 "namespace_export" => Ok(Self::NamespaceExport(::std::boxed::Box::new(
7082 ::treesitter_types::runtime::maybe_grow_stack(|| {
7083 <NamespaceExport as ::treesitter_types::FromNode>::from_node(node, src)
7084 })?,
7085 ))),
7086 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7087 }
7088 }
7089}
7090impl ::treesitter_types::Spanned for ExportStatementChildren<'_> {
7091 fn span(&self) -> ::treesitter_types::Span {
7092 match self {
7093 Self::ExportClause(inner) => inner.span(),
7094 Self::NamespaceExport(inner) => inner.span(),
7095 }
7096 }
7097}
7098#[derive(Debug, Clone, PartialEq, Eq)]
7099pub enum ExpressionStatementChildren<'tree> {
7100 Expression(::std::boxed::Box<Expression<'tree>>),
7101 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
7102}
7103impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
7104 #[allow(clippy::collapsible_else_if)]
7105 fn from_node(
7106 node: ::treesitter_types::tree_sitter::Node<'tree>,
7107 src: &'tree [u8],
7108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7109 match node.kind() {
7110 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
7111 ::treesitter_types::runtime::maybe_grow_stack(|| {
7112 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
7113 })?,
7114 ))),
7115 _other => {
7116 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7117 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7118 }) {
7119 Ok(Self::Expression(::std::boxed::Box::new(v)))
7120 } else {
7121 Err(::treesitter_types::ParseError::unexpected_kind(
7122 _other, node,
7123 ))
7124 }
7125 }
7126 }
7127 }
7128}
7129impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
7130 fn span(&self) -> ::treesitter_types::Span {
7131 match self {
7132 Self::Expression(inner) => inner.span(),
7133 Self::SequenceExpression(inner) => inner.span(),
7134 }
7135 }
7136}
7137#[derive(Debug, Clone, PartialEq, Eq)]
7138pub enum FieldDefinitionProperty<'tree> {
7139 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
7140 Number(::std::boxed::Box<Number<'tree>>),
7141 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
7142 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
7143 String(::std::boxed::Box<String<'tree>>),
7144}
7145impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDefinitionProperty<'tree> {
7146 #[allow(clippy::collapsible_else_if)]
7147 fn from_node(
7148 node: ::treesitter_types::tree_sitter::Node<'tree>,
7149 src: &'tree [u8],
7150 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7151 match node.kind() {
7152 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
7153 ::treesitter_types::runtime::maybe_grow_stack(|| {
7154 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)
7155 })?,
7156 ))),
7157 "number" => Ok(Self::Number(::std::boxed::Box::new(
7158 ::treesitter_types::runtime::maybe_grow_stack(|| {
7159 <Number as ::treesitter_types::FromNode>::from_node(node, src)
7160 })?,
7161 ))),
7162 "private_property_identifier" => Ok(Self::PrivatePropertyIdentifier(
7163 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
7164 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
7165 node, src,
7166 )
7167 })?),
7168 )),
7169 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
7170 ::treesitter_types::runtime::maybe_grow_stack(|| {
7171 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
7172 })?,
7173 ))),
7174 "string" => Ok(Self::String(::std::boxed::Box::new(
7175 ::treesitter_types::runtime::maybe_grow_stack(|| {
7176 <String as ::treesitter_types::FromNode>::from_node(node, src)
7177 })?,
7178 ))),
7179 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7180 }
7181 }
7182}
7183impl ::treesitter_types::Spanned for FieldDefinitionProperty<'_> {
7184 fn span(&self) -> ::treesitter_types::Span {
7185 match self {
7186 Self::ComputedPropertyName(inner) => inner.span(),
7187 Self::Number(inner) => inner.span(),
7188 Self::PrivatePropertyIdentifier(inner) => inner.span(),
7189 Self::PropertyIdentifier(inner) => inner.span(),
7190 Self::String(inner) => inner.span(),
7191 }
7192 }
7193}
7194#[derive(Debug, Clone, PartialEq, Eq)]
7195pub enum ForInStatementKind {
7196 Await(::treesitter_types::Span),
7197 Const(::treesitter_types::Span),
7198 Let(::treesitter_types::Span),
7199 Using(::treesitter_types::Span),
7200 Var(::treesitter_types::Span),
7201}
7202impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementKind {
7203 #[allow(clippy::collapsible_else_if)]
7204 fn from_node(
7205 node: ::treesitter_types::tree_sitter::Node<'tree>,
7206 _src: &'tree [u8],
7207 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7208 match node.kind() {
7209 "await" => Ok(Self::Await(::treesitter_types::Span::from(node))),
7210 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
7211 "let" => Ok(Self::Let(::treesitter_types::Span::from(node))),
7212 "using" => Ok(Self::Using(::treesitter_types::Span::from(node))),
7213 "var" => Ok(Self::Var(::treesitter_types::Span::from(node))),
7214 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7215 }
7216 }
7217}
7218impl ::treesitter_types::Spanned for ForInStatementKind {
7219 fn span(&self) -> ::treesitter_types::Span {
7220 match self {
7221 Self::Await(span) => *span,
7222 Self::Const(span) => *span,
7223 Self::Let(span) => *span,
7224 Self::Using(span) => *span,
7225 Self::Var(span) => *span,
7226 }
7227 }
7228}
7229#[derive(Debug, Clone, PartialEq, Eq)]
7230pub enum ForInStatementLeft<'tree> {
7231 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
7232 Identifier(::std::boxed::Box<Identifier<'tree>>),
7233 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
7234 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
7235 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
7236 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
7237 Undefined(::std::boxed::Box<Undefined<'tree>>),
7238}
7239impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementLeft<'tree> {
7240 #[allow(clippy::collapsible_else_if)]
7241 fn from_node(
7242 node: ::treesitter_types::tree_sitter::Node<'tree>,
7243 src: &'tree [u8],
7244 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7245 match node.kind() {
7246 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
7247 ::treesitter_types::runtime::maybe_grow_stack(|| {
7248 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
7249 })?,
7250 ))),
7251 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7252 ::treesitter_types::runtime::maybe_grow_stack(|| {
7253 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7254 })?,
7255 ))),
7256 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
7257 ::treesitter_types::runtime::maybe_grow_stack(|| {
7258 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
7259 })?,
7260 ))),
7261 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
7262 ::treesitter_types::runtime::maybe_grow_stack(|| {
7263 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
7264 })?,
7265 ))),
7266 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
7267 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
7268 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
7269 })?),
7270 )),
7271 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
7272 ::treesitter_types::runtime::maybe_grow_stack(|| {
7273 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
7274 })?,
7275 ))),
7276 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
7277 ::treesitter_types::runtime::maybe_grow_stack(|| {
7278 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)
7279 })?,
7280 ))),
7281 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7282 }
7283 }
7284}
7285impl ::treesitter_types::Spanned for ForInStatementLeft<'_> {
7286 fn span(&self) -> ::treesitter_types::Span {
7287 match self {
7288 Self::ArrayPattern(inner) => inner.span(),
7289 Self::Identifier(inner) => inner.span(),
7290 Self::MemberExpression(inner) => inner.span(),
7291 Self::ObjectPattern(inner) => inner.span(),
7292 Self::ParenthesizedExpression(inner) => inner.span(),
7293 Self::SubscriptExpression(inner) => inner.span(),
7294 Self::Undefined(inner) => inner.span(),
7295 }
7296 }
7297}
7298#[derive(Debug, Clone, PartialEq, Eq)]
7299pub enum ForInStatementOperator {
7300 In(::treesitter_types::Span),
7301 Of(::treesitter_types::Span),
7302}
7303impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementOperator {
7304 #[allow(clippy::collapsible_else_if)]
7305 fn from_node(
7306 node: ::treesitter_types::tree_sitter::Node<'tree>,
7307 _src: &'tree [u8],
7308 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7309 match node.kind() {
7310 "in" => Ok(Self::In(::treesitter_types::Span::from(node))),
7311 "of" => Ok(Self::Of(::treesitter_types::Span::from(node))),
7312 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7313 }
7314 }
7315}
7316impl ::treesitter_types::Spanned for ForInStatementOperator {
7317 fn span(&self) -> ::treesitter_types::Span {
7318 match self {
7319 Self::In(span) => *span,
7320 Self::Of(span) => *span,
7321 }
7322 }
7323}
7324#[derive(Debug, Clone, PartialEq, Eq)]
7325pub enum ForInStatementRight<'tree> {
7326 Expression(::std::boxed::Box<Expression<'tree>>),
7327 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
7328}
7329impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementRight<'tree> {
7330 #[allow(clippy::collapsible_else_if)]
7331 fn from_node(
7332 node: ::treesitter_types::tree_sitter::Node<'tree>,
7333 src: &'tree [u8],
7334 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7335 match node.kind() {
7336 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
7337 ::treesitter_types::runtime::maybe_grow_stack(|| {
7338 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
7339 })?,
7340 ))),
7341 _other => {
7342 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7343 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7344 }) {
7345 Ok(Self::Expression(::std::boxed::Box::new(v)))
7346 } else {
7347 Err(::treesitter_types::ParseError::unexpected_kind(
7348 _other, node,
7349 ))
7350 }
7351 }
7352 }
7353 }
7354}
7355impl ::treesitter_types::Spanned for ForInStatementRight<'_> {
7356 fn span(&self) -> ::treesitter_types::Span {
7357 match self {
7358 Self::Expression(inner) => inner.span(),
7359 Self::SequenceExpression(inner) => inner.span(),
7360 }
7361 }
7362}
7363#[derive(Debug, Clone, PartialEq, Eq)]
7364pub enum ForStatementCondition<'tree> {
7365 Semicolon(::treesitter_types::Span),
7366 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7367 Expression(::std::boxed::Box<Expression<'tree>>),
7368 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
7369}
7370impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementCondition<'tree> {
7371 #[allow(clippy::collapsible_else_if)]
7372 fn from_node(
7373 node: ::treesitter_types::tree_sitter::Node<'tree>,
7374 src: &'tree [u8],
7375 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7376 match node.kind() {
7377 ";" => Ok(Self::Semicolon(::treesitter_types::Span::from(node))),
7378 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7379 ::treesitter_types::runtime::maybe_grow_stack(|| {
7380 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
7381 })?,
7382 ))),
7383 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
7384 ::treesitter_types::runtime::maybe_grow_stack(|| {
7385 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
7386 })?,
7387 ))),
7388 _other => {
7389 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7390 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7391 }) {
7392 Ok(Self::Expression(::std::boxed::Box::new(v)))
7393 } else {
7394 Err(::treesitter_types::ParseError::unexpected_kind(
7395 _other, node,
7396 ))
7397 }
7398 }
7399 }
7400 }
7401}
7402impl ::treesitter_types::Spanned for ForStatementCondition<'_> {
7403 fn span(&self) -> ::treesitter_types::Span {
7404 match self {
7405 Self::Semicolon(span) => *span,
7406 Self::EmptyStatement(inner) => inner.span(),
7407 Self::Expression(inner) => inner.span(),
7408 Self::SequenceExpression(inner) => inner.span(),
7409 }
7410 }
7411}
7412#[derive(Debug, Clone, PartialEq, Eq)]
7413pub enum ForStatementIncrement<'tree> {
7414 Expression(::std::boxed::Box<Expression<'tree>>),
7415 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
7416}
7417impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementIncrement<'tree> {
7418 #[allow(clippy::collapsible_else_if)]
7419 fn from_node(
7420 node: ::treesitter_types::tree_sitter::Node<'tree>,
7421 src: &'tree [u8],
7422 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7423 match node.kind() {
7424 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
7425 ::treesitter_types::runtime::maybe_grow_stack(|| {
7426 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
7427 })?,
7428 ))),
7429 _other => {
7430 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7431 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7432 }) {
7433 Ok(Self::Expression(::std::boxed::Box::new(v)))
7434 } else {
7435 Err(::treesitter_types::ParseError::unexpected_kind(
7436 _other, node,
7437 ))
7438 }
7439 }
7440 }
7441 }
7442}
7443impl ::treesitter_types::Spanned for ForStatementIncrement<'_> {
7444 fn span(&self) -> ::treesitter_types::Span {
7445 match self {
7446 Self::Expression(inner) => inner.span(),
7447 Self::SequenceExpression(inner) => inner.span(),
7448 }
7449 }
7450}
7451#[derive(Debug, Clone, PartialEq, Eq)]
7452pub enum ForStatementInitializer<'tree> {
7453 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7454 Expression(::std::boxed::Box<Expression<'tree>>),
7455 LexicalDeclaration(::std::boxed::Box<LexicalDeclaration<'tree>>),
7456 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
7457 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
7458}
7459impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
7460 #[allow(clippy::collapsible_else_if)]
7461 fn from_node(
7462 node: ::treesitter_types::tree_sitter::Node<'tree>,
7463 src: &'tree [u8],
7464 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7465 match node.kind() {
7466 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7467 ::treesitter_types::runtime::maybe_grow_stack(|| {
7468 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
7469 })?,
7470 ))),
7471 "lexical_declaration" => Ok(Self::LexicalDeclaration(::std::boxed::Box::new(
7472 ::treesitter_types::runtime::maybe_grow_stack(|| {
7473 <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7474 })?,
7475 ))),
7476 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
7477 ::treesitter_types::runtime::maybe_grow_stack(|| {
7478 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
7479 })?,
7480 ))),
7481 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
7482 ::treesitter_types::runtime::maybe_grow_stack(|| {
7483 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7484 })?,
7485 ))),
7486 _other => {
7487 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7488 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7489 }) {
7490 Ok(Self::Expression(::std::boxed::Box::new(v)))
7491 } else {
7492 Err(::treesitter_types::ParseError::unexpected_kind(
7493 _other, node,
7494 ))
7495 }
7496 }
7497 }
7498 }
7499}
7500impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
7501 fn span(&self) -> ::treesitter_types::Span {
7502 match self {
7503 Self::EmptyStatement(inner) => inner.span(),
7504 Self::Expression(inner) => inner.span(),
7505 Self::LexicalDeclaration(inner) => inner.span(),
7506 Self::SequenceExpression(inner) => inner.span(),
7507 Self::VariableDeclaration(inner) => inner.span(),
7508 }
7509 }
7510}
7511#[derive(Debug, Clone, PartialEq, Eq)]
7512pub enum FormalParametersChildren<'tree> {
7513 AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
7514 Pattern(::std::boxed::Box<Pattern<'tree>>),
7515}
7516impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParametersChildren<'tree> {
7517 #[allow(clippy::collapsible_else_if)]
7518 fn from_node(
7519 node: ::treesitter_types::tree_sitter::Node<'tree>,
7520 src: &'tree [u8],
7521 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7522 match node.kind() {
7523 "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
7524 ::treesitter_types::runtime::maybe_grow_stack(|| {
7525 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
7526 })?,
7527 ))),
7528 _other => {
7529 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7530 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
7531 }) {
7532 Ok(Self::Pattern(::std::boxed::Box::new(v)))
7533 } else {
7534 Err(::treesitter_types::ParseError::unexpected_kind(
7535 _other, node,
7536 ))
7537 }
7538 }
7539 }
7540 }
7541}
7542impl ::treesitter_types::Spanned for FormalParametersChildren<'_> {
7543 fn span(&self) -> ::treesitter_types::Span {
7544 match self {
7545 Self::AssignmentPattern(inner) => inner.span(),
7546 Self::Pattern(inner) => inner.span(),
7547 }
7548 }
7549}
7550#[derive(Debug, Clone, PartialEq, Eq)]
7551pub enum ImportClauseChildren<'tree> {
7552 Identifier(::std::boxed::Box<Identifier<'tree>>),
7553 NamedImports(::std::boxed::Box<NamedImports<'tree>>),
7554 NamespaceImport(::std::boxed::Box<NamespaceImport<'tree>>),
7555}
7556impl<'tree> ::treesitter_types::FromNode<'tree> for ImportClauseChildren<'tree> {
7557 #[allow(clippy::collapsible_else_if)]
7558 fn from_node(
7559 node: ::treesitter_types::tree_sitter::Node<'tree>,
7560 src: &'tree [u8],
7561 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7562 match node.kind() {
7563 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7564 ::treesitter_types::runtime::maybe_grow_stack(|| {
7565 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7566 })?,
7567 ))),
7568 "named_imports" => Ok(Self::NamedImports(::std::boxed::Box::new(
7569 ::treesitter_types::runtime::maybe_grow_stack(|| {
7570 <NamedImports as ::treesitter_types::FromNode>::from_node(node, src)
7571 })?,
7572 ))),
7573 "namespace_import" => Ok(Self::NamespaceImport(::std::boxed::Box::new(
7574 ::treesitter_types::runtime::maybe_grow_stack(|| {
7575 <NamespaceImport as ::treesitter_types::FromNode>::from_node(node, src)
7576 })?,
7577 ))),
7578 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7579 }
7580 }
7581}
7582impl ::treesitter_types::Spanned for ImportClauseChildren<'_> {
7583 fn span(&self) -> ::treesitter_types::Span {
7584 match self {
7585 Self::Identifier(inner) => inner.span(),
7586 Self::NamedImports(inner) => inner.span(),
7587 Self::NamespaceImport(inner) => inner.span(),
7588 }
7589 }
7590}
7591#[derive(Debug, Clone, PartialEq, Eq)]
7592pub enum ImportSpecifierName<'tree> {
7593 Default(::treesitter_types::Span),
7594 Identifier(::std::boxed::Box<Identifier<'tree>>),
7595 String(::std::boxed::Box<String<'tree>>),
7596}
7597impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecifierName<'tree> {
7598 #[allow(clippy::collapsible_else_if)]
7599 fn from_node(
7600 node: ::treesitter_types::tree_sitter::Node<'tree>,
7601 src: &'tree [u8],
7602 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7603 match node.kind() {
7604 "default" => Ok(Self::Default(::treesitter_types::Span::from(node))),
7605 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7606 ::treesitter_types::runtime::maybe_grow_stack(|| {
7607 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7608 })?,
7609 ))),
7610 "string" => Ok(Self::String(::std::boxed::Box::new(
7611 ::treesitter_types::runtime::maybe_grow_stack(|| {
7612 <String as ::treesitter_types::FromNode>::from_node(node, src)
7613 })?,
7614 ))),
7615 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7616 }
7617 }
7618}
7619impl ::treesitter_types::Spanned for ImportSpecifierName<'_> {
7620 fn span(&self) -> ::treesitter_types::Span {
7621 match self {
7622 Self::Default(span) => *span,
7623 Self::Identifier(inner) => inner.span(),
7624 Self::String(inner) => inner.span(),
7625 }
7626 }
7627}
7628#[derive(Debug, Clone, PartialEq, Eq)]
7629pub enum ImportStatementChildren<'tree> {
7630 ImportAttribute(::std::boxed::Box<ImportAttribute<'tree>>),
7631 ImportClause(::std::boxed::Box<ImportClause<'tree>>),
7632}
7633impl<'tree> ::treesitter_types::FromNode<'tree> for ImportStatementChildren<'tree> {
7634 #[allow(clippy::collapsible_else_if)]
7635 fn from_node(
7636 node: ::treesitter_types::tree_sitter::Node<'tree>,
7637 src: &'tree [u8],
7638 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7639 match node.kind() {
7640 "import_attribute" => Ok(Self::ImportAttribute(::std::boxed::Box::new(
7641 ::treesitter_types::runtime::maybe_grow_stack(|| {
7642 <ImportAttribute as ::treesitter_types::FromNode>::from_node(node, src)
7643 })?,
7644 ))),
7645 "import_clause" => Ok(Self::ImportClause(::std::boxed::Box::new(
7646 ::treesitter_types::runtime::maybe_grow_stack(|| {
7647 <ImportClause as ::treesitter_types::FromNode>::from_node(node, src)
7648 })?,
7649 ))),
7650 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7651 }
7652 }
7653}
7654impl ::treesitter_types::Spanned for ImportStatementChildren<'_> {
7655 fn span(&self) -> ::treesitter_types::Span {
7656 match self {
7657 Self::ImportAttribute(inner) => inner.span(),
7658 Self::ImportClause(inner) => inner.span(),
7659 }
7660 }
7661}
7662#[derive(Debug, Clone, PartialEq, Eq)]
7663pub enum JsxAttributeChildren<'tree> {
7664 JsxElement(::std::boxed::Box<JsxElement<'tree>>),
7665 JsxExpression(::std::boxed::Box<JsxExpression<'tree>>),
7666 JsxNamespaceName(::std::boxed::Box<JsxNamespaceName<'tree>>),
7667 JsxSelfClosingElement(::std::boxed::Box<JsxSelfClosingElement<'tree>>),
7668 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
7669 String(::std::boxed::Box<String<'tree>>),
7670}
7671impl<'tree> ::treesitter_types::FromNode<'tree> for JsxAttributeChildren<'tree> {
7672 #[allow(clippy::collapsible_else_if)]
7673 fn from_node(
7674 node: ::treesitter_types::tree_sitter::Node<'tree>,
7675 src: &'tree [u8],
7676 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7677 match node.kind() {
7678 "jsx_element" => Ok(Self::JsxElement(::std::boxed::Box::new(
7679 ::treesitter_types::runtime::maybe_grow_stack(|| {
7680 <JsxElement as ::treesitter_types::FromNode>::from_node(node, src)
7681 })?,
7682 ))),
7683 "jsx_expression" => Ok(Self::JsxExpression(::std::boxed::Box::new(
7684 ::treesitter_types::runtime::maybe_grow_stack(|| {
7685 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)
7686 })?,
7687 ))),
7688 "jsx_namespace_name" => Ok(Self::JsxNamespaceName(::std::boxed::Box::new(
7689 ::treesitter_types::runtime::maybe_grow_stack(|| {
7690 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
7691 })?,
7692 ))),
7693 "jsx_self_closing_element" => Ok(Self::JsxSelfClosingElement(::std::boxed::Box::new(
7694 ::treesitter_types::runtime::maybe_grow_stack(|| {
7695 <JsxSelfClosingElement as ::treesitter_types::FromNode>::from_node(node, src)
7696 })?,
7697 ))),
7698 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
7699 ::treesitter_types::runtime::maybe_grow_stack(|| {
7700 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
7701 })?,
7702 ))),
7703 "string" => Ok(Self::String(::std::boxed::Box::new(
7704 ::treesitter_types::runtime::maybe_grow_stack(|| {
7705 <String as ::treesitter_types::FromNode>::from_node(node, src)
7706 })?,
7707 ))),
7708 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7709 }
7710 }
7711}
7712impl ::treesitter_types::Spanned for JsxAttributeChildren<'_> {
7713 fn span(&self) -> ::treesitter_types::Span {
7714 match self {
7715 Self::JsxElement(inner) => inner.span(),
7716 Self::JsxExpression(inner) => inner.span(),
7717 Self::JsxNamespaceName(inner) => inner.span(),
7718 Self::JsxSelfClosingElement(inner) => inner.span(),
7719 Self::PropertyIdentifier(inner) => inner.span(),
7720 Self::String(inner) => inner.span(),
7721 }
7722 }
7723}
7724#[derive(Debug, Clone, PartialEq, Eq)]
7725pub enum JsxClosingElementName<'tree> {
7726 Identifier(::std::boxed::Box<Identifier<'tree>>),
7727 JsxNamespaceName(::std::boxed::Box<JsxNamespaceName<'tree>>),
7728 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
7729}
7730impl<'tree> ::treesitter_types::FromNode<'tree> for JsxClosingElementName<'tree> {
7731 #[allow(clippy::collapsible_else_if)]
7732 fn from_node(
7733 node: ::treesitter_types::tree_sitter::Node<'tree>,
7734 src: &'tree [u8],
7735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7736 match node.kind() {
7737 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7738 ::treesitter_types::runtime::maybe_grow_stack(|| {
7739 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7740 })?,
7741 ))),
7742 "jsx_namespace_name" => Ok(Self::JsxNamespaceName(::std::boxed::Box::new(
7743 ::treesitter_types::runtime::maybe_grow_stack(|| {
7744 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
7745 })?,
7746 ))),
7747 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
7748 ::treesitter_types::runtime::maybe_grow_stack(|| {
7749 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
7750 })?,
7751 ))),
7752 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7753 }
7754 }
7755}
7756impl ::treesitter_types::Spanned for JsxClosingElementName<'_> {
7757 fn span(&self) -> ::treesitter_types::Span {
7758 match self {
7759 Self::Identifier(inner) => inner.span(),
7760 Self::JsxNamespaceName(inner) => inner.span(),
7761 Self::MemberExpression(inner) => inner.span(),
7762 }
7763 }
7764}
7765#[derive(Debug, Clone, PartialEq, Eq)]
7766pub enum JsxElementChildren<'tree> {
7767 HtmlCharacterReference(::std::boxed::Box<HtmlCharacterReference<'tree>>),
7768 JsxElement(::std::boxed::Box<JsxElement<'tree>>),
7769 JsxExpression(::std::boxed::Box<JsxExpression<'tree>>),
7770 JsxSelfClosingElement(::std::boxed::Box<JsxSelfClosingElement<'tree>>),
7771 JsxText(::std::boxed::Box<JsxText<'tree>>),
7772}
7773impl<'tree> ::treesitter_types::FromNode<'tree> for JsxElementChildren<'tree> {
7774 #[allow(clippy::collapsible_else_if)]
7775 fn from_node(
7776 node: ::treesitter_types::tree_sitter::Node<'tree>,
7777 src: &'tree [u8],
7778 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7779 match node.kind() {
7780 "html_character_reference" => Ok(Self::HtmlCharacterReference(::std::boxed::Box::new(
7781 ::treesitter_types::runtime::maybe_grow_stack(|| {
7782 <HtmlCharacterReference as ::treesitter_types::FromNode>::from_node(node, src)
7783 })?,
7784 ))),
7785 "jsx_element" => Ok(Self::JsxElement(::std::boxed::Box::new(
7786 ::treesitter_types::runtime::maybe_grow_stack(|| {
7787 <JsxElement as ::treesitter_types::FromNode>::from_node(node, src)
7788 })?,
7789 ))),
7790 "jsx_expression" => Ok(Self::JsxExpression(::std::boxed::Box::new(
7791 ::treesitter_types::runtime::maybe_grow_stack(|| {
7792 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)
7793 })?,
7794 ))),
7795 "jsx_self_closing_element" => Ok(Self::JsxSelfClosingElement(::std::boxed::Box::new(
7796 ::treesitter_types::runtime::maybe_grow_stack(|| {
7797 <JsxSelfClosingElement as ::treesitter_types::FromNode>::from_node(node, src)
7798 })?,
7799 ))),
7800 "jsx_text" => Ok(Self::JsxText(::std::boxed::Box::new(
7801 ::treesitter_types::runtime::maybe_grow_stack(|| {
7802 <JsxText as ::treesitter_types::FromNode>::from_node(node, src)
7803 })?,
7804 ))),
7805 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7806 }
7807 }
7808}
7809impl ::treesitter_types::Spanned for JsxElementChildren<'_> {
7810 fn span(&self) -> ::treesitter_types::Span {
7811 match self {
7812 Self::HtmlCharacterReference(inner) => inner.span(),
7813 Self::JsxElement(inner) => inner.span(),
7814 Self::JsxExpression(inner) => inner.span(),
7815 Self::JsxSelfClosingElement(inner) => inner.span(),
7816 Self::JsxText(inner) => inner.span(),
7817 }
7818 }
7819}
7820#[derive(Debug, Clone, PartialEq, Eq)]
7821pub enum JsxExpressionChildren<'tree> {
7822 Expression(::std::boxed::Box<Expression<'tree>>),
7823 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
7824 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
7825}
7826impl<'tree> ::treesitter_types::FromNode<'tree> for JsxExpressionChildren<'tree> {
7827 #[allow(clippy::collapsible_else_if)]
7828 fn from_node(
7829 node: ::treesitter_types::tree_sitter::Node<'tree>,
7830 src: &'tree [u8],
7831 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7832 match node.kind() {
7833 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
7834 ::treesitter_types::runtime::maybe_grow_stack(|| {
7835 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
7836 })?,
7837 ))),
7838 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
7839 ::treesitter_types::runtime::maybe_grow_stack(|| {
7840 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
7841 })?,
7842 ))),
7843 _other => {
7844 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7845 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7846 }) {
7847 Ok(Self::Expression(::std::boxed::Box::new(v)))
7848 } else {
7849 Err(::treesitter_types::ParseError::unexpected_kind(
7850 _other, node,
7851 ))
7852 }
7853 }
7854 }
7855 }
7856}
7857impl ::treesitter_types::Spanned for JsxExpressionChildren<'_> {
7858 fn span(&self) -> ::treesitter_types::Span {
7859 match self {
7860 Self::Expression(inner) => inner.span(),
7861 Self::SequenceExpression(inner) => inner.span(),
7862 Self::SpreadElement(inner) => inner.span(),
7863 }
7864 }
7865}
7866#[derive(Debug, Clone, PartialEq, Eq)]
7867pub enum JsxOpeningElementAttribute<'tree> {
7868 JsxAttribute(::std::boxed::Box<JsxAttribute<'tree>>),
7869 JsxExpression(::std::boxed::Box<JsxExpression<'tree>>),
7870}
7871impl<'tree> ::treesitter_types::FromNode<'tree> for JsxOpeningElementAttribute<'tree> {
7872 #[allow(clippy::collapsible_else_if)]
7873 fn from_node(
7874 node: ::treesitter_types::tree_sitter::Node<'tree>,
7875 src: &'tree [u8],
7876 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7877 match node.kind() {
7878 "jsx_attribute" => Ok(Self::JsxAttribute(::std::boxed::Box::new(
7879 ::treesitter_types::runtime::maybe_grow_stack(|| {
7880 <JsxAttribute as ::treesitter_types::FromNode>::from_node(node, src)
7881 })?,
7882 ))),
7883 "jsx_expression" => Ok(Self::JsxExpression(::std::boxed::Box::new(
7884 ::treesitter_types::runtime::maybe_grow_stack(|| {
7885 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)
7886 })?,
7887 ))),
7888 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7889 }
7890 }
7891}
7892impl ::treesitter_types::Spanned for JsxOpeningElementAttribute<'_> {
7893 fn span(&self) -> ::treesitter_types::Span {
7894 match self {
7895 Self::JsxAttribute(inner) => inner.span(),
7896 Self::JsxExpression(inner) => inner.span(),
7897 }
7898 }
7899}
7900#[derive(Debug, Clone, PartialEq, Eq)]
7901pub enum JsxOpeningElementName<'tree> {
7902 Identifier(::std::boxed::Box<Identifier<'tree>>),
7903 JsxNamespaceName(::std::boxed::Box<JsxNamespaceName<'tree>>),
7904 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
7905}
7906impl<'tree> ::treesitter_types::FromNode<'tree> for JsxOpeningElementName<'tree> {
7907 #[allow(clippy::collapsible_else_if)]
7908 fn from_node(
7909 node: ::treesitter_types::tree_sitter::Node<'tree>,
7910 src: &'tree [u8],
7911 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7912 match node.kind() {
7913 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7914 ::treesitter_types::runtime::maybe_grow_stack(|| {
7915 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7916 })?,
7917 ))),
7918 "jsx_namespace_name" => Ok(Self::JsxNamespaceName(::std::boxed::Box::new(
7919 ::treesitter_types::runtime::maybe_grow_stack(|| {
7920 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
7921 })?,
7922 ))),
7923 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
7924 ::treesitter_types::runtime::maybe_grow_stack(|| {
7925 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
7926 })?,
7927 ))),
7928 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7929 }
7930 }
7931}
7932impl ::treesitter_types::Spanned for JsxOpeningElementName<'_> {
7933 fn span(&self) -> ::treesitter_types::Span {
7934 match self {
7935 Self::Identifier(inner) => inner.span(),
7936 Self::JsxNamespaceName(inner) => inner.span(),
7937 Self::MemberExpression(inner) => inner.span(),
7938 }
7939 }
7940}
7941#[derive(Debug, Clone, PartialEq, Eq)]
7942pub enum JsxSelfClosingElementAttribute<'tree> {
7943 JsxAttribute(::std::boxed::Box<JsxAttribute<'tree>>),
7944 JsxExpression(::std::boxed::Box<JsxExpression<'tree>>),
7945}
7946impl<'tree> ::treesitter_types::FromNode<'tree> for JsxSelfClosingElementAttribute<'tree> {
7947 #[allow(clippy::collapsible_else_if)]
7948 fn from_node(
7949 node: ::treesitter_types::tree_sitter::Node<'tree>,
7950 src: &'tree [u8],
7951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7952 match node.kind() {
7953 "jsx_attribute" => Ok(Self::JsxAttribute(::std::boxed::Box::new(
7954 ::treesitter_types::runtime::maybe_grow_stack(|| {
7955 <JsxAttribute as ::treesitter_types::FromNode>::from_node(node, src)
7956 })?,
7957 ))),
7958 "jsx_expression" => Ok(Self::JsxExpression(::std::boxed::Box::new(
7959 ::treesitter_types::runtime::maybe_grow_stack(|| {
7960 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)
7961 })?,
7962 ))),
7963 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7964 }
7965 }
7966}
7967impl ::treesitter_types::Spanned for JsxSelfClosingElementAttribute<'_> {
7968 fn span(&self) -> ::treesitter_types::Span {
7969 match self {
7970 Self::JsxAttribute(inner) => inner.span(),
7971 Self::JsxExpression(inner) => inner.span(),
7972 }
7973 }
7974}
7975#[derive(Debug, Clone, PartialEq, Eq)]
7976pub enum JsxSelfClosingElementName<'tree> {
7977 Identifier(::std::boxed::Box<Identifier<'tree>>),
7978 JsxNamespaceName(::std::boxed::Box<JsxNamespaceName<'tree>>),
7979 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
7980}
7981impl<'tree> ::treesitter_types::FromNode<'tree> for JsxSelfClosingElementName<'tree> {
7982 #[allow(clippy::collapsible_else_if)]
7983 fn from_node(
7984 node: ::treesitter_types::tree_sitter::Node<'tree>,
7985 src: &'tree [u8],
7986 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7987 match node.kind() {
7988 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7989 ::treesitter_types::runtime::maybe_grow_stack(|| {
7990 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7991 })?,
7992 ))),
7993 "jsx_namespace_name" => Ok(Self::JsxNamespaceName(::std::boxed::Box::new(
7994 ::treesitter_types::runtime::maybe_grow_stack(|| {
7995 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
7996 })?,
7997 ))),
7998 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
7999 ::treesitter_types::runtime::maybe_grow_stack(|| {
8000 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
8001 })?,
8002 ))),
8003 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8004 }
8005 }
8006}
8007impl ::treesitter_types::Spanned for JsxSelfClosingElementName<'_> {
8008 fn span(&self) -> ::treesitter_types::Span {
8009 match self {
8010 Self::Identifier(inner) => inner.span(),
8011 Self::JsxNamespaceName(inner) => inner.span(),
8012 Self::MemberExpression(inner) => inner.span(),
8013 }
8014 }
8015}
8016#[derive(Debug, Clone, PartialEq, Eq)]
8017pub enum LexicalDeclarationKind {
8018 Const(::treesitter_types::Span),
8019 Let(::treesitter_types::Span),
8020}
8021impl<'tree> ::treesitter_types::FromNode<'tree> for LexicalDeclarationKind {
8022 #[allow(clippy::collapsible_else_if)]
8023 fn from_node(
8024 node: ::treesitter_types::tree_sitter::Node<'tree>,
8025 _src: &'tree [u8],
8026 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8027 match node.kind() {
8028 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
8029 "let" => Ok(Self::Let(::treesitter_types::Span::from(node))),
8030 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8031 }
8032 }
8033}
8034impl ::treesitter_types::Spanned for LexicalDeclarationKind {
8035 fn span(&self) -> ::treesitter_types::Span {
8036 match self {
8037 Self::Const(span) => *span,
8038 Self::Let(span) => *span,
8039 }
8040 }
8041}
8042#[derive(Debug, Clone, PartialEq, Eq)]
8043pub enum MemberExpressionObject<'tree> {
8044 Expression(::std::boxed::Box<Expression<'tree>>),
8045 Import(::std::boxed::Box<Import<'tree>>),
8046}
8047impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpressionObject<'tree> {
8048 #[allow(clippy::collapsible_else_if)]
8049 fn from_node(
8050 node: ::treesitter_types::tree_sitter::Node<'tree>,
8051 src: &'tree [u8],
8052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8053 match node.kind() {
8054 "import" => Ok(Self::Import(::std::boxed::Box::new(
8055 ::treesitter_types::runtime::maybe_grow_stack(|| {
8056 <Import as ::treesitter_types::FromNode>::from_node(node, src)
8057 })?,
8058 ))),
8059 _other => {
8060 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8061 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8062 }) {
8063 Ok(Self::Expression(::std::boxed::Box::new(v)))
8064 } else {
8065 Err(::treesitter_types::ParseError::unexpected_kind(
8066 _other, node,
8067 ))
8068 }
8069 }
8070 }
8071 }
8072}
8073impl ::treesitter_types::Spanned for MemberExpressionObject<'_> {
8074 fn span(&self) -> ::treesitter_types::Span {
8075 match self {
8076 Self::Expression(inner) => inner.span(),
8077 Self::Import(inner) => inner.span(),
8078 }
8079 }
8080}
8081#[derive(Debug, Clone, PartialEq, Eq)]
8082pub enum MemberExpressionProperty<'tree> {
8083 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
8084 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
8085}
8086impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpressionProperty<'tree> {
8087 #[allow(clippy::collapsible_else_if)]
8088 fn from_node(
8089 node: ::treesitter_types::tree_sitter::Node<'tree>,
8090 src: &'tree [u8],
8091 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8092 match node.kind() {
8093 "private_property_identifier" => Ok(Self::PrivatePropertyIdentifier(
8094 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8095 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
8096 node, src,
8097 )
8098 })?),
8099 )),
8100 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
8101 ::treesitter_types::runtime::maybe_grow_stack(|| {
8102 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
8103 })?,
8104 ))),
8105 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8106 }
8107 }
8108}
8109impl ::treesitter_types::Spanned for MemberExpressionProperty<'_> {
8110 fn span(&self) -> ::treesitter_types::Span {
8111 match self {
8112 Self::PrivatePropertyIdentifier(inner) => inner.span(),
8113 Self::PropertyIdentifier(inner) => inner.span(),
8114 }
8115 }
8116}
8117#[derive(Debug, Clone, PartialEq, Eq)]
8118pub enum MethodDefinitionName<'tree> {
8119 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
8120 Number(::std::boxed::Box<Number<'tree>>),
8121 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
8122 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
8123 String(::std::boxed::Box<String<'tree>>),
8124}
8125impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinitionName<'tree> {
8126 #[allow(clippy::collapsible_else_if)]
8127 fn from_node(
8128 node: ::treesitter_types::tree_sitter::Node<'tree>,
8129 src: &'tree [u8],
8130 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8131 match node.kind() {
8132 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
8133 ::treesitter_types::runtime::maybe_grow_stack(|| {
8134 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)
8135 })?,
8136 ))),
8137 "number" => Ok(Self::Number(::std::boxed::Box::new(
8138 ::treesitter_types::runtime::maybe_grow_stack(|| {
8139 <Number as ::treesitter_types::FromNode>::from_node(node, src)
8140 })?,
8141 ))),
8142 "private_property_identifier" => Ok(Self::PrivatePropertyIdentifier(
8143 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8144 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
8145 node, src,
8146 )
8147 })?),
8148 )),
8149 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
8150 ::treesitter_types::runtime::maybe_grow_stack(|| {
8151 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
8152 })?,
8153 ))),
8154 "string" => Ok(Self::String(::std::boxed::Box::new(
8155 ::treesitter_types::runtime::maybe_grow_stack(|| {
8156 <String as ::treesitter_types::FromNode>::from_node(node, src)
8157 })?,
8158 ))),
8159 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8160 }
8161 }
8162}
8163impl ::treesitter_types::Spanned for MethodDefinitionName<'_> {
8164 fn span(&self) -> ::treesitter_types::Span {
8165 match self {
8166 Self::ComputedPropertyName(inner) => inner.span(),
8167 Self::Number(inner) => inner.span(),
8168 Self::PrivatePropertyIdentifier(inner) => inner.span(),
8169 Self::PropertyIdentifier(inner) => inner.span(),
8170 Self::String(inner) => inner.span(),
8171 }
8172 }
8173}
8174#[derive(Debug, Clone, PartialEq, Eq)]
8175pub enum NamespaceExportChildren<'tree> {
8176 Identifier(::std::boxed::Box<Identifier<'tree>>),
8177 String(::std::boxed::Box<String<'tree>>),
8178}
8179impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceExportChildren<'tree> {
8180 #[allow(clippy::collapsible_else_if)]
8181 fn from_node(
8182 node: ::treesitter_types::tree_sitter::Node<'tree>,
8183 src: &'tree [u8],
8184 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8185 match node.kind() {
8186 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8187 ::treesitter_types::runtime::maybe_grow_stack(|| {
8188 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
8189 })?,
8190 ))),
8191 "string" => Ok(Self::String(::std::boxed::Box::new(
8192 ::treesitter_types::runtime::maybe_grow_stack(|| {
8193 <String as ::treesitter_types::FromNode>::from_node(node, src)
8194 })?,
8195 ))),
8196 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8197 }
8198 }
8199}
8200impl ::treesitter_types::Spanned for NamespaceExportChildren<'_> {
8201 fn span(&self) -> ::treesitter_types::Span {
8202 match self {
8203 Self::Identifier(inner) => inner.span(),
8204 Self::String(inner) => inner.span(),
8205 }
8206 }
8207}
8208#[derive(Debug, Clone, PartialEq, Eq)]
8209pub enum NewExpressionConstructor<'tree> {
8210 NewExpression(::std::boxed::Box<NewExpression<'tree>>),
8211 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
8212}
8213impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpressionConstructor<'tree> {
8214 #[allow(clippy::collapsible_else_if)]
8215 fn from_node(
8216 node: ::treesitter_types::tree_sitter::Node<'tree>,
8217 src: &'tree [u8],
8218 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8219 match node.kind() {
8220 "new_expression" => Ok(Self::NewExpression(::std::boxed::Box::new(
8221 ::treesitter_types::runtime::maybe_grow_stack(|| {
8222 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)
8223 })?,
8224 ))),
8225 _other => {
8226 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8227 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
8228 }) {
8229 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
8230 } else {
8231 Err(::treesitter_types::ParseError::unexpected_kind(
8232 _other, node,
8233 ))
8234 }
8235 }
8236 }
8237 }
8238}
8239impl ::treesitter_types::Spanned for NewExpressionConstructor<'_> {
8240 fn span(&self) -> ::treesitter_types::Span {
8241 match self {
8242 Self::NewExpression(inner) => inner.span(),
8243 Self::PrimaryExpression(inner) => inner.span(),
8244 }
8245 }
8246}
8247#[derive(Debug, Clone, PartialEq, Eq)]
8248pub enum ObjectChildren<'tree> {
8249 MethodDefinition(::std::boxed::Box<MethodDefinition<'tree>>),
8250 Pair(::std::boxed::Box<Pair<'tree>>),
8251 ShorthandPropertyIdentifier(::std::boxed::Box<ShorthandPropertyIdentifier<'tree>>),
8252 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
8253}
8254impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectChildren<'tree> {
8255 #[allow(clippy::collapsible_else_if)]
8256 fn from_node(
8257 node: ::treesitter_types::tree_sitter::Node<'tree>,
8258 src: &'tree [u8],
8259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8260 match node.kind() {
8261 "method_definition" => Ok(Self::MethodDefinition(::std::boxed::Box::new(
8262 ::treesitter_types::runtime::maybe_grow_stack(|| {
8263 <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)
8264 })?,
8265 ))),
8266 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
8267 ::treesitter_types::runtime::maybe_grow_stack(|| {
8268 <Pair as ::treesitter_types::FromNode>::from_node(node, src)
8269 })?,
8270 ))),
8271 "shorthand_property_identifier" => Ok(Self::ShorthandPropertyIdentifier(
8272 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8273 <ShorthandPropertyIdentifier as ::treesitter_types::FromNode>::from_node(
8274 node, src,
8275 )
8276 })?),
8277 )),
8278 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
8279 ::treesitter_types::runtime::maybe_grow_stack(|| {
8280 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
8281 })?,
8282 ))),
8283 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8284 }
8285 }
8286}
8287impl ::treesitter_types::Spanned for ObjectChildren<'_> {
8288 fn span(&self) -> ::treesitter_types::Span {
8289 match self {
8290 Self::MethodDefinition(inner) => inner.span(),
8291 Self::Pair(inner) => inner.span(),
8292 Self::ShorthandPropertyIdentifier(inner) => inner.span(),
8293 Self::SpreadElement(inner) => inner.span(),
8294 }
8295 }
8296}
8297#[derive(Debug, Clone, PartialEq, Eq)]
8298pub enum ObjectAssignmentPatternLeft<'tree> {
8299 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
8300 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
8301 ShorthandPropertyIdentifierPattern(
8302 ::std::boxed::Box<ShorthandPropertyIdentifierPattern<'tree>>,
8303 ),
8304}
8305impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectAssignmentPatternLeft<'tree> {
8306 #[allow(clippy::collapsible_else_if)]
8307 fn from_node(
8308 node: ::treesitter_types::tree_sitter::Node<'tree>,
8309 src: &'tree [u8],
8310 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8311 match node.kind() {
8312 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
8313 ::treesitter_types::runtime::maybe_grow_stack(|| {
8314 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
8315 })?,
8316 ))),
8317 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
8318 ::treesitter_types::runtime::maybe_grow_stack(|| {
8319 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
8320 })?,
8321 ))),
8322 "shorthand_property_identifier_pattern" => {
8323 Ok(Self::ShorthandPropertyIdentifierPattern(
8324 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8325 <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
8326 node,
8327 src,
8328 )
8329 })?),
8330 ))
8331 }
8332 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8333 }
8334 }
8335}
8336impl ::treesitter_types::Spanned for ObjectAssignmentPatternLeft<'_> {
8337 fn span(&self) -> ::treesitter_types::Span {
8338 match self {
8339 Self::ArrayPattern(inner) => inner.span(),
8340 Self::ObjectPattern(inner) => inner.span(),
8341 Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
8342 }
8343 }
8344}
8345#[derive(Debug, Clone, PartialEq, Eq)]
8346pub enum ObjectPatternChildren<'tree> {
8347 ObjectAssignmentPattern(::std::boxed::Box<ObjectAssignmentPattern<'tree>>),
8348 PairPattern(::std::boxed::Box<PairPattern<'tree>>),
8349 RestPattern(::std::boxed::Box<RestPattern<'tree>>),
8350 ShorthandPropertyIdentifierPattern(
8351 ::std::boxed::Box<ShorthandPropertyIdentifierPattern<'tree>>,
8352 ),
8353}
8354impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectPatternChildren<'tree> {
8355 #[allow(clippy::collapsible_else_if)]
8356 fn from_node(
8357 node: ::treesitter_types::tree_sitter::Node<'tree>,
8358 src: &'tree [u8],
8359 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8360 match node.kind() {
8361 "object_assignment_pattern" => Ok(Self::ObjectAssignmentPattern(
8362 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8363 <ObjectAssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
8364 })?),
8365 )),
8366 "pair_pattern" => Ok(Self::PairPattern(::std::boxed::Box::new(
8367 ::treesitter_types::runtime::maybe_grow_stack(|| {
8368 <PairPattern as ::treesitter_types::FromNode>::from_node(node, src)
8369 })?,
8370 ))),
8371 "rest_pattern" => Ok(Self::RestPattern(::std::boxed::Box::new(
8372 ::treesitter_types::runtime::maybe_grow_stack(|| {
8373 <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)
8374 })?,
8375 ))),
8376 "shorthand_property_identifier_pattern" => {
8377 Ok(Self::ShorthandPropertyIdentifierPattern(
8378 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8379 <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
8380 node,
8381 src,
8382 )
8383 })?),
8384 ))
8385 }
8386 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8387 }
8388 }
8389}
8390impl ::treesitter_types::Spanned for ObjectPatternChildren<'_> {
8391 fn span(&self) -> ::treesitter_types::Span {
8392 match self {
8393 Self::ObjectAssignmentPattern(inner) => inner.span(),
8394 Self::PairPattern(inner) => inner.span(),
8395 Self::RestPattern(inner) => inner.span(),
8396 Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
8397 }
8398 }
8399}
8400#[derive(Debug, Clone, PartialEq, Eq)]
8401pub enum PairKey<'tree> {
8402 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
8403 Number(::std::boxed::Box<Number<'tree>>),
8404 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
8405 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
8406 String(::std::boxed::Box<String<'tree>>),
8407}
8408impl<'tree> ::treesitter_types::FromNode<'tree> for PairKey<'tree> {
8409 #[allow(clippy::collapsible_else_if)]
8410 fn from_node(
8411 node: ::treesitter_types::tree_sitter::Node<'tree>,
8412 src: &'tree [u8],
8413 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8414 match node.kind() {
8415 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
8416 ::treesitter_types::runtime::maybe_grow_stack(|| {
8417 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)
8418 })?,
8419 ))),
8420 "number" => Ok(Self::Number(::std::boxed::Box::new(
8421 ::treesitter_types::runtime::maybe_grow_stack(|| {
8422 <Number as ::treesitter_types::FromNode>::from_node(node, src)
8423 })?,
8424 ))),
8425 "private_property_identifier" => Ok(Self::PrivatePropertyIdentifier(
8426 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8427 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
8428 node, src,
8429 )
8430 })?),
8431 )),
8432 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
8433 ::treesitter_types::runtime::maybe_grow_stack(|| {
8434 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
8435 })?,
8436 ))),
8437 "string" => Ok(Self::String(::std::boxed::Box::new(
8438 ::treesitter_types::runtime::maybe_grow_stack(|| {
8439 <String as ::treesitter_types::FromNode>::from_node(node, src)
8440 })?,
8441 ))),
8442 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8443 }
8444 }
8445}
8446impl ::treesitter_types::Spanned for PairKey<'_> {
8447 fn span(&self) -> ::treesitter_types::Span {
8448 match self {
8449 Self::ComputedPropertyName(inner) => inner.span(),
8450 Self::Number(inner) => inner.span(),
8451 Self::PrivatePropertyIdentifier(inner) => inner.span(),
8452 Self::PropertyIdentifier(inner) => inner.span(),
8453 Self::String(inner) => inner.span(),
8454 }
8455 }
8456}
8457#[derive(Debug, Clone, PartialEq, Eq)]
8458pub enum PairPatternKey<'tree> {
8459 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
8460 Number(::std::boxed::Box<Number<'tree>>),
8461 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
8462 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
8463 String(::std::boxed::Box<String<'tree>>),
8464}
8465impl<'tree> ::treesitter_types::FromNode<'tree> for PairPatternKey<'tree> {
8466 #[allow(clippy::collapsible_else_if)]
8467 fn from_node(
8468 node: ::treesitter_types::tree_sitter::Node<'tree>,
8469 src: &'tree [u8],
8470 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8471 match node.kind() {
8472 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
8473 ::treesitter_types::runtime::maybe_grow_stack(|| {
8474 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)
8475 })?,
8476 ))),
8477 "number" => Ok(Self::Number(::std::boxed::Box::new(
8478 ::treesitter_types::runtime::maybe_grow_stack(|| {
8479 <Number as ::treesitter_types::FromNode>::from_node(node, src)
8480 })?,
8481 ))),
8482 "private_property_identifier" => Ok(Self::PrivatePropertyIdentifier(
8483 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8484 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
8485 node, src,
8486 )
8487 })?),
8488 )),
8489 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
8490 ::treesitter_types::runtime::maybe_grow_stack(|| {
8491 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
8492 })?,
8493 ))),
8494 "string" => Ok(Self::String(::std::boxed::Box::new(
8495 ::treesitter_types::runtime::maybe_grow_stack(|| {
8496 <String as ::treesitter_types::FromNode>::from_node(node, src)
8497 })?,
8498 ))),
8499 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8500 }
8501 }
8502}
8503impl ::treesitter_types::Spanned for PairPatternKey<'_> {
8504 fn span(&self) -> ::treesitter_types::Span {
8505 match self {
8506 Self::ComputedPropertyName(inner) => inner.span(),
8507 Self::Number(inner) => inner.span(),
8508 Self::PrivatePropertyIdentifier(inner) => inner.span(),
8509 Self::PropertyIdentifier(inner) => inner.span(),
8510 Self::String(inner) => inner.span(),
8511 }
8512 }
8513}
8514#[derive(Debug, Clone, PartialEq, Eq)]
8515pub enum PairPatternValue<'tree> {
8516 AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
8517 Pattern(::std::boxed::Box<Pattern<'tree>>),
8518}
8519impl<'tree> ::treesitter_types::FromNode<'tree> for PairPatternValue<'tree> {
8520 #[allow(clippy::collapsible_else_if)]
8521 fn from_node(
8522 node: ::treesitter_types::tree_sitter::Node<'tree>,
8523 src: &'tree [u8],
8524 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8525 match node.kind() {
8526 "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
8527 ::treesitter_types::runtime::maybe_grow_stack(|| {
8528 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
8529 })?,
8530 ))),
8531 _other => {
8532 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8533 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
8534 }) {
8535 Ok(Self::Pattern(::std::boxed::Box::new(v)))
8536 } else {
8537 Err(::treesitter_types::ParseError::unexpected_kind(
8538 _other, node,
8539 ))
8540 }
8541 }
8542 }
8543 }
8544}
8545impl ::treesitter_types::Spanned for PairPatternValue<'_> {
8546 fn span(&self) -> ::treesitter_types::Span {
8547 match self {
8548 Self::AssignmentPattern(inner) => inner.span(),
8549 Self::Pattern(inner) => inner.span(),
8550 }
8551 }
8552}
8553#[derive(Debug, Clone, PartialEq, Eq)]
8554pub enum ParenthesizedExpressionChildren<'tree> {
8555 Expression(::std::boxed::Box<Expression<'tree>>),
8556 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8557}
8558impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'tree> {
8559 #[allow(clippy::collapsible_else_if)]
8560 fn from_node(
8561 node: ::treesitter_types::tree_sitter::Node<'tree>,
8562 src: &'tree [u8],
8563 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8564 match node.kind() {
8565 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8566 ::treesitter_types::runtime::maybe_grow_stack(|| {
8567 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
8568 })?,
8569 ))),
8570 _other => {
8571 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8572 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8573 }) {
8574 Ok(Self::Expression(::std::boxed::Box::new(v)))
8575 } else {
8576 Err(::treesitter_types::ParseError::unexpected_kind(
8577 _other, node,
8578 ))
8579 }
8580 }
8581 }
8582 }
8583}
8584impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
8585 fn span(&self) -> ::treesitter_types::Span {
8586 match self {
8587 Self::Expression(inner) => inner.span(),
8588 Self::SequenceExpression(inner) => inner.span(),
8589 }
8590 }
8591}
8592#[derive(Debug, Clone, PartialEq, Eq)]
8593pub enum ProgramChildren<'tree> {
8594 HashBangLine(::std::boxed::Box<HashBangLine<'tree>>),
8595 Statement(::std::boxed::Box<Statement<'tree>>),
8596}
8597impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
8598 #[allow(clippy::collapsible_else_if)]
8599 fn from_node(
8600 node: ::treesitter_types::tree_sitter::Node<'tree>,
8601 src: &'tree [u8],
8602 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8603 match node.kind() {
8604 "hash_bang_line" => Ok(Self::HashBangLine(::std::boxed::Box::new(
8605 ::treesitter_types::runtime::maybe_grow_stack(|| {
8606 <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)
8607 })?,
8608 ))),
8609 _other => {
8610 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8611 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8612 }) {
8613 Ok(Self::Statement(::std::boxed::Box::new(v)))
8614 } else {
8615 Err(::treesitter_types::ParseError::unexpected_kind(
8616 _other, node,
8617 ))
8618 }
8619 }
8620 }
8621 }
8622}
8623impl ::treesitter_types::Spanned for ProgramChildren<'_> {
8624 fn span(&self) -> ::treesitter_types::Span {
8625 match self {
8626 Self::HashBangLine(inner) => inner.span(),
8627 Self::Statement(inner) => inner.span(),
8628 }
8629 }
8630}
8631#[derive(Debug, Clone, PartialEq, Eq)]
8632pub enum RestPatternChildren<'tree> {
8633 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
8634 Identifier(::std::boxed::Box<Identifier<'tree>>),
8635 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
8636 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
8637 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
8638 Undefined(::std::boxed::Box<Undefined<'tree>>),
8639}
8640impl<'tree> ::treesitter_types::FromNode<'tree> for RestPatternChildren<'tree> {
8641 #[allow(clippy::collapsible_else_if)]
8642 fn from_node(
8643 node: ::treesitter_types::tree_sitter::Node<'tree>,
8644 src: &'tree [u8],
8645 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8646 match node.kind() {
8647 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
8648 ::treesitter_types::runtime::maybe_grow_stack(|| {
8649 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
8650 })?,
8651 ))),
8652 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8653 ::treesitter_types::runtime::maybe_grow_stack(|| {
8654 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
8655 })?,
8656 ))),
8657 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
8658 ::treesitter_types::runtime::maybe_grow_stack(|| {
8659 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
8660 })?,
8661 ))),
8662 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
8663 ::treesitter_types::runtime::maybe_grow_stack(|| {
8664 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
8665 })?,
8666 ))),
8667 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
8668 ::treesitter_types::runtime::maybe_grow_stack(|| {
8669 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
8670 })?,
8671 ))),
8672 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
8673 ::treesitter_types::runtime::maybe_grow_stack(|| {
8674 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)
8675 })?,
8676 ))),
8677 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8678 }
8679 }
8680}
8681impl ::treesitter_types::Spanned for RestPatternChildren<'_> {
8682 fn span(&self) -> ::treesitter_types::Span {
8683 match self {
8684 Self::ArrayPattern(inner) => inner.span(),
8685 Self::Identifier(inner) => inner.span(),
8686 Self::MemberExpression(inner) => inner.span(),
8687 Self::ObjectPattern(inner) => inner.span(),
8688 Self::SubscriptExpression(inner) => inner.span(),
8689 Self::Undefined(inner) => inner.span(),
8690 }
8691 }
8692}
8693#[derive(Debug, Clone, PartialEq, Eq)]
8694pub enum ReturnStatementChildren<'tree> {
8695 Expression(::std::boxed::Box<Expression<'tree>>),
8696 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8697}
8698impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatementChildren<'tree> {
8699 #[allow(clippy::collapsible_else_if)]
8700 fn from_node(
8701 node: ::treesitter_types::tree_sitter::Node<'tree>,
8702 src: &'tree [u8],
8703 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8704 match node.kind() {
8705 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8706 ::treesitter_types::runtime::maybe_grow_stack(|| {
8707 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
8708 })?,
8709 ))),
8710 _other => {
8711 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8712 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8713 }) {
8714 Ok(Self::Expression(::std::boxed::Box::new(v)))
8715 } else {
8716 Err(::treesitter_types::ParseError::unexpected_kind(
8717 _other, node,
8718 ))
8719 }
8720 }
8721 }
8722 }
8723}
8724impl ::treesitter_types::Spanned for ReturnStatementChildren<'_> {
8725 fn span(&self) -> ::treesitter_types::Span {
8726 match self {
8727 Self::Expression(inner) => inner.span(),
8728 Self::SequenceExpression(inner) => inner.span(),
8729 }
8730 }
8731}
8732#[derive(Debug, Clone, PartialEq, Eq)]
8733pub enum StringChildren<'tree> {
8734 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
8735 HtmlCharacterReference(::std::boxed::Box<HtmlCharacterReference<'tree>>),
8736 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
8737}
8738impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
8739 #[allow(clippy::collapsible_else_if)]
8740 fn from_node(
8741 node: ::treesitter_types::tree_sitter::Node<'tree>,
8742 src: &'tree [u8],
8743 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8744 match node.kind() {
8745 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
8746 ::treesitter_types::runtime::maybe_grow_stack(|| {
8747 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
8748 })?,
8749 ))),
8750 "html_character_reference" => Ok(Self::HtmlCharacterReference(::std::boxed::Box::new(
8751 ::treesitter_types::runtime::maybe_grow_stack(|| {
8752 <HtmlCharacterReference as ::treesitter_types::FromNode>::from_node(node, src)
8753 })?,
8754 ))),
8755 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
8756 ::treesitter_types::runtime::maybe_grow_stack(|| {
8757 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
8758 })?,
8759 ))),
8760 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8761 }
8762 }
8763}
8764impl ::treesitter_types::Spanned for StringChildren<'_> {
8765 fn span(&self) -> ::treesitter_types::Span {
8766 match self {
8767 Self::EscapeSequence(inner) => inner.span(),
8768 Self::HtmlCharacterReference(inner) => inner.span(),
8769 Self::StringFragment(inner) => inner.span(),
8770 }
8771 }
8772}
8773#[derive(Debug, Clone, PartialEq, Eq)]
8774pub enum SubscriptExpressionIndex<'tree> {
8775 Expression(::std::boxed::Box<Expression<'tree>>),
8776 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8777}
8778impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpressionIndex<'tree> {
8779 #[allow(clippy::collapsible_else_if)]
8780 fn from_node(
8781 node: ::treesitter_types::tree_sitter::Node<'tree>,
8782 src: &'tree [u8],
8783 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8784 match node.kind() {
8785 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8786 ::treesitter_types::runtime::maybe_grow_stack(|| {
8787 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
8788 })?,
8789 ))),
8790 _other => {
8791 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8792 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8793 }) {
8794 Ok(Self::Expression(::std::boxed::Box::new(v)))
8795 } else {
8796 Err(::treesitter_types::ParseError::unexpected_kind(
8797 _other, node,
8798 ))
8799 }
8800 }
8801 }
8802 }
8803}
8804impl ::treesitter_types::Spanned for SubscriptExpressionIndex<'_> {
8805 fn span(&self) -> ::treesitter_types::Span {
8806 match self {
8807 Self::Expression(inner) => inner.span(),
8808 Self::SequenceExpression(inner) => inner.span(),
8809 }
8810 }
8811}
8812#[derive(Debug, Clone, PartialEq, Eq)]
8813pub enum SwitchBodyChildren<'tree> {
8814 SwitchCase(::std::boxed::Box<SwitchCase<'tree>>),
8815 SwitchDefault(::std::boxed::Box<SwitchDefault<'tree>>),
8816}
8817impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBodyChildren<'tree> {
8818 #[allow(clippy::collapsible_else_if)]
8819 fn from_node(
8820 node: ::treesitter_types::tree_sitter::Node<'tree>,
8821 src: &'tree [u8],
8822 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8823 match node.kind() {
8824 "switch_case" => Ok(Self::SwitchCase(::std::boxed::Box::new(
8825 ::treesitter_types::runtime::maybe_grow_stack(|| {
8826 <SwitchCase as ::treesitter_types::FromNode>::from_node(node, src)
8827 })?,
8828 ))),
8829 "switch_default" => Ok(Self::SwitchDefault(::std::boxed::Box::new(
8830 ::treesitter_types::runtime::maybe_grow_stack(|| {
8831 <SwitchDefault as ::treesitter_types::FromNode>::from_node(node, src)
8832 })?,
8833 ))),
8834 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8835 }
8836 }
8837}
8838impl ::treesitter_types::Spanned for SwitchBodyChildren<'_> {
8839 fn span(&self) -> ::treesitter_types::Span {
8840 match self {
8841 Self::SwitchCase(inner) => inner.span(),
8842 Self::SwitchDefault(inner) => inner.span(),
8843 }
8844 }
8845}
8846#[derive(Debug, Clone, PartialEq, Eq)]
8847pub enum SwitchCaseValue<'tree> {
8848 Expression(::std::boxed::Box<Expression<'tree>>),
8849 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8850}
8851impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchCaseValue<'tree> {
8852 #[allow(clippy::collapsible_else_if)]
8853 fn from_node(
8854 node: ::treesitter_types::tree_sitter::Node<'tree>,
8855 src: &'tree [u8],
8856 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8857 match node.kind() {
8858 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8859 ::treesitter_types::runtime::maybe_grow_stack(|| {
8860 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
8861 })?,
8862 ))),
8863 _other => {
8864 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8865 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8866 }) {
8867 Ok(Self::Expression(::std::boxed::Box::new(v)))
8868 } else {
8869 Err(::treesitter_types::ParseError::unexpected_kind(
8870 _other, node,
8871 ))
8872 }
8873 }
8874 }
8875 }
8876}
8877impl ::treesitter_types::Spanned for SwitchCaseValue<'_> {
8878 fn span(&self) -> ::treesitter_types::Span {
8879 match self {
8880 Self::Expression(inner) => inner.span(),
8881 Self::SequenceExpression(inner) => inner.span(),
8882 }
8883 }
8884}
8885#[derive(Debug, Clone, PartialEq, Eq)]
8886pub enum TemplateStringChildren<'tree> {
8887 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
8888 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
8889 TemplateSubstitution(::std::boxed::Box<TemplateSubstitution<'tree>>),
8890}
8891impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateStringChildren<'tree> {
8892 #[allow(clippy::collapsible_else_if)]
8893 fn from_node(
8894 node: ::treesitter_types::tree_sitter::Node<'tree>,
8895 src: &'tree [u8],
8896 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8897 match node.kind() {
8898 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
8899 ::treesitter_types::runtime::maybe_grow_stack(|| {
8900 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
8901 })?,
8902 ))),
8903 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
8904 ::treesitter_types::runtime::maybe_grow_stack(|| {
8905 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
8906 })?,
8907 ))),
8908 "template_substitution" => Ok(Self::TemplateSubstitution(::std::boxed::Box::new(
8909 ::treesitter_types::runtime::maybe_grow_stack(|| {
8910 <TemplateSubstitution as ::treesitter_types::FromNode>::from_node(node, src)
8911 })?,
8912 ))),
8913 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8914 }
8915 }
8916}
8917impl ::treesitter_types::Spanned for TemplateStringChildren<'_> {
8918 fn span(&self) -> ::treesitter_types::Span {
8919 match self {
8920 Self::EscapeSequence(inner) => inner.span(),
8921 Self::StringFragment(inner) => inner.span(),
8922 Self::TemplateSubstitution(inner) => inner.span(),
8923 }
8924 }
8925}
8926#[derive(Debug, Clone, PartialEq, Eq)]
8927pub enum TemplateSubstitutionChildren<'tree> {
8928 Expression(::std::boxed::Box<Expression<'tree>>),
8929 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8930}
8931impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateSubstitutionChildren<'tree> {
8932 #[allow(clippy::collapsible_else_if)]
8933 fn from_node(
8934 node: ::treesitter_types::tree_sitter::Node<'tree>,
8935 src: &'tree [u8],
8936 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8937 match node.kind() {
8938 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8939 ::treesitter_types::runtime::maybe_grow_stack(|| {
8940 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
8941 })?,
8942 ))),
8943 _other => {
8944 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8945 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8946 }) {
8947 Ok(Self::Expression(::std::boxed::Box::new(v)))
8948 } else {
8949 Err(::treesitter_types::ParseError::unexpected_kind(
8950 _other, node,
8951 ))
8952 }
8953 }
8954 }
8955 }
8956}
8957impl ::treesitter_types::Spanned for TemplateSubstitutionChildren<'_> {
8958 fn span(&self) -> ::treesitter_types::Span {
8959 match self {
8960 Self::Expression(inner) => inner.span(),
8961 Self::SequenceExpression(inner) => inner.span(),
8962 }
8963 }
8964}
8965#[derive(Debug, Clone, PartialEq, Eq)]
8966pub enum ThrowStatementChildren<'tree> {
8967 Expression(::std::boxed::Box<Expression<'tree>>),
8968 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8969}
8970impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatementChildren<'tree> {
8971 #[allow(clippy::collapsible_else_if)]
8972 fn from_node(
8973 node: ::treesitter_types::tree_sitter::Node<'tree>,
8974 src: &'tree [u8],
8975 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8976 match node.kind() {
8977 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8978 ::treesitter_types::runtime::maybe_grow_stack(|| {
8979 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
8980 })?,
8981 ))),
8982 _other => {
8983 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8984 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8985 }) {
8986 Ok(Self::Expression(::std::boxed::Box::new(v)))
8987 } else {
8988 Err(::treesitter_types::ParseError::unexpected_kind(
8989 _other, node,
8990 ))
8991 }
8992 }
8993 }
8994 }
8995}
8996impl ::treesitter_types::Spanned for ThrowStatementChildren<'_> {
8997 fn span(&self) -> ::treesitter_types::Span {
8998 match self {
8999 Self::Expression(inner) => inner.span(),
9000 Self::SequenceExpression(inner) => inner.span(),
9001 }
9002 }
9003}
9004#[derive(Debug, Clone, PartialEq, Eq)]
9005pub enum UnaryExpressionOperator {
9006 Bang(::treesitter_types::Span),
9007 Plus(::treesitter_types::Span),
9008 Minus(::treesitter_types::Span),
9009 Delete(::treesitter_types::Span),
9010 Typeof(::treesitter_types::Span),
9011 Void(::treesitter_types::Span),
9012 Tilde(::treesitter_types::Span),
9013}
9014impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
9015 #[allow(clippy::collapsible_else_if)]
9016 fn from_node(
9017 node: ::treesitter_types::tree_sitter::Node<'tree>,
9018 _src: &'tree [u8],
9019 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9020 match node.kind() {
9021 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
9022 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
9023 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
9024 "delete" => Ok(Self::Delete(::treesitter_types::Span::from(node))),
9025 "typeof" => Ok(Self::Typeof(::treesitter_types::Span::from(node))),
9026 "void" => Ok(Self::Void(::treesitter_types::Span::from(node))),
9027 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
9028 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9029 }
9030 }
9031}
9032impl ::treesitter_types::Spanned for UnaryExpressionOperator {
9033 fn span(&self) -> ::treesitter_types::Span {
9034 match self {
9035 Self::Bang(span) => *span,
9036 Self::Plus(span) => *span,
9037 Self::Minus(span) => *span,
9038 Self::Delete(span) => *span,
9039 Self::Typeof(span) => *span,
9040 Self::Void(span) => *span,
9041 Self::Tilde(span) => *span,
9042 }
9043 }
9044}
9045#[derive(Debug, Clone, PartialEq, Eq)]
9046pub enum UpdateExpressionOperator {
9047 PlusPlus(::treesitter_types::Span),
9048 MinusMinus(::treesitter_types::Span),
9049}
9050impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionOperator {
9051 #[allow(clippy::collapsible_else_if)]
9052 fn from_node(
9053 node: ::treesitter_types::tree_sitter::Node<'tree>,
9054 _src: &'tree [u8],
9055 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9056 match node.kind() {
9057 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
9058 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
9059 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9060 }
9061 }
9062}
9063impl ::treesitter_types::Spanned for UpdateExpressionOperator {
9064 fn span(&self) -> ::treesitter_types::Span {
9065 match self {
9066 Self::PlusPlus(span) => *span,
9067 Self::MinusMinus(span) => *span,
9068 }
9069 }
9070}
9071#[derive(Debug, Clone, PartialEq, Eq)]
9072pub enum UsingDeclarationKind {
9073 Await(::treesitter_types::Span),
9074 Using(::treesitter_types::Span),
9075}
9076impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDeclarationKind {
9077 #[allow(clippy::collapsible_else_if)]
9078 fn from_node(
9079 node: ::treesitter_types::tree_sitter::Node<'tree>,
9080 _src: &'tree [u8],
9081 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9082 match node.kind() {
9083 "await" => Ok(Self::Await(::treesitter_types::Span::from(node))),
9084 "using" => Ok(Self::Using(::treesitter_types::Span::from(node))),
9085 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9086 }
9087 }
9088}
9089impl ::treesitter_types::Spanned for UsingDeclarationKind {
9090 fn span(&self) -> ::treesitter_types::Span {
9091 match self {
9092 Self::Await(span) => *span,
9093 Self::Using(span) => *span,
9094 }
9095 }
9096}
9097#[derive(Debug, Clone, PartialEq, Eq)]
9098pub enum VariableDeclaratorName<'tree> {
9099 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
9100 Identifier(::std::boxed::Box<Identifier<'tree>>),
9101 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
9102}
9103impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorName<'tree> {
9104 #[allow(clippy::collapsible_else_if)]
9105 fn from_node(
9106 node: ::treesitter_types::tree_sitter::Node<'tree>,
9107 src: &'tree [u8],
9108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9109 match node.kind() {
9110 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
9111 ::treesitter_types::runtime::maybe_grow_stack(|| {
9112 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
9113 })?,
9114 ))),
9115 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9116 ::treesitter_types::runtime::maybe_grow_stack(|| {
9117 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9118 })?,
9119 ))),
9120 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
9121 ::treesitter_types::runtime::maybe_grow_stack(|| {
9122 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
9123 })?,
9124 ))),
9125 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9126 }
9127 }
9128}
9129impl ::treesitter_types::Spanned for VariableDeclaratorName<'_> {
9130 fn span(&self) -> ::treesitter_types::Span {
9131 match self {
9132 Self::ArrayPattern(inner) => inner.span(),
9133 Self::Identifier(inner) => inner.span(),
9134 Self::ObjectPattern(inner) => inner.span(),
9135 }
9136 }
9137}
9138#[derive(Debug, Clone, PartialEq, Eq)]
9139pub enum AnyNode<'tree> {
9140 Declaration(Declaration<'tree>),
9141 Expression(Expression<'tree>),
9142 Pattern(Pattern<'tree>),
9143 PrimaryExpression(PrimaryExpression<'tree>),
9144 Statement(Statement<'tree>),
9145 Arguments(Arguments<'tree>),
9146 Array(Array<'tree>),
9147 ArrayPattern(ArrayPattern<'tree>),
9148 ArrowFunction(ArrowFunction<'tree>),
9149 AssignmentExpression(AssignmentExpression<'tree>),
9150 AssignmentPattern(AssignmentPattern<'tree>),
9151 AugmentedAssignmentExpression(AugmentedAssignmentExpression<'tree>),
9152 AwaitExpression(AwaitExpression<'tree>),
9153 BinaryExpression(BinaryExpression<'tree>),
9154 BreakStatement(BreakStatement<'tree>),
9155 CallExpression(CallExpression<'tree>),
9156 CatchClause(CatchClause<'tree>),
9157 Class(Class<'tree>),
9158 ClassBody(ClassBody<'tree>),
9159 ClassDeclaration(ClassDeclaration<'tree>),
9160 ClassHeritage(ClassHeritage<'tree>),
9161 ClassStaticBlock(ClassStaticBlock<'tree>),
9162 ComputedPropertyName(ComputedPropertyName<'tree>),
9163 ContinueStatement(ContinueStatement<'tree>),
9164 DebuggerStatement(DebuggerStatement<'tree>),
9165 Decorator(Decorator<'tree>),
9166 DoStatement(DoStatement<'tree>),
9167 ElseClause(ElseClause<'tree>),
9168 EmptyStatement(EmptyStatement<'tree>),
9169 ExportClause(ExportClause<'tree>),
9170 ExportSpecifier(ExportSpecifier<'tree>),
9171 ExportStatement(ExportStatement<'tree>),
9172 ExpressionStatement(ExpressionStatement<'tree>),
9173 FieldDefinition(FieldDefinition<'tree>),
9174 FinallyClause(FinallyClause<'tree>),
9175 ForInStatement(ForInStatement<'tree>),
9176 ForStatement(ForStatement<'tree>),
9177 FormalParameters(FormalParameters<'tree>),
9178 FunctionDeclaration(FunctionDeclaration<'tree>),
9179 FunctionExpression(FunctionExpression<'tree>),
9180 GeneratorFunction(GeneratorFunction<'tree>),
9181 GeneratorFunctionDeclaration(GeneratorFunctionDeclaration<'tree>),
9182 IfStatement(IfStatement<'tree>),
9183 Import(Import<'tree>),
9184 ImportAttribute(ImportAttribute<'tree>),
9185 ImportClause(ImportClause<'tree>),
9186 ImportSpecifier(ImportSpecifier<'tree>),
9187 ImportStatement(ImportStatement<'tree>),
9188 JsxAttribute(JsxAttribute<'tree>),
9189 JsxClosingElement(JsxClosingElement<'tree>),
9190 JsxElement(JsxElement<'tree>),
9191 JsxExpression(JsxExpression<'tree>),
9192 JsxNamespaceName(JsxNamespaceName<'tree>),
9193 JsxOpeningElement(JsxOpeningElement<'tree>),
9194 JsxSelfClosingElement(JsxSelfClosingElement<'tree>),
9195 LabeledStatement(LabeledStatement<'tree>),
9196 LexicalDeclaration(LexicalDeclaration<'tree>),
9197 MemberExpression(MemberExpression<'tree>),
9198 MetaProperty(MetaProperty<'tree>),
9199 MethodDefinition(MethodDefinition<'tree>),
9200 NamedImports(NamedImports<'tree>),
9201 NamespaceExport(NamespaceExport<'tree>),
9202 NamespaceImport(NamespaceImport<'tree>),
9203 NewExpression(NewExpression<'tree>),
9204 Object(Object<'tree>),
9205 ObjectAssignmentPattern(ObjectAssignmentPattern<'tree>),
9206 ObjectPattern(ObjectPattern<'tree>),
9207 Pair(Pair<'tree>),
9208 PairPattern(PairPattern<'tree>),
9209 ParenthesizedExpression(ParenthesizedExpression<'tree>),
9210 Program(Program<'tree>),
9211 Regex(Regex<'tree>),
9212 RestPattern(RestPattern<'tree>),
9213 ReturnStatement(ReturnStatement<'tree>),
9214 SequenceExpression(SequenceExpression<'tree>),
9215 SpreadElement(SpreadElement<'tree>),
9216 StatementBlock(StatementBlock<'tree>),
9217 String(String<'tree>),
9218 SubscriptExpression(SubscriptExpression<'tree>),
9219 SwitchBody(SwitchBody<'tree>),
9220 SwitchCase(SwitchCase<'tree>),
9221 SwitchDefault(SwitchDefault<'tree>),
9222 SwitchStatement(SwitchStatement<'tree>),
9223 TemplateString(TemplateString<'tree>),
9224 TemplateSubstitution(TemplateSubstitution<'tree>),
9225 TernaryExpression(TernaryExpression<'tree>),
9226 ThrowStatement(ThrowStatement<'tree>),
9227 TryStatement(TryStatement<'tree>),
9228 UnaryExpression(UnaryExpression<'tree>),
9229 UpdateExpression(UpdateExpression<'tree>),
9230 UsingDeclaration(UsingDeclaration<'tree>),
9231 VariableDeclaration(VariableDeclaration<'tree>),
9232 VariableDeclarator(VariableDeclarator<'tree>),
9233 WhileStatement(WhileStatement<'tree>),
9234 WithStatement(WithStatement<'tree>),
9235 YieldExpression(YieldExpression<'tree>),
9236 Comment(Comment<'tree>),
9237 EscapeSequence(EscapeSequence<'tree>),
9238 False(False<'tree>),
9239 HashBangLine(HashBangLine<'tree>),
9240 HtmlCharacterReference(HtmlCharacterReference<'tree>),
9241 HtmlComment(HtmlComment<'tree>),
9242 Identifier(Identifier<'tree>),
9243 JsxText(JsxText<'tree>),
9244 Null(Null<'tree>),
9245 Number(Number<'tree>),
9246 OptionalChain(OptionalChain<'tree>),
9247 PrivatePropertyIdentifier(PrivatePropertyIdentifier<'tree>),
9248 PropertyIdentifier(PropertyIdentifier<'tree>),
9249 RegexFlags(RegexFlags<'tree>),
9250 RegexPattern(RegexPattern<'tree>),
9251 ShorthandPropertyIdentifier(ShorthandPropertyIdentifier<'tree>),
9252 ShorthandPropertyIdentifierPattern(ShorthandPropertyIdentifierPattern<'tree>),
9253 StatementIdentifier(StatementIdentifier<'tree>),
9254 StringFragment(StringFragment<'tree>),
9255 Super(Super<'tree>),
9256 This(This<'tree>),
9257 True(True<'tree>),
9258 Undefined(Undefined<'tree>),
9259 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
9260}
9261impl<'tree> AnyNode<'tree> {
9262 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
9263 match node.kind() {
9264 "declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9265 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
9266 })
9267 .map(Self::Declaration)
9268 .unwrap_or(Self::Unknown(node)),
9269 "expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9270 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9271 })
9272 .map(Self::Expression)
9273 .unwrap_or(Self::Unknown(node)),
9274 "pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9275 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
9276 })
9277 .map(Self::Pattern)
9278 .unwrap_or(Self::Unknown(node)),
9279 "primary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9280 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9281 })
9282 .map(Self::PrimaryExpression)
9283 .unwrap_or(Self::Unknown(node)),
9284 "statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9285 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
9286 })
9287 .map(Self::Statement)
9288 .unwrap_or(Self::Unknown(node)),
9289 "arguments" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9290 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
9291 })
9292 .map(Self::Arguments)
9293 .unwrap_or(Self::Unknown(node)),
9294 "array" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9295 <Array as ::treesitter_types::FromNode>::from_node(node, src)
9296 })
9297 .map(Self::Array)
9298 .unwrap_or(Self::Unknown(node)),
9299 "array_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9300 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
9301 })
9302 .map(Self::ArrayPattern)
9303 .unwrap_or(Self::Unknown(node)),
9304 "arrow_function" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9305 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)
9306 })
9307 .map(Self::ArrowFunction)
9308 .unwrap_or(Self::Unknown(node)),
9309 "assignment_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9310 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
9311 })
9312 .map(Self::AssignmentExpression)
9313 .unwrap_or(Self::Unknown(node)),
9314 "assignment_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9315 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
9316 })
9317 .map(Self::AssignmentPattern)
9318 .unwrap_or(Self::Unknown(node)),
9319 "augmented_assignment_expression" => {
9320 ::treesitter_types::runtime::maybe_grow_stack(|| {
9321 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
9322 node, src,
9323 )
9324 })
9325 .map(Self::AugmentedAssignmentExpression)
9326 .unwrap_or(Self::Unknown(node))
9327 }
9328 "await_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9329 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
9330 })
9331 .map(Self::AwaitExpression)
9332 .unwrap_or(Self::Unknown(node)),
9333 "binary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9334 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9335 })
9336 .map(Self::BinaryExpression)
9337 .unwrap_or(Self::Unknown(node)),
9338 "break_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9339 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
9340 })
9341 .map(Self::BreakStatement)
9342 .unwrap_or(Self::Unknown(node)),
9343 "call_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9344 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
9345 })
9346 .map(Self::CallExpression)
9347 .unwrap_or(Self::Unknown(node)),
9348 "catch_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9349 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
9350 })
9351 .map(Self::CatchClause)
9352 .unwrap_or(Self::Unknown(node)),
9353 "class" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9354 <Class as ::treesitter_types::FromNode>::from_node(node, src)
9355 })
9356 .map(Self::Class)
9357 .unwrap_or(Self::Unknown(node)),
9358 "class_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9359 <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)
9360 })
9361 .map(Self::ClassBody)
9362 .unwrap_or(Self::Unknown(node)),
9363 "class_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9364 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9365 })
9366 .map(Self::ClassDeclaration)
9367 .unwrap_or(Self::Unknown(node)),
9368 "class_heritage" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9369 <ClassHeritage as ::treesitter_types::FromNode>::from_node(node, src)
9370 })
9371 .map(Self::ClassHeritage)
9372 .unwrap_or(Self::Unknown(node)),
9373 "class_static_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9374 <ClassStaticBlock as ::treesitter_types::FromNode>::from_node(node, src)
9375 })
9376 .map(Self::ClassStaticBlock)
9377 .unwrap_or(Self::Unknown(node)),
9378 "computed_property_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9379 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)
9380 })
9381 .map(Self::ComputedPropertyName)
9382 .unwrap_or(Self::Unknown(node)),
9383 "continue_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9384 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
9385 })
9386 .map(Self::ContinueStatement)
9387 .unwrap_or(Self::Unknown(node)),
9388 "debugger_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9389 <DebuggerStatement as ::treesitter_types::FromNode>::from_node(node, src)
9390 })
9391 .map(Self::DebuggerStatement)
9392 .unwrap_or(Self::Unknown(node)),
9393 "decorator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9394 <Decorator as ::treesitter_types::FromNode>::from_node(node, src)
9395 })
9396 .map(Self::Decorator)
9397 .unwrap_or(Self::Unknown(node)),
9398 "do_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9399 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
9400 })
9401 .map(Self::DoStatement)
9402 .unwrap_or(Self::Unknown(node)),
9403 "else_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9404 <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
9405 })
9406 .map(Self::ElseClause)
9407 .unwrap_or(Self::Unknown(node)),
9408 "empty_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9409 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
9410 })
9411 .map(Self::EmptyStatement)
9412 .unwrap_or(Self::Unknown(node)),
9413 "export_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9414 <ExportClause as ::treesitter_types::FromNode>::from_node(node, src)
9415 })
9416 .map(Self::ExportClause)
9417 .unwrap_or(Self::Unknown(node)),
9418 "export_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9419 <ExportSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
9420 })
9421 .map(Self::ExportSpecifier)
9422 .unwrap_or(Self::Unknown(node)),
9423 "export_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9424 <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)
9425 })
9426 .map(Self::ExportStatement)
9427 .unwrap_or(Self::Unknown(node)),
9428 "expression_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9429 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
9430 })
9431 .map(Self::ExpressionStatement)
9432 .unwrap_or(Self::Unknown(node)),
9433 "field_definition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9434 <FieldDefinition as ::treesitter_types::FromNode>::from_node(node, src)
9435 })
9436 .map(Self::FieldDefinition)
9437 .unwrap_or(Self::Unknown(node)),
9438 "finally_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9439 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
9440 })
9441 .map(Self::FinallyClause)
9442 .unwrap_or(Self::Unknown(node)),
9443 "for_in_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9444 <ForInStatement as ::treesitter_types::FromNode>::from_node(node, src)
9445 })
9446 .map(Self::ForInStatement)
9447 .unwrap_or(Self::Unknown(node)),
9448 "for_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9449 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
9450 })
9451 .map(Self::ForStatement)
9452 .unwrap_or(Self::Unknown(node)),
9453 "formal_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9454 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
9455 })
9456 .map(Self::FormalParameters)
9457 .unwrap_or(Self::Unknown(node)),
9458 "function_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9459 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9460 })
9461 .map(Self::FunctionDeclaration)
9462 .unwrap_or(Self::Unknown(node)),
9463 "function_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9464 <FunctionExpression as ::treesitter_types::FromNode>::from_node(node, src)
9465 })
9466 .map(Self::FunctionExpression)
9467 .unwrap_or(Self::Unknown(node)),
9468 "generator_function" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9469 <GeneratorFunction as ::treesitter_types::FromNode>::from_node(node, src)
9470 })
9471 .map(Self::GeneratorFunction)
9472 .unwrap_or(Self::Unknown(node)),
9473 "generator_function_declaration" => {
9474 ::treesitter_types::runtime::maybe_grow_stack(|| {
9475 <GeneratorFunctionDeclaration as ::treesitter_types::FromNode>::from_node(
9476 node, src,
9477 )
9478 })
9479 .map(Self::GeneratorFunctionDeclaration)
9480 .unwrap_or(Self::Unknown(node))
9481 }
9482 "if_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9483 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
9484 })
9485 .map(Self::IfStatement)
9486 .unwrap_or(Self::Unknown(node)),
9487 "import" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9488 <Import as ::treesitter_types::FromNode>::from_node(node, src)
9489 })
9490 .map(Self::Import)
9491 .unwrap_or(Self::Unknown(node)),
9492 "import_attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9493 <ImportAttribute as ::treesitter_types::FromNode>::from_node(node, src)
9494 })
9495 .map(Self::ImportAttribute)
9496 .unwrap_or(Self::Unknown(node)),
9497 "import_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9498 <ImportClause as ::treesitter_types::FromNode>::from_node(node, src)
9499 })
9500 .map(Self::ImportClause)
9501 .unwrap_or(Self::Unknown(node)),
9502 "import_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9503 <ImportSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
9504 })
9505 .map(Self::ImportSpecifier)
9506 .unwrap_or(Self::Unknown(node)),
9507 "import_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9508 <ImportStatement as ::treesitter_types::FromNode>::from_node(node, src)
9509 })
9510 .map(Self::ImportStatement)
9511 .unwrap_or(Self::Unknown(node)),
9512 "jsx_attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9513 <JsxAttribute as ::treesitter_types::FromNode>::from_node(node, src)
9514 })
9515 .map(Self::JsxAttribute)
9516 .unwrap_or(Self::Unknown(node)),
9517 "jsx_closing_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9518 <JsxClosingElement as ::treesitter_types::FromNode>::from_node(node, src)
9519 })
9520 .map(Self::JsxClosingElement)
9521 .unwrap_or(Self::Unknown(node)),
9522 "jsx_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9523 <JsxElement as ::treesitter_types::FromNode>::from_node(node, src)
9524 })
9525 .map(Self::JsxElement)
9526 .unwrap_or(Self::Unknown(node)),
9527 "jsx_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9528 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)
9529 })
9530 .map(Self::JsxExpression)
9531 .unwrap_or(Self::Unknown(node)),
9532 "jsx_namespace_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9533 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
9534 })
9535 .map(Self::JsxNamespaceName)
9536 .unwrap_or(Self::Unknown(node)),
9537 "jsx_opening_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9538 <JsxOpeningElement as ::treesitter_types::FromNode>::from_node(node, src)
9539 })
9540 .map(Self::JsxOpeningElement)
9541 .unwrap_or(Self::Unknown(node)),
9542 "jsx_self_closing_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9543 <JsxSelfClosingElement as ::treesitter_types::FromNode>::from_node(node, src)
9544 })
9545 .map(Self::JsxSelfClosingElement)
9546 .unwrap_or(Self::Unknown(node)),
9547 "labeled_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9548 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
9549 })
9550 .map(Self::LabeledStatement)
9551 .unwrap_or(Self::Unknown(node)),
9552 "lexical_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9553 <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9554 })
9555 .map(Self::LexicalDeclaration)
9556 .unwrap_or(Self::Unknown(node)),
9557 "member_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9558 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
9559 })
9560 .map(Self::MemberExpression)
9561 .unwrap_or(Self::Unknown(node)),
9562 "meta_property" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9563 <MetaProperty as ::treesitter_types::FromNode>::from_node(node, src)
9564 })
9565 .map(Self::MetaProperty)
9566 .unwrap_or(Self::Unknown(node)),
9567 "method_definition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9568 <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)
9569 })
9570 .map(Self::MethodDefinition)
9571 .unwrap_or(Self::Unknown(node)),
9572 "named_imports" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9573 <NamedImports as ::treesitter_types::FromNode>::from_node(node, src)
9574 })
9575 .map(Self::NamedImports)
9576 .unwrap_or(Self::Unknown(node)),
9577 "namespace_export" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9578 <NamespaceExport as ::treesitter_types::FromNode>::from_node(node, src)
9579 })
9580 .map(Self::NamespaceExport)
9581 .unwrap_or(Self::Unknown(node)),
9582 "namespace_import" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9583 <NamespaceImport as ::treesitter_types::FromNode>::from_node(node, src)
9584 })
9585 .map(Self::NamespaceImport)
9586 .unwrap_or(Self::Unknown(node)),
9587 "new_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9588 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)
9589 })
9590 .map(Self::NewExpression)
9591 .unwrap_or(Self::Unknown(node)),
9592 "object" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9593 <Object as ::treesitter_types::FromNode>::from_node(node, src)
9594 })
9595 .map(Self::Object)
9596 .unwrap_or(Self::Unknown(node)),
9597 "object_assignment_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9598 <ObjectAssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
9599 })
9600 .map(Self::ObjectAssignmentPattern)
9601 .unwrap_or(Self::Unknown(node)),
9602 "object_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9603 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
9604 })
9605 .map(Self::ObjectPattern)
9606 .unwrap_or(Self::Unknown(node)),
9607 "pair" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9608 <Pair as ::treesitter_types::FromNode>::from_node(node, src)
9609 })
9610 .map(Self::Pair)
9611 .unwrap_or(Self::Unknown(node)),
9612 "pair_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9613 <PairPattern as ::treesitter_types::FromNode>::from_node(node, src)
9614 })
9615 .map(Self::PairPattern)
9616 .unwrap_or(Self::Unknown(node)),
9617 "parenthesized_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9618 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
9619 })
9620 .map(Self::ParenthesizedExpression)
9621 .unwrap_or(Self::Unknown(node)),
9622 "program" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9623 <Program as ::treesitter_types::FromNode>::from_node(node, src)
9624 })
9625 .map(Self::Program)
9626 .unwrap_or(Self::Unknown(node)),
9627 "regex" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9628 <Regex as ::treesitter_types::FromNode>::from_node(node, src)
9629 })
9630 .map(Self::Regex)
9631 .unwrap_or(Self::Unknown(node)),
9632 "rest_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9633 <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)
9634 })
9635 .map(Self::RestPattern)
9636 .unwrap_or(Self::Unknown(node)),
9637 "return_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9638 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
9639 })
9640 .map(Self::ReturnStatement)
9641 .unwrap_or(Self::Unknown(node)),
9642 "sequence_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9643 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
9644 })
9645 .map(Self::SequenceExpression)
9646 .unwrap_or(Self::Unknown(node)),
9647 "spread_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9648 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
9649 })
9650 .map(Self::SpreadElement)
9651 .unwrap_or(Self::Unknown(node)),
9652 "statement_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9653 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)
9654 })
9655 .map(Self::StatementBlock)
9656 .unwrap_or(Self::Unknown(node)),
9657 "string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9658 <String as ::treesitter_types::FromNode>::from_node(node, src)
9659 })
9660 .map(Self::String)
9661 .unwrap_or(Self::Unknown(node)),
9662 "subscript_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9663 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
9664 })
9665 .map(Self::SubscriptExpression)
9666 .unwrap_or(Self::Unknown(node)),
9667 "switch_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9668 <SwitchBody as ::treesitter_types::FromNode>::from_node(node, src)
9669 })
9670 .map(Self::SwitchBody)
9671 .unwrap_or(Self::Unknown(node)),
9672 "switch_case" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9673 <SwitchCase as ::treesitter_types::FromNode>::from_node(node, src)
9674 })
9675 .map(Self::SwitchCase)
9676 .unwrap_or(Self::Unknown(node)),
9677 "switch_default" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9678 <SwitchDefault as ::treesitter_types::FromNode>::from_node(node, src)
9679 })
9680 .map(Self::SwitchDefault)
9681 .unwrap_or(Self::Unknown(node)),
9682 "switch_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9683 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
9684 })
9685 .map(Self::SwitchStatement)
9686 .unwrap_or(Self::Unknown(node)),
9687 "template_string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9688 <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)
9689 })
9690 .map(Self::TemplateString)
9691 .unwrap_or(Self::Unknown(node)),
9692 "template_substitution" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9693 <TemplateSubstitution as ::treesitter_types::FromNode>::from_node(node, src)
9694 })
9695 .map(Self::TemplateSubstitution)
9696 .unwrap_or(Self::Unknown(node)),
9697 "ternary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9698 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9699 })
9700 .map(Self::TernaryExpression)
9701 .unwrap_or(Self::Unknown(node)),
9702 "throw_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9703 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
9704 })
9705 .map(Self::ThrowStatement)
9706 .unwrap_or(Self::Unknown(node)),
9707 "try_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9708 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
9709 })
9710 .map(Self::TryStatement)
9711 .unwrap_or(Self::Unknown(node)),
9712 "unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9713 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9714 })
9715 .map(Self::UnaryExpression)
9716 .unwrap_or(Self::Unknown(node)),
9717 "update_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9718 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
9719 })
9720 .map(Self::UpdateExpression)
9721 .unwrap_or(Self::Unknown(node)),
9722 "using_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9723 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9724 })
9725 .map(Self::UsingDeclaration)
9726 .unwrap_or(Self::Unknown(node)),
9727 "variable_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9728 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9729 })
9730 .map(Self::VariableDeclaration)
9731 .unwrap_or(Self::Unknown(node)),
9732 "variable_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9733 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
9734 })
9735 .map(Self::VariableDeclarator)
9736 .unwrap_or(Self::Unknown(node)),
9737 "while_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9738 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
9739 })
9740 .map(Self::WhileStatement)
9741 .unwrap_or(Self::Unknown(node)),
9742 "with_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9743 <WithStatement as ::treesitter_types::FromNode>::from_node(node, src)
9744 })
9745 .map(Self::WithStatement)
9746 .unwrap_or(Self::Unknown(node)),
9747 "yield_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9748 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
9749 })
9750 .map(Self::YieldExpression)
9751 .unwrap_or(Self::Unknown(node)),
9752 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9753 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
9754 })
9755 .map(Self::Comment)
9756 .unwrap_or(Self::Unknown(node)),
9757 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9758 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
9759 })
9760 .map(Self::EscapeSequence)
9761 .unwrap_or(Self::Unknown(node)),
9762 "false" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9763 <False as ::treesitter_types::FromNode>::from_node(node, src)
9764 })
9765 .map(Self::False)
9766 .unwrap_or(Self::Unknown(node)),
9767 "hash_bang_line" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9768 <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)
9769 })
9770 .map(Self::HashBangLine)
9771 .unwrap_or(Self::Unknown(node)),
9772 "html_character_reference" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9773 <HtmlCharacterReference as ::treesitter_types::FromNode>::from_node(node, src)
9774 })
9775 .map(Self::HtmlCharacterReference)
9776 .unwrap_or(Self::Unknown(node)),
9777 "html_comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9778 <HtmlComment as ::treesitter_types::FromNode>::from_node(node, src)
9779 })
9780 .map(Self::HtmlComment)
9781 .unwrap_or(Self::Unknown(node)),
9782 "identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9783 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9784 })
9785 .map(Self::Identifier)
9786 .unwrap_or(Self::Unknown(node)),
9787 "jsx_text" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9788 <JsxText as ::treesitter_types::FromNode>::from_node(node, src)
9789 })
9790 .map(Self::JsxText)
9791 .unwrap_or(Self::Unknown(node)),
9792 "null" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9793 <Null as ::treesitter_types::FromNode>::from_node(node, src)
9794 })
9795 .map(Self::Null)
9796 .unwrap_or(Self::Unknown(node)),
9797 "number" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9798 <Number as ::treesitter_types::FromNode>::from_node(node, src)
9799 })
9800 .map(Self::Number)
9801 .unwrap_or(Self::Unknown(node)),
9802 "optional_chain" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9803 <OptionalChain as ::treesitter_types::FromNode>::from_node(node, src)
9804 })
9805 .map(Self::OptionalChain)
9806 .unwrap_or(Self::Unknown(node)),
9807 "private_property_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9808 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
9809 })
9810 .map(Self::PrivatePropertyIdentifier)
9811 .unwrap_or(Self::Unknown(node)),
9812 "property_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9813 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
9814 })
9815 .map(Self::PropertyIdentifier)
9816 .unwrap_or(Self::Unknown(node)),
9817 "regex_flags" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9818 <RegexFlags as ::treesitter_types::FromNode>::from_node(node, src)
9819 })
9820 .map(Self::RegexFlags)
9821 .unwrap_or(Self::Unknown(node)),
9822 "regex_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9823 <RegexPattern as ::treesitter_types::FromNode>::from_node(node, src)
9824 })
9825 .map(Self::RegexPattern)
9826 .unwrap_or(Self::Unknown(node)),
9827 "shorthand_property_identifier" => {
9828 ::treesitter_types::runtime::maybe_grow_stack(|| {
9829 <ShorthandPropertyIdentifier as ::treesitter_types::FromNode>::from_node(
9830 node, src,
9831 )
9832 })
9833 .map(Self::ShorthandPropertyIdentifier)
9834 .unwrap_or(Self::Unknown(node))
9835 }
9836 "shorthand_property_identifier_pattern" => {
9837 ::treesitter_types::runtime::maybe_grow_stack(|| {
9838 <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
9839 node, src,
9840 )
9841 })
9842 .map(Self::ShorthandPropertyIdentifierPattern)
9843 .unwrap_or(Self::Unknown(node))
9844 }
9845 "statement_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9846 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
9847 })
9848 .map(Self::StatementIdentifier)
9849 .unwrap_or(Self::Unknown(node)),
9850 "string_fragment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9851 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
9852 })
9853 .map(Self::StringFragment)
9854 .unwrap_or(Self::Unknown(node)),
9855 "super" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9856 <Super as ::treesitter_types::FromNode>::from_node(node, src)
9857 })
9858 .map(Self::Super)
9859 .unwrap_or(Self::Unknown(node)),
9860 "this" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9861 <This as ::treesitter_types::FromNode>::from_node(node, src)
9862 })
9863 .map(Self::This)
9864 .unwrap_or(Self::Unknown(node)),
9865 "true" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9866 <True as ::treesitter_types::FromNode>::from_node(node, src)
9867 })
9868 .map(Self::True)
9869 .unwrap_or(Self::Unknown(node)),
9870 "undefined" => ::treesitter_types::runtime::maybe_grow_stack(|| {
9871 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)
9872 })
9873 .map(Self::Undefined)
9874 .unwrap_or(Self::Unknown(node)),
9875 _ => Self::Unknown(node),
9876 }
9877 }
9878}
9879impl ::treesitter_types::Spanned for AnyNode<'_> {
9880 fn span(&self) -> ::treesitter_types::Span {
9881 match self {
9882 Self::Declaration(inner) => inner.span(),
9883 Self::Expression(inner) => inner.span(),
9884 Self::Pattern(inner) => inner.span(),
9885 Self::PrimaryExpression(inner) => inner.span(),
9886 Self::Statement(inner) => inner.span(),
9887 Self::Arguments(inner) => inner.span(),
9888 Self::Array(inner) => inner.span(),
9889 Self::ArrayPattern(inner) => inner.span(),
9890 Self::ArrowFunction(inner) => inner.span(),
9891 Self::AssignmentExpression(inner) => inner.span(),
9892 Self::AssignmentPattern(inner) => inner.span(),
9893 Self::AugmentedAssignmentExpression(inner) => inner.span(),
9894 Self::AwaitExpression(inner) => inner.span(),
9895 Self::BinaryExpression(inner) => inner.span(),
9896 Self::BreakStatement(inner) => inner.span(),
9897 Self::CallExpression(inner) => inner.span(),
9898 Self::CatchClause(inner) => inner.span(),
9899 Self::Class(inner) => inner.span(),
9900 Self::ClassBody(inner) => inner.span(),
9901 Self::ClassDeclaration(inner) => inner.span(),
9902 Self::ClassHeritage(inner) => inner.span(),
9903 Self::ClassStaticBlock(inner) => inner.span(),
9904 Self::ComputedPropertyName(inner) => inner.span(),
9905 Self::ContinueStatement(inner) => inner.span(),
9906 Self::DebuggerStatement(inner) => inner.span(),
9907 Self::Decorator(inner) => inner.span(),
9908 Self::DoStatement(inner) => inner.span(),
9909 Self::ElseClause(inner) => inner.span(),
9910 Self::EmptyStatement(inner) => inner.span(),
9911 Self::ExportClause(inner) => inner.span(),
9912 Self::ExportSpecifier(inner) => inner.span(),
9913 Self::ExportStatement(inner) => inner.span(),
9914 Self::ExpressionStatement(inner) => inner.span(),
9915 Self::FieldDefinition(inner) => inner.span(),
9916 Self::FinallyClause(inner) => inner.span(),
9917 Self::ForInStatement(inner) => inner.span(),
9918 Self::ForStatement(inner) => inner.span(),
9919 Self::FormalParameters(inner) => inner.span(),
9920 Self::FunctionDeclaration(inner) => inner.span(),
9921 Self::FunctionExpression(inner) => inner.span(),
9922 Self::GeneratorFunction(inner) => inner.span(),
9923 Self::GeneratorFunctionDeclaration(inner) => inner.span(),
9924 Self::IfStatement(inner) => inner.span(),
9925 Self::Import(inner) => inner.span(),
9926 Self::ImportAttribute(inner) => inner.span(),
9927 Self::ImportClause(inner) => inner.span(),
9928 Self::ImportSpecifier(inner) => inner.span(),
9929 Self::ImportStatement(inner) => inner.span(),
9930 Self::JsxAttribute(inner) => inner.span(),
9931 Self::JsxClosingElement(inner) => inner.span(),
9932 Self::JsxElement(inner) => inner.span(),
9933 Self::JsxExpression(inner) => inner.span(),
9934 Self::JsxNamespaceName(inner) => inner.span(),
9935 Self::JsxOpeningElement(inner) => inner.span(),
9936 Self::JsxSelfClosingElement(inner) => inner.span(),
9937 Self::LabeledStatement(inner) => inner.span(),
9938 Self::LexicalDeclaration(inner) => inner.span(),
9939 Self::MemberExpression(inner) => inner.span(),
9940 Self::MetaProperty(inner) => inner.span(),
9941 Self::MethodDefinition(inner) => inner.span(),
9942 Self::NamedImports(inner) => inner.span(),
9943 Self::NamespaceExport(inner) => inner.span(),
9944 Self::NamespaceImport(inner) => inner.span(),
9945 Self::NewExpression(inner) => inner.span(),
9946 Self::Object(inner) => inner.span(),
9947 Self::ObjectAssignmentPattern(inner) => inner.span(),
9948 Self::ObjectPattern(inner) => inner.span(),
9949 Self::Pair(inner) => inner.span(),
9950 Self::PairPattern(inner) => inner.span(),
9951 Self::ParenthesizedExpression(inner) => inner.span(),
9952 Self::Program(inner) => inner.span(),
9953 Self::Regex(inner) => inner.span(),
9954 Self::RestPattern(inner) => inner.span(),
9955 Self::ReturnStatement(inner) => inner.span(),
9956 Self::SequenceExpression(inner) => inner.span(),
9957 Self::SpreadElement(inner) => inner.span(),
9958 Self::StatementBlock(inner) => inner.span(),
9959 Self::String(inner) => inner.span(),
9960 Self::SubscriptExpression(inner) => inner.span(),
9961 Self::SwitchBody(inner) => inner.span(),
9962 Self::SwitchCase(inner) => inner.span(),
9963 Self::SwitchDefault(inner) => inner.span(),
9964 Self::SwitchStatement(inner) => inner.span(),
9965 Self::TemplateString(inner) => inner.span(),
9966 Self::TemplateSubstitution(inner) => inner.span(),
9967 Self::TernaryExpression(inner) => inner.span(),
9968 Self::ThrowStatement(inner) => inner.span(),
9969 Self::TryStatement(inner) => inner.span(),
9970 Self::UnaryExpression(inner) => inner.span(),
9971 Self::UpdateExpression(inner) => inner.span(),
9972 Self::UsingDeclaration(inner) => inner.span(),
9973 Self::VariableDeclaration(inner) => inner.span(),
9974 Self::VariableDeclarator(inner) => inner.span(),
9975 Self::WhileStatement(inner) => inner.span(),
9976 Self::WithStatement(inner) => inner.span(),
9977 Self::YieldExpression(inner) => inner.span(),
9978 Self::Comment(inner) => inner.span(),
9979 Self::EscapeSequence(inner) => inner.span(),
9980 Self::False(inner) => inner.span(),
9981 Self::HashBangLine(inner) => inner.span(),
9982 Self::HtmlCharacterReference(inner) => inner.span(),
9983 Self::HtmlComment(inner) => inner.span(),
9984 Self::Identifier(inner) => inner.span(),
9985 Self::JsxText(inner) => inner.span(),
9986 Self::Null(inner) => inner.span(),
9987 Self::Number(inner) => inner.span(),
9988 Self::OptionalChain(inner) => inner.span(),
9989 Self::PrivatePropertyIdentifier(inner) => inner.span(),
9990 Self::PropertyIdentifier(inner) => inner.span(),
9991 Self::RegexFlags(inner) => inner.span(),
9992 Self::RegexPattern(inner) => inner.span(),
9993 Self::ShorthandPropertyIdentifier(inner) => inner.span(),
9994 Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
9995 Self::StatementIdentifier(inner) => inner.span(),
9996 Self::StringFragment(inner) => inner.span(),
9997 Self::Super(inner) => inner.span(),
9998 Self::This(inner) => inner.span(),
9999 Self::True(inner) => inner.span(),
10000 Self::Undefined(inner) => inner.span(),
10001 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
10002 }
10003 }
10004}