1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Declaration<'tree> {
3 FunctionDeclaration(::std::boxed::Box<FunctionDeclaration<'tree>>),
4 ImplicitVariableDeclaration(::std::boxed::Box<ImplicitVariableDeclaration<'tree>>),
5 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
6}
7impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
8 #[allow(clippy::collapsible_else_if)]
9 fn from_node(
10 node: ::treesitter_types::tree_sitter::Node<'tree>,
11 src: &'tree [u8],
12 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13 match node.kind() {
14 "function_declaration" => Ok(Self::FunctionDeclaration(::std::boxed::Box::new(
15 ::treesitter_types::runtime::maybe_grow_stack(|| {
16 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17 })?,
18 ))),
19 "implicit_variable_declaration" => Ok(Self::ImplicitVariableDeclaration(
20 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
21 <ImplicitVariableDeclaration as ::treesitter_types::FromNode>::from_node(
22 node, src,
23 )
24 })?),
25 )),
26 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
27 ::treesitter_types::runtime::maybe_grow_stack(|| {
28 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
29 })?,
30 ))),
31 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
32 }
33 }
34}
35impl ::treesitter_types::Spanned for Declaration<'_> {
36 fn span(&self) -> ::treesitter_types::Span {
37 match self {
38 Self::FunctionDeclaration(inner) => inner.span(),
39 Self::ImplicitVariableDeclaration(inner) => inner.span(),
40 Self::VariableDeclaration(inner) => inner.span(),
41 }
42 }
43}
44#[derive(Debug, Clone, PartialEq, Eq)]
45pub enum Expression<'tree> {
46 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
47 False(::std::boxed::Box<False<'tree>>),
48 FunctionCall(::std::boxed::Box<FunctionCall<'tree>>),
49 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
50 Nil(::std::boxed::Box<Nil<'tree>>),
51 Number(::std::boxed::Box<Number<'tree>>),
52 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
53 String(::std::boxed::Box<String<'tree>>),
54 TableConstructor(::std::boxed::Box<TableConstructor<'tree>>),
55 True(::std::boxed::Box<True<'tree>>),
56 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
57 VarargExpression(::std::boxed::Box<VarargExpression<'tree>>),
58 Variable(::std::boxed::Box<Variable<'tree>>),
59}
60impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
61 #[allow(clippy::collapsible_else_if)]
62 fn from_node(
63 node: ::treesitter_types::tree_sitter::Node<'tree>,
64 src: &'tree [u8],
65 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
66 match node.kind() {
67 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
68 ::treesitter_types::runtime::maybe_grow_stack(|| {
69 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
70 })?,
71 ))),
72 "false" => Ok(Self::False(::std::boxed::Box::new(
73 ::treesitter_types::runtime::maybe_grow_stack(|| {
74 <False as ::treesitter_types::FromNode>::from_node(node, src)
75 })?,
76 ))),
77 "function_call" => Ok(Self::FunctionCall(::std::boxed::Box::new(
78 ::treesitter_types::runtime::maybe_grow_stack(|| {
79 <FunctionCall as ::treesitter_types::FromNode>::from_node(node, src)
80 })?,
81 ))),
82 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
83 ::treesitter_types::runtime::maybe_grow_stack(|| {
84 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
85 })?,
86 ))),
87 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
88 ::treesitter_types::runtime::maybe_grow_stack(|| {
89 <Nil as ::treesitter_types::FromNode>::from_node(node, src)
90 })?,
91 ))),
92 "number" => Ok(Self::Number(::std::boxed::Box::new(
93 ::treesitter_types::runtime::maybe_grow_stack(|| {
94 <Number as ::treesitter_types::FromNode>::from_node(node, src)
95 })?,
96 ))),
97 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
98 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
99 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
100 })?),
101 )),
102 "string" => Ok(Self::String(::std::boxed::Box::new(
103 ::treesitter_types::runtime::maybe_grow_stack(|| {
104 <String as ::treesitter_types::FromNode>::from_node(node, src)
105 })?,
106 ))),
107 "table_constructor" => Ok(Self::TableConstructor(::std::boxed::Box::new(
108 ::treesitter_types::runtime::maybe_grow_stack(|| {
109 <TableConstructor as ::treesitter_types::FromNode>::from_node(node, src)
110 })?,
111 ))),
112 "true" => Ok(Self::True(::std::boxed::Box::new(
113 ::treesitter_types::runtime::maybe_grow_stack(|| {
114 <True as ::treesitter_types::FromNode>::from_node(node, src)
115 })?,
116 ))),
117 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
118 ::treesitter_types::runtime::maybe_grow_stack(|| {
119 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
120 })?,
121 ))),
122 "vararg_expression" => Ok(Self::VarargExpression(::std::boxed::Box::new(
123 ::treesitter_types::runtime::maybe_grow_stack(|| {
124 <VarargExpression as ::treesitter_types::FromNode>::from_node(node, src)
125 })?,
126 ))),
127 _other => {
128 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
129 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
130 }) {
131 Ok(Self::Variable(::std::boxed::Box::new(v)))
132 } else {
133 Err(::treesitter_types::ParseError::unexpected_kind(
134 _other, node,
135 ))
136 }
137 }
138 }
139 }
140}
141impl ::treesitter_types::Spanned for Expression<'_> {
142 fn span(&self) -> ::treesitter_types::Span {
143 match self {
144 Self::BinaryExpression(inner) => inner.span(),
145 Self::False(inner) => inner.span(),
146 Self::FunctionCall(inner) => inner.span(),
147 Self::FunctionDefinition(inner) => inner.span(),
148 Self::Nil(inner) => inner.span(),
149 Self::Number(inner) => inner.span(),
150 Self::ParenthesizedExpression(inner) => inner.span(),
151 Self::String(inner) => inner.span(),
152 Self::TableConstructor(inner) => inner.span(),
153 Self::True(inner) => inner.span(),
154 Self::UnaryExpression(inner) => inner.span(),
155 Self::VarargExpression(inner) => inner.span(),
156 Self::Variable(inner) => inner.span(),
157 }
158 }
159}
160#[derive(Debug, Clone, PartialEq, Eq)]
161pub enum Statement<'tree> {
162 AssignmentStatement(::std::boxed::Box<AssignmentStatement<'tree>>),
163 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
164 Declaration(::std::boxed::Box<Declaration<'tree>>),
165 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
166 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
167 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
168 FunctionCall(::std::boxed::Box<FunctionCall<'tree>>),
169 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
170 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
171 LabelStatement(::std::boxed::Box<LabelStatement<'tree>>),
172 RepeatStatement(::std::boxed::Box<RepeatStatement<'tree>>),
173 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
174}
175impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
176 #[allow(clippy::collapsible_else_if)]
177 fn from_node(
178 node: ::treesitter_types::tree_sitter::Node<'tree>,
179 src: &'tree [u8],
180 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
181 match node.kind() {
182 "assignment_statement" => Ok(Self::AssignmentStatement(::std::boxed::Box::new(
183 ::treesitter_types::runtime::maybe_grow_stack(|| {
184 <AssignmentStatement as ::treesitter_types::FromNode>::from_node(node, src)
185 })?,
186 ))),
187 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
188 ::treesitter_types::runtime::maybe_grow_stack(|| {
189 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
190 })?,
191 ))),
192 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
193 ::treesitter_types::runtime::maybe_grow_stack(|| {
194 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
195 })?,
196 ))),
197 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
198 ::treesitter_types::runtime::maybe_grow_stack(|| {
199 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
200 })?,
201 ))),
202 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
203 ::treesitter_types::runtime::maybe_grow_stack(|| {
204 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
205 })?,
206 ))),
207 "function_call" => Ok(Self::FunctionCall(::std::boxed::Box::new(
208 ::treesitter_types::runtime::maybe_grow_stack(|| {
209 <FunctionCall as ::treesitter_types::FromNode>::from_node(node, src)
210 })?,
211 ))),
212 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
213 ::treesitter_types::runtime::maybe_grow_stack(|| {
214 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
215 })?,
216 ))),
217 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
218 ::treesitter_types::runtime::maybe_grow_stack(|| {
219 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
220 })?,
221 ))),
222 "label_statement" => Ok(Self::LabelStatement(::std::boxed::Box::new(
223 ::treesitter_types::runtime::maybe_grow_stack(|| {
224 <LabelStatement as ::treesitter_types::FromNode>::from_node(node, src)
225 })?,
226 ))),
227 "repeat_statement" => Ok(Self::RepeatStatement(::std::boxed::Box::new(
228 ::treesitter_types::runtime::maybe_grow_stack(|| {
229 <RepeatStatement as ::treesitter_types::FromNode>::from_node(node, src)
230 })?,
231 ))),
232 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
233 ::treesitter_types::runtime::maybe_grow_stack(|| {
234 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
235 })?,
236 ))),
237 _other => {
238 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
239 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
240 }) {
241 Ok(Self::Declaration(::std::boxed::Box::new(v)))
242 } else {
243 Err(::treesitter_types::ParseError::unexpected_kind(
244 _other, node,
245 ))
246 }
247 }
248 }
249 }
250}
251impl ::treesitter_types::Spanned for Statement<'_> {
252 fn span(&self) -> ::treesitter_types::Span {
253 match self {
254 Self::AssignmentStatement(inner) => inner.span(),
255 Self::BreakStatement(inner) => inner.span(),
256 Self::Declaration(inner) => inner.span(),
257 Self::DoStatement(inner) => inner.span(),
258 Self::EmptyStatement(inner) => inner.span(),
259 Self::ForStatement(inner) => inner.span(),
260 Self::FunctionCall(inner) => inner.span(),
261 Self::GotoStatement(inner) => inner.span(),
262 Self::IfStatement(inner) => inner.span(),
263 Self::LabelStatement(inner) => inner.span(),
264 Self::RepeatStatement(inner) => inner.span(),
265 Self::WhileStatement(inner) => inner.span(),
266 }
267 }
268}
269#[derive(Debug, Clone, PartialEq, Eq)]
270pub enum Variable<'tree> {
271 BracketIndexExpression(::std::boxed::Box<BracketIndexExpression<'tree>>),
272 DotIndexExpression(::std::boxed::Box<DotIndexExpression<'tree>>),
273 Global(::treesitter_types::Span),
274 Identifier(::std::boxed::Box<Identifier<'tree>>),
275}
276impl<'tree> ::treesitter_types::FromNode<'tree> for Variable<'tree> {
277 #[allow(clippy::collapsible_else_if)]
278 fn from_node(
279 node: ::treesitter_types::tree_sitter::Node<'tree>,
280 src: &'tree [u8],
281 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
282 match node.kind() {
283 "bracket_index_expression" => Ok(Self::BracketIndexExpression(::std::boxed::Box::new(
284 ::treesitter_types::runtime::maybe_grow_stack(|| {
285 <BracketIndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
286 })?,
287 ))),
288 "dot_index_expression" => Ok(Self::DotIndexExpression(::std::boxed::Box::new(
289 ::treesitter_types::runtime::maybe_grow_stack(|| {
290 <DotIndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
291 })?,
292 ))),
293 "global" => Ok(Self::Global(::treesitter_types::Span::from(node))),
294 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
295 ::treesitter_types::runtime::maybe_grow_stack(|| {
296 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
297 })?,
298 ))),
299 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
300 }
301 }
302}
303impl ::treesitter_types::Spanned for Variable<'_> {
304 fn span(&self) -> ::treesitter_types::Span {
305 match self {
306 Self::BracketIndexExpression(inner) => inner.span(),
307 Self::DotIndexExpression(inner) => inner.span(),
308 Self::Global(span) => *span,
309 Self::Identifier(inner) => inner.span(),
310 }
311 }
312}
313#[derive(Debug, Clone, PartialEq, Eq)]
314pub struct Arguments<'tree> {
315 pub span: ::treesitter_types::Span,
316 pub children: ::std::vec::Vec<Expression<'tree>>,
317}
318impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
319 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
320 fn from_node(
321 node: ::treesitter_types::tree_sitter::Node<'tree>,
322 src: &'tree [u8],
323 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
324 debug_assert_eq!(node.kind(), "arguments");
325 Ok(Self {
326 span: ::treesitter_types::Span::from(node),
327 children: {
328 #[allow(clippy::suspicious_else_formatting)]
329 let non_field_children = {
330 let mut cursor = node.walk();
331 let mut result = ::std::vec::Vec::new();
332 if cursor.goto_first_child() {
333 loop {
334 if cursor.field_name().is_none()
335 && cursor.node().is_named()
336 && !cursor.node().is_extra()
337 {
338 result.push(cursor.node());
339 }
340 if !cursor.goto_next_sibling() {
341 break;
342 }
343 }
344 }
345 result
346 };
347 let mut items = ::std::vec::Vec::new();
348 for child in non_field_children {
349 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
350 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
351 })?);
352 }
353 items
354 },
355 })
356 }
357}
358impl ::treesitter_types::Spanned for Arguments<'_> {
359 fn span(&self) -> ::treesitter_types::Span {
360 self.span
361 }
362}
363#[derive(Debug, Clone, PartialEq, Eq)]
364pub struct AssignmentStatement<'tree> {
365 pub span: ::treesitter_types::Span,
366 pub operator: AssignmentStatementOperator,
367 pub children: ::std::vec::Vec<AssignmentStatementChildren<'tree>>,
368}
369impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentStatement<'tree> {
370 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
371 fn from_node(
372 node: ::treesitter_types::tree_sitter::Node<'tree>,
373 src: &'tree [u8],
374 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
375 debug_assert_eq!(node.kind(), "assignment_statement");
376 Ok(Self {
377 span: ::treesitter_types::Span::from(node),
378 operator: {
379 let child = node.child_by_field_name("operator").ok_or_else(|| {
380 ::treesitter_types::ParseError::missing_field("operator", node)
381 })?;
382 ::treesitter_types::runtime::maybe_grow_stack(|| {
383 <AssignmentStatementOperator as ::treesitter_types::FromNode>::from_node(
384 child, src,
385 )
386 })?
387 },
388 children: {
389 #[allow(clippy::suspicious_else_formatting)]
390 let non_field_children = {
391 let mut cursor = node.walk();
392 let mut result = ::std::vec::Vec::new();
393 if cursor.goto_first_child() {
394 loop {
395 if cursor.field_name().is_none()
396 && cursor.node().is_named()
397 && !cursor.node().is_extra()
398 {
399 result.push(cursor.node());
400 }
401 if !cursor.goto_next_sibling() {
402 break;
403 }
404 }
405 }
406 result
407 };
408 let mut items = ::std::vec::Vec::new();
409 for child in non_field_children {
410 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
411 <AssignmentStatementChildren as ::treesitter_types::FromNode>::from_node(
412 child, src,
413 )
414 })?);
415 }
416 items
417 },
418 })
419 }
420}
421impl ::treesitter_types::Spanned for AssignmentStatement<'_> {
422 fn span(&self) -> ::treesitter_types::Span {
423 self.span
424 }
425}
426#[derive(Debug, Clone, PartialEq, Eq)]
427pub struct Attribute<'tree> {
428 pub span: ::treesitter_types::Span,
429 pub children: Identifier<'tree>,
430}
431impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
432 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
433 fn from_node(
434 node: ::treesitter_types::tree_sitter::Node<'tree>,
435 src: &'tree [u8],
436 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
437 debug_assert_eq!(node.kind(), "attribute");
438 Ok(Self {
439 span: ::treesitter_types::Span::from(node),
440 children: {
441 #[allow(clippy::suspicious_else_formatting)]
442 let non_field_children = {
443 let mut cursor = node.walk();
444 let mut result = ::std::vec::Vec::new();
445 if cursor.goto_first_child() {
446 loop {
447 if cursor.field_name().is_none()
448 && cursor.node().is_named()
449 && !cursor.node().is_extra()
450 {
451 result.push(cursor.node());
452 }
453 if !cursor.goto_next_sibling() {
454 break;
455 }
456 }
457 }
458 result
459 };
460 let child = if let Some(&c) = non_field_children.first() {
461 c
462 } else {
463 let mut fallback_cursor = node.walk();
464 let mut fallback_child = None;
465 if fallback_cursor.goto_first_child() {
466 loop {
467 if fallback_cursor.field_name().is_none()
468 && !fallback_cursor.node().is_extra()
469 {
470 let candidate = fallback_cursor.node();
471 #[allow(clippy::needless_question_mark)]
472 if (|| -> ::core::result::Result<
473 _,
474 ::treesitter_types::ParseError,
475 > {
476 let child = candidate;
477 Ok(
478 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
479 child,
480 src,
481 ))?,
482 )
483 })()
484 .is_ok()
485 {
486 fallback_child = Some(candidate);
487 break;
488 }
489 }
490 if !fallback_cursor.goto_next_sibling() {
491 break;
492 }
493 }
494 }
495 if fallback_child.is_none() {
496 let mut cursor2 = node.walk();
497 if cursor2.goto_first_child() {
498 loop {
499 if cursor2.node().is_named() && !cursor2.node().is_extra() {
500 let candidate = cursor2.node();
501 #[allow(clippy::needless_question_mark)]
502 if (|| -> ::core::result::Result<
503 _,
504 ::treesitter_types::ParseError,
505 > {
506 let child = candidate;
507 Ok(
508 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
509 child,
510 src,
511 ))?,
512 )
513 })()
514 .is_ok()
515 {
516 fallback_child = Some(candidate);
517 break;
518 }
519 }
520 if !cursor2.goto_next_sibling() {
521 break;
522 }
523 }
524 }
525 }
526 fallback_child.ok_or_else(|| {
527 ::treesitter_types::ParseError::missing_field("children", node)
528 })?
529 };
530 ::treesitter_types::runtime::maybe_grow_stack(|| {
531 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
532 })?
533 },
534 })
535 }
536}
537impl ::treesitter_types::Spanned for Attribute<'_> {
538 fn span(&self) -> ::treesitter_types::Span {
539 self.span
540 }
541}
542#[derive(Debug, Clone, PartialEq, Eq)]
543pub struct BinaryExpression<'tree> {
544 pub span: ::treesitter_types::Span,
545 pub left: Expression<'tree>,
546 pub operator: BinaryExpressionOperator,
547 pub right: Expression<'tree>,
548}
549impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
550 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
551 fn from_node(
552 node: ::treesitter_types::tree_sitter::Node<'tree>,
553 src: &'tree [u8],
554 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
555 debug_assert_eq!(node.kind(), "binary_expression");
556 Ok(Self {
557 span: ::treesitter_types::Span::from(node),
558 left: {
559 let child = node
560 .child_by_field_name("left")
561 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
562 ::treesitter_types::runtime::maybe_grow_stack(|| {
563 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
564 })?
565 },
566 operator: {
567 let child = node.child_by_field_name("operator").ok_or_else(|| {
568 ::treesitter_types::ParseError::missing_field("operator", node)
569 })?;
570 ::treesitter_types::runtime::maybe_grow_stack(|| {
571 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
572 child, src,
573 )
574 })?
575 },
576 right: {
577 let child = node
578 .child_by_field_name("right")
579 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
580 ::treesitter_types::runtime::maybe_grow_stack(|| {
581 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
582 })?
583 },
584 })
585 }
586}
587impl ::treesitter_types::Spanned for BinaryExpression<'_> {
588 fn span(&self) -> ::treesitter_types::Span {
589 self.span
590 }
591}
592#[derive(Debug, Clone, PartialEq, Eq)]
593pub struct Block<'tree> {
594 pub span: ::treesitter_types::Span,
595 pub children: ::std::vec::Vec<BlockChildren<'tree>>,
596}
597impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
598 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
599 fn from_node(
600 node: ::treesitter_types::tree_sitter::Node<'tree>,
601 src: &'tree [u8],
602 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
603 debug_assert_eq!(node.kind(), "block");
604 Ok(Self {
605 span: ::treesitter_types::Span::from(node),
606 children: {
607 #[allow(clippy::suspicious_else_formatting)]
608 let non_field_children = {
609 let mut cursor = node.walk();
610 let mut result = ::std::vec::Vec::new();
611 if cursor.goto_first_child() {
612 loop {
613 if cursor.field_name().is_none()
614 && cursor.node().is_named()
615 && !cursor.node().is_extra()
616 {
617 result.push(cursor.node());
618 }
619 if !cursor.goto_next_sibling() {
620 break;
621 }
622 }
623 }
624 result
625 };
626 let mut items = ::std::vec::Vec::new();
627 for child in non_field_children {
628 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
629 <BlockChildren as ::treesitter_types::FromNode>::from_node(child, src)
630 })?);
631 }
632 items
633 },
634 })
635 }
636}
637impl ::treesitter_types::Spanned for Block<'_> {
638 fn span(&self) -> ::treesitter_types::Span {
639 self.span
640 }
641}
642#[derive(Debug, Clone, PartialEq, Eq)]
643pub struct BracketIndexExpression<'tree> {
644 pub span: ::treesitter_types::Span,
645 pub field: Expression<'tree>,
646 pub table: BracketIndexExpressionTable<'tree>,
647}
648impl<'tree> ::treesitter_types::FromNode<'tree> for BracketIndexExpression<'tree> {
649 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
650 fn from_node(
651 node: ::treesitter_types::tree_sitter::Node<'tree>,
652 src: &'tree [u8],
653 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
654 debug_assert_eq!(node.kind(), "bracket_index_expression");
655 Ok(Self {
656 span: ::treesitter_types::Span::from(node),
657 field: {
658 let child = node
659 .child_by_field_name("field")
660 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
661 ::treesitter_types::runtime::maybe_grow_stack(|| {
662 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
663 })?
664 },
665 table: {
666 let child = node
667 .child_by_field_name("table")
668 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("table", node))?;
669 ::treesitter_types::runtime::maybe_grow_stack(|| {
670 <BracketIndexExpressionTable as ::treesitter_types::FromNode>::from_node(
671 child, src,
672 )
673 })?
674 },
675 })
676 }
677}
678impl ::treesitter_types::Spanned for BracketIndexExpression<'_> {
679 fn span(&self) -> ::treesitter_types::Span {
680 self.span
681 }
682}
683#[derive(Debug, Clone, PartialEq, Eq)]
684pub struct Chunk<'tree> {
685 pub span: ::treesitter_types::Span,
686 pub children: ::std::vec::Vec<ChunkChildren<'tree>>,
687}
688impl<'tree> ::treesitter_types::FromNode<'tree> for Chunk<'tree> {
689 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
690 fn from_node(
691 node: ::treesitter_types::tree_sitter::Node<'tree>,
692 src: &'tree [u8],
693 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
694 debug_assert_eq!(node.kind(), "chunk");
695 Ok(Self {
696 span: ::treesitter_types::Span::from(node),
697 children: {
698 #[allow(clippy::suspicious_else_formatting)]
699 let non_field_children = {
700 let mut cursor = node.walk();
701 let mut result = ::std::vec::Vec::new();
702 if cursor.goto_first_child() {
703 loop {
704 if cursor.field_name().is_none()
705 && cursor.node().is_named()
706 && !cursor.node().is_extra()
707 {
708 result.push(cursor.node());
709 }
710 if !cursor.goto_next_sibling() {
711 break;
712 }
713 }
714 }
715 result
716 };
717 let mut items = ::std::vec::Vec::new();
718 for child in non_field_children {
719 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
720 <ChunkChildren as ::treesitter_types::FromNode>::from_node(child, src)
721 })?);
722 }
723 items
724 },
725 })
726 }
727}
728impl ::treesitter_types::Spanned for Chunk<'_> {
729 fn span(&self) -> ::treesitter_types::Span {
730 self.span
731 }
732}
733#[derive(Debug, Clone, PartialEq, Eq)]
734pub struct Comment<'tree> {
735 pub span: ::treesitter_types::Span,
736 pub content: CommentContent<'tree>,
737 pub end: ::core::option::Option<CommentEnd>,
738 pub start: CommentStart,
739}
740impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
741 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
742 fn from_node(
743 node: ::treesitter_types::tree_sitter::Node<'tree>,
744 src: &'tree [u8],
745 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
746 debug_assert_eq!(node.kind(), "comment");
747 Ok(Self {
748 span: ::treesitter_types::Span::from(node),
749 content: {
750 let child = node.child_by_field_name("content").ok_or_else(|| {
751 ::treesitter_types::ParseError::missing_field("content", node)
752 })?;
753 ::treesitter_types::runtime::maybe_grow_stack(|| {
754 <CommentContent as ::treesitter_types::FromNode>::from_node(child, src)
755 })?
756 },
757 end: match node.child_by_field_name("end") {
758 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
759 <CommentEnd as ::treesitter_types::FromNode>::from_node(child, src)
760 })?),
761 None => None,
762 },
763 start: {
764 let child = node
765 .child_by_field_name("start")
766 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("start", node))?;
767 ::treesitter_types::runtime::maybe_grow_stack(|| {
768 <CommentStart as ::treesitter_types::FromNode>::from_node(child, src)
769 })?
770 },
771 })
772 }
773}
774impl ::treesitter_types::Spanned for Comment<'_> {
775 fn span(&self) -> ::treesitter_types::Span {
776 self.span
777 }
778}
779#[derive(Debug, Clone, PartialEq, Eq)]
780pub struct DoStatement<'tree> {
781 pub span: ::treesitter_types::Span,
782 pub body: ::core::option::Option<Block<'tree>>,
783}
784impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
785 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
786 fn from_node(
787 node: ::treesitter_types::tree_sitter::Node<'tree>,
788 src: &'tree [u8],
789 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
790 debug_assert_eq!(node.kind(), "do_statement");
791 Ok(Self {
792 span: ::treesitter_types::Span::from(node),
793 body: match node.child_by_field_name("body") {
794 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
795 <Block as ::treesitter_types::FromNode>::from_node(child, src)
796 })?),
797 None => None,
798 },
799 })
800 }
801}
802impl ::treesitter_types::Spanned for DoStatement<'_> {
803 fn span(&self) -> ::treesitter_types::Span {
804 self.span
805 }
806}
807#[derive(Debug, Clone, PartialEq, Eq)]
808pub struct DotIndexExpression<'tree> {
809 pub span: ::treesitter_types::Span,
810 pub field: Identifier<'tree>,
811 pub table: DotIndexExpressionTable<'tree>,
812}
813impl<'tree> ::treesitter_types::FromNode<'tree> for DotIndexExpression<'tree> {
814 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
815 fn from_node(
816 node: ::treesitter_types::tree_sitter::Node<'tree>,
817 src: &'tree [u8],
818 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
819 debug_assert_eq!(node.kind(), "dot_index_expression");
820 Ok(Self {
821 span: ::treesitter_types::Span::from(node),
822 field: {
823 let child = node
824 .child_by_field_name("field")
825 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
826 ::treesitter_types::runtime::maybe_grow_stack(|| {
827 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
828 })?
829 },
830 table: {
831 let child = node
832 .child_by_field_name("table")
833 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("table", node))?;
834 ::treesitter_types::runtime::maybe_grow_stack(|| {
835 <DotIndexExpressionTable as ::treesitter_types::FromNode>::from_node(child, src)
836 })?
837 },
838 })
839 }
840}
841impl ::treesitter_types::Spanned for DotIndexExpression<'_> {
842 fn span(&self) -> ::treesitter_types::Span {
843 self.span
844 }
845}
846#[derive(Debug, Clone, PartialEq, Eq)]
847pub struct ElseStatement<'tree> {
848 pub span: ::treesitter_types::Span,
849 pub body: ::core::option::Option<Block<'tree>>,
850}
851impl<'tree> ::treesitter_types::FromNode<'tree> for ElseStatement<'tree> {
852 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
853 fn from_node(
854 node: ::treesitter_types::tree_sitter::Node<'tree>,
855 src: &'tree [u8],
856 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
857 debug_assert_eq!(node.kind(), "else_statement");
858 Ok(Self {
859 span: ::treesitter_types::Span::from(node),
860 body: match node.child_by_field_name("body") {
861 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
862 <Block as ::treesitter_types::FromNode>::from_node(child, src)
863 })?),
864 None => None,
865 },
866 })
867 }
868}
869impl ::treesitter_types::Spanned for ElseStatement<'_> {
870 fn span(&self) -> ::treesitter_types::Span {
871 self.span
872 }
873}
874#[derive(Debug, Clone, PartialEq, Eq)]
875pub struct ElseifStatement<'tree> {
876 pub span: ::treesitter_types::Span,
877 pub condition: Expression<'tree>,
878 pub consequence: ::core::option::Option<Block<'tree>>,
879}
880impl<'tree> ::treesitter_types::FromNode<'tree> for ElseifStatement<'tree> {
881 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
882 fn from_node(
883 node: ::treesitter_types::tree_sitter::Node<'tree>,
884 src: &'tree [u8],
885 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
886 debug_assert_eq!(node.kind(), "elseif_statement");
887 Ok(Self {
888 span: ::treesitter_types::Span::from(node),
889 condition: {
890 let child = node.child_by_field_name("condition").ok_or_else(|| {
891 ::treesitter_types::ParseError::missing_field("condition", node)
892 })?;
893 ::treesitter_types::runtime::maybe_grow_stack(|| {
894 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
895 })?
896 },
897 consequence: match node.child_by_field_name("consequence") {
898 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
899 <Block as ::treesitter_types::FromNode>::from_node(child, src)
900 })?),
901 None => None,
902 },
903 })
904 }
905}
906impl ::treesitter_types::Spanned for ElseifStatement<'_> {
907 fn span(&self) -> ::treesitter_types::Span {
908 self.span
909 }
910}
911#[derive(Debug, Clone, PartialEq, Eq)]
912pub struct EmptyStatement<'tree> {
913 pub span: ::treesitter_types::Span,
914 text: &'tree str,
915}
916impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
917 fn from_node(
918 node: ::treesitter_types::tree_sitter::Node<'tree>,
919 src: &'tree [u8],
920 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
921 debug_assert_eq!(node.kind(), "empty_statement");
922 Ok(Self {
923 span: ::treesitter_types::Span::from(node),
924 text: node.utf8_text(src)?,
925 })
926 }
927}
928impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
929 fn text(&self) -> &'tree str {
930 self.text
931 }
932}
933impl ::treesitter_types::Spanned for EmptyStatement<'_> {
934 fn span(&self) -> ::treesitter_types::Span {
935 self.span
936 }
937}
938#[derive(Debug, Clone, PartialEq, Eq)]
939pub struct ExpressionList<'tree> {
940 pub span: ::treesitter_types::Span,
941 pub value: ::std::vec::Vec<Expression<'tree>>,
942 pub children: ::std::vec::Vec<Expression<'tree>>,
943}
944impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionList<'tree> {
945 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
946 fn from_node(
947 node: ::treesitter_types::tree_sitter::Node<'tree>,
948 src: &'tree [u8],
949 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
950 debug_assert_eq!(node.kind(), "expression_list");
951 Ok(Self {
952 span: ::treesitter_types::Span::from(node),
953 value: {
954 let mut cursor = node.walk();
955 let mut items = ::std::vec::Vec::new();
956 for child in node.children_by_field_name("value", &mut cursor) {
957 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
958 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
959 })?);
960 }
961 items
962 },
963 children: {
964 #[allow(clippy::suspicious_else_formatting)]
965 let non_field_children = {
966 let mut cursor = node.walk();
967 let mut result = ::std::vec::Vec::new();
968 if cursor.goto_first_child() {
969 loop {
970 if cursor.field_name().is_none()
971 && cursor.node().is_named()
972 && !cursor.node().is_extra()
973 {
974 result.push(cursor.node());
975 }
976 if !cursor.goto_next_sibling() {
977 break;
978 }
979 }
980 }
981 result
982 };
983 let mut items = ::std::vec::Vec::new();
984 for child in non_field_children {
985 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
986 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
987 })?);
988 }
989 items
990 },
991 })
992 }
993}
994impl ::treesitter_types::Spanned for ExpressionList<'_> {
995 fn span(&self) -> ::treesitter_types::Span {
996 self.span
997 }
998}
999#[derive(Debug, Clone, PartialEq, Eq)]
1000pub struct Field<'tree> {
1001 pub span: ::treesitter_types::Span,
1002 pub name: ::core::option::Option<FieldName<'tree>>,
1003 pub operator: ::core::option::Option<FieldOperator>,
1004 pub value: Expression<'tree>,
1005}
1006impl<'tree> ::treesitter_types::FromNode<'tree> for Field<'tree> {
1007 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1008 fn from_node(
1009 node: ::treesitter_types::tree_sitter::Node<'tree>,
1010 src: &'tree [u8],
1011 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1012 debug_assert_eq!(node.kind(), "field");
1013 Ok(Self {
1014 span: ::treesitter_types::Span::from(node),
1015 name: match node.child_by_field_name("name") {
1016 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1017 <FieldName as ::treesitter_types::FromNode>::from_node(child, src)
1018 })?),
1019 None => None,
1020 },
1021 operator: match node.child_by_field_name("operator") {
1022 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1023 <FieldOperator as ::treesitter_types::FromNode>::from_node(child, src)
1024 })?),
1025 None => None,
1026 },
1027 value: {
1028 let child = node
1029 .child_by_field_name("value")
1030 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1031 ::treesitter_types::runtime::maybe_grow_stack(|| {
1032 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1033 })?
1034 },
1035 })
1036 }
1037}
1038impl ::treesitter_types::Spanned for Field<'_> {
1039 fn span(&self) -> ::treesitter_types::Span {
1040 self.span
1041 }
1042}
1043#[derive(Debug, Clone, PartialEq, Eq)]
1044pub struct ForGenericClause<'tree> {
1045 pub span: ::treesitter_types::Span,
1046 pub children: ::std::vec::Vec<ForGenericClauseChildren<'tree>>,
1047}
1048impl<'tree> ::treesitter_types::FromNode<'tree> for ForGenericClause<'tree> {
1049 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1050 fn from_node(
1051 node: ::treesitter_types::tree_sitter::Node<'tree>,
1052 src: &'tree [u8],
1053 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1054 debug_assert_eq!(node.kind(), "for_generic_clause");
1055 Ok(Self {
1056 span: ::treesitter_types::Span::from(node),
1057 children: {
1058 #[allow(clippy::suspicious_else_formatting)]
1059 let non_field_children = {
1060 let mut cursor = node.walk();
1061 let mut result = ::std::vec::Vec::new();
1062 if cursor.goto_first_child() {
1063 loop {
1064 if cursor.field_name().is_none()
1065 && cursor.node().is_named()
1066 && !cursor.node().is_extra()
1067 {
1068 result.push(cursor.node());
1069 }
1070 if !cursor.goto_next_sibling() {
1071 break;
1072 }
1073 }
1074 }
1075 result
1076 };
1077 let mut items = ::std::vec::Vec::new();
1078 for child in non_field_children {
1079 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1080 <ForGenericClauseChildren as ::treesitter_types::FromNode>::from_node(
1081 child, src,
1082 )
1083 })?);
1084 }
1085 items
1086 },
1087 })
1088 }
1089}
1090impl ::treesitter_types::Spanned for ForGenericClause<'_> {
1091 fn span(&self) -> ::treesitter_types::Span {
1092 self.span
1093 }
1094}
1095#[derive(Debug, Clone, PartialEq, Eq)]
1096pub struct ForNumericClause<'tree> {
1097 pub span: ::treesitter_types::Span,
1098 pub end: Expression<'tree>,
1099 pub name: Identifier<'tree>,
1100 pub operator: ForNumericClauseOperator,
1101 pub start: Expression<'tree>,
1102 pub step: ::core::option::Option<Expression<'tree>>,
1103}
1104impl<'tree> ::treesitter_types::FromNode<'tree> for ForNumericClause<'tree> {
1105 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1106 fn from_node(
1107 node: ::treesitter_types::tree_sitter::Node<'tree>,
1108 src: &'tree [u8],
1109 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1110 debug_assert_eq!(node.kind(), "for_numeric_clause");
1111 Ok(Self {
1112 span: ::treesitter_types::Span::from(node),
1113 end: {
1114 let child = node
1115 .child_by_field_name("end")
1116 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("end", node))?;
1117 ::treesitter_types::runtime::maybe_grow_stack(|| {
1118 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1119 })?
1120 },
1121 name: {
1122 let child = node
1123 .child_by_field_name("name")
1124 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1125 ::treesitter_types::runtime::maybe_grow_stack(|| {
1126 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1127 })?
1128 },
1129 operator: {
1130 let child = node.child_by_field_name("operator").ok_or_else(|| {
1131 ::treesitter_types::ParseError::missing_field("operator", node)
1132 })?;
1133 ::treesitter_types::runtime::maybe_grow_stack(|| {
1134 <ForNumericClauseOperator as ::treesitter_types::FromNode>::from_node(
1135 child, src,
1136 )
1137 })?
1138 },
1139 start: {
1140 let child = node
1141 .child_by_field_name("start")
1142 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("start", node))?;
1143 ::treesitter_types::runtime::maybe_grow_stack(|| {
1144 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1145 })?
1146 },
1147 step: match node.child_by_field_name("step") {
1148 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1149 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1150 })?),
1151 None => None,
1152 },
1153 })
1154 }
1155}
1156impl ::treesitter_types::Spanned for ForNumericClause<'_> {
1157 fn span(&self) -> ::treesitter_types::Span {
1158 self.span
1159 }
1160}
1161#[derive(Debug, Clone, PartialEq, Eq)]
1162pub struct ForStatement<'tree> {
1163 pub span: ::treesitter_types::Span,
1164 pub body: ::core::option::Option<Block<'tree>>,
1165 pub clause: ForStatementClause<'tree>,
1166}
1167impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
1168 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1169 fn from_node(
1170 node: ::treesitter_types::tree_sitter::Node<'tree>,
1171 src: &'tree [u8],
1172 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1173 debug_assert_eq!(node.kind(), "for_statement");
1174 Ok(Self {
1175 span: ::treesitter_types::Span::from(node),
1176 body: match node.child_by_field_name("body") {
1177 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1178 <Block as ::treesitter_types::FromNode>::from_node(child, src)
1179 })?),
1180 None => None,
1181 },
1182 clause: {
1183 let child = node
1184 .child_by_field_name("clause")
1185 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("clause", node))?;
1186 ::treesitter_types::runtime::maybe_grow_stack(|| {
1187 <ForStatementClause as ::treesitter_types::FromNode>::from_node(child, src)
1188 })?
1189 },
1190 })
1191 }
1192}
1193impl ::treesitter_types::Spanned for ForStatement<'_> {
1194 fn span(&self) -> ::treesitter_types::Span {
1195 self.span
1196 }
1197}
1198#[derive(Debug, Clone, PartialEq, Eq)]
1199pub struct FunctionCall<'tree> {
1200 pub span: ::treesitter_types::Span,
1201 pub arguments: Arguments<'tree>,
1202 pub name: FunctionCallName<'tree>,
1203}
1204impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionCall<'tree> {
1205 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1206 fn from_node(
1207 node: ::treesitter_types::tree_sitter::Node<'tree>,
1208 src: &'tree [u8],
1209 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1210 debug_assert_eq!(node.kind(), "function_call");
1211 Ok(Self {
1212 span: ::treesitter_types::Span::from(node),
1213 arguments: {
1214 let child = node.child_by_field_name("arguments").ok_or_else(|| {
1215 ::treesitter_types::ParseError::missing_field("arguments", node)
1216 })?;
1217 ::treesitter_types::runtime::maybe_grow_stack(|| {
1218 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)
1219 })?
1220 },
1221 name: {
1222 let child = node
1223 .child_by_field_name("name")
1224 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1225 ::treesitter_types::runtime::maybe_grow_stack(|| {
1226 <FunctionCallName as ::treesitter_types::FromNode>::from_node(child, src)
1227 })?
1228 },
1229 })
1230 }
1231}
1232impl ::treesitter_types::Spanned for FunctionCall<'_> {
1233 fn span(&self) -> ::treesitter_types::Span {
1234 self.span
1235 }
1236}
1237#[derive(Debug, Clone, PartialEq, Eq)]
1238pub struct FunctionDeclaration<'tree> {
1239 pub span: ::treesitter_types::Span,
1240 pub body: ::core::option::Option<Block<'tree>>,
1241 pub name: FunctionDeclarationName<'tree>,
1242 pub parameters: Parameters<'tree>,
1243}
1244impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaration<'tree> {
1245 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1246 fn from_node(
1247 node: ::treesitter_types::tree_sitter::Node<'tree>,
1248 src: &'tree [u8],
1249 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1250 debug_assert_eq!(node.kind(), "function_declaration");
1251 Ok(Self {
1252 span: ::treesitter_types::Span::from(node),
1253 body: match node.child_by_field_name("body") {
1254 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1255 <Block as ::treesitter_types::FromNode>::from_node(child, src)
1256 })?),
1257 None => None,
1258 },
1259 name: {
1260 let child = node
1261 .child_by_field_name("name")
1262 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1263 ::treesitter_types::runtime::maybe_grow_stack(|| {
1264 <FunctionDeclarationName as ::treesitter_types::FromNode>::from_node(child, src)
1265 })?
1266 },
1267 parameters: {
1268 let child = node.child_by_field_name("parameters").ok_or_else(|| {
1269 ::treesitter_types::ParseError::missing_field("parameters", node)
1270 })?;
1271 ::treesitter_types::runtime::maybe_grow_stack(|| {
1272 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)
1273 })?
1274 },
1275 })
1276 }
1277}
1278impl ::treesitter_types::Spanned for FunctionDeclaration<'_> {
1279 fn span(&self) -> ::treesitter_types::Span {
1280 self.span
1281 }
1282}
1283#[derive(Debug, Clone, PartialEq, Eq)]
1284pub struct FunctionDefinition<'tree> {
1285 pub span: ::treesitter_types::Span,
1286 pub body: ::core::option::Option<Block<'tree>>,
1287 pub parameters: Parameters<'tree>,
1288}
1289impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinition<'tree> {
1290 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1291 fn from_node(
1292 node: ::treesitter_types::tree_sitter::Node<'tree>,
1293 src: &'tree [u8],
1294 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1295 debug_assert_eq!(node.kind(), "function_definition");
1296 Ok(Self {
1297 span: ::treesitter_types::Span::from(node),
1298 body: match node.child_by_field_name("body") {
1299 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1300 <Block as ::treesitter_types::FromNode>::from_node(child, src)
1301 })?),
1302 None => None,
1303 },
1304 parameters: {
1305 let child = node.child_by_field_name("parameters").ok_or_else(|| {
1306 ::treesitter_types::ParseError::missing_field("parameters", node)
1307 })?;
1308 ::treesitter_types::runtime::maybe_grow_stack(|| {
1309 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)
1310 })?
1311 },
1312 })
1313 }
1314}
1315impl ::treesitter_types::Spanned for FunctionDefinition<'_> {
1316 fn span(&self) -> ::treesitter_types::Span {
1317 self.span
1318 }
1319}
1320#[derive(Debug, Clone, PartialEq, Eq)]
1321pub struct GotoStatement<'tree> {
1322 pub span: ::treesitter_types::Span,
1323 pub children: Identifier<'tree>,
1324}
1325impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
1326 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1327 fn from_node(
1328 node: ::treesitter_types::tree_sitter::Node<'tree>,
1329 src: &'tree [u8],
1330 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1331 debug_assert_eq!(node.kind(), "goto_statement");
1332 Ok(Self {
1333 span: ::treesitter_types::Span::from(node),
1334 children: {
1335 #[allow(clippy::suspicious_else_formatting)]
1336 let non_field_children = {
1337 let mut cursor = node.walk();
1338 let mut result = ::std::vec::Vec::new();
1339 if cursor.goto_first_child() {
1340 loop {
1341 if cursor.field_name().is_none()
1342 && cursor.node().is_named()
1343 && !cursor.node().is_extra()
1344 {
1345 result.push(cursor.node());
1346 }
1347 if !cursor.goto_next_sibling() {
1348 break;
1349 }
1350 }
1351 }
1352 result
1353 };
1354 let child = if let Some(&c) = non_field_children.first() {
1355 c
1356 } else {
1357 let mut fallback_cursor = node.walk();
1358 let mut fallback_child = None;
1359 if fallback_cursor.goto_first_child() {
1360 loop {
1361 if fallback_cursor.field_name().is_none()
1362 && !fallback_cursor.node().is_extra()
1363 {
1364 let candidate = fallback_cursor.node();
1365 #[allow(clippy::needless_question_mark)]
1366 if (|| -> ::core::result::Result<
1367 _,
1368 ::treesitter_types::ParseError,
1369 > {
1370 let child = candidate;
1371 Ok(
1372 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
1373 child,
1374 src,
1375 ))?,
1376 )
1377 })()
1378 .is_ok()
1379 {
1380 fallback_child = Some(candidate);
1381 break;
1382 }
1383 }
1384 if !fallback_cursor.goto_next_sibling() {
1385 break;
1386 }
1387 }
1388 }
1389 if fallback_child.is_none() {
1390 let mut cursor2 = node.walk();
1391 if cursor2.goto_first_child() {
1392 loop {
1393 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1394 let candidate = cursor2.node();
1395 #[allow(clippy::needless_question_mark)]
1396 if (|| -> ::core::result::Result<
1397 _,
1398 ::treesitter_types::ParseError,
1399 > {
1400 let child = candidate;
1401 Ok(
1402 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
1403 child,
1404 src,
1405 ))?,
1406 )
1407 })()
1408 .is_ok()
1409 {
1410 fallback_child = Some(candidate);
1411 break;
1412 }
1413 }
1414 if !cursor2.goto_next_sibling() {
1415 break;
1416 }
1417 }
1418 }
1419 }
1420 fallback_child.ok_or_else(|| {
1421 ::treesitter_types::ParseError::missing_field("children", node)
1422 })?
1423 };
1424 ::treesitter_types::runtime::maybe_grow_stack(|| {
1425 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1426 })?
1427 },
1428 })
1429 }
1430}
1431impl ::treesitter_types::Spanned for GotoStatement<'_> {
1432 fn span(&self) -> ::treesitter_types::Span {
1433 self.span
1434 }
1435}
1436#[derive(Debug, Clone, PartialEq, Eq)]
1437pub struct IfStatement<'tree> {
1438 pub span: ::treesitter_types::Span,
1439 pub alternative: ::std::vec::Vec<IfStatementAlternative<'tree>>,
1440 pub condition: Expression<'tree>,
1441 pub consequence: ::core::option::Option<Block<'tree>>,
1442}
1443impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
1444 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1445 fn from_node(
1446 node: ::treesitter_types::tree_sitter::Node<'tree>,
1447 src: &'tree [u8],
1448 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1449 debug_assert_eq!(node.kind(), "if_statement");
1450 Ok(Self {
1451 span: ::treesitter_types::Span::from(node),
1452 alternative: {
1453 let mut cursor = node.walk();
1454 let mut items = ::std::vec::Vec::new();
1455 for child in node.children_by_field_name("alternative", &mut cursor) {
1456 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1457 <IfStatementAlternative as ::treesitter_types::FromNode>::from_node(
1458 child, src,
1459 )
1460 })?);
1461 }
1462 items
1463 },
1464 condition: {
1465 let child = node.child_by_field_name("condition").ok_or_else(|| {
1466 ::treesitter_types::ParseError::missing_field("condition", node)
1467 })?;
1468 ::treesitter_types::runtime::maybe_grow_stack(|| {
1469 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1470 })?
1471 },
1472 consequence: match node.child_by_field_name("consequence") {
1473 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1474 <Block as ::treesitter_types::FromNode>::from_node(child, src)
1475 })?),
1476 None => None,
1477 },
1478 })
1479 }
1480}
1481impl ::treesitter_types::Spanned for IfStatement<'_> {
1482 fn span(&self) -> ::treesitter_types::Span {
1483 self.span
1484 }
1485}
1486#[derive(Debug, Clone, PartialEq, Eq)]
1487pub struct ImplicitVariableDeclaration<'tree> {
1488 pub span: ::treesitter_types::Span,
1489 pub attribute: ::core::option::Option<Attribute<'tree>>,
1490}
1491impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitVariableDeclaration<'tree> {
1492 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1493 fn from_node(
1494 node: ::treesitter_types::tree_sitter::Node<'tree>,
1495 src: &'tree [u8],
1496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1497 debug_assert_eq!(node.kind(), "implicit_variable_declaration");
1498 Ok(Self {
1499 span: ::treesitter_types::Span::from(node),
1500 attribute: match node.child_by_field_name("attribute") {
1501 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1502 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)
1503 })?),
1504 None => None,
1505 },
1506 })
1507 }
1508}
1509impl ::treesitter_types::Spanned for ImplicitVariableDeclaration<'_> {
1510 fn span(&self) -> ::treesitter_types::Span {
1511 self.span
1512 }
1513}
1514#[derive(Debug, Clone, PartialEq, Eq)]
1515pub struct LabelStatement<'tree> {
1516 pub span: ::treesitter_types::Span,
1517 pub children: Identifier<'tree>,
1518}
1519impl<'tree> ::treesitter_types::FromNode<'tree> for LabelStatement<'tree> {
1520 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1521 fn from_node(
1522 node: ::treesitter_types::tree_sitter::Node<'tree>,
1523 src: &'tree [u8],
1524 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1525 debug_assert_eq!(node.kind(), "label_statement");
1526 Ok(Self {
1527 span: ::treesitter_types::Span::from(node),
1528 children: {
1529 #[allow(clippy::suspicious_else_formatting)]
1530 let non_field_children = {
1531 let mut cursor = node.walk();
1532 let mut result = ::std::vec::Vec::new();
1533 if cursor.goto_first_child() {
1534 loop {
1535 if cursor.field_name().is_none()
1536 && cursor.node().is_named()
1537 && !cursor.node().is_extra()
1538 {
1539 result.push(cursor.node());
1540 }
1541 if !cursor.goto_next_sibling() {
1542 break;
1543 }
1544 }
1545 }
1546 result
1547 };
1548 let child = if let Some(&c) = non_field_children.first() {
1549 c
1550 } else {
1551 let mut fallback_cursor = node.walk();
1552 let mut fallback_child = None;
1553 if fallback_cursor.goto_first_child() {
1554 loop {
1555 if fallback_cursor.field_name().is_none()
1556 && !fallback_cursor.node().is_extra()
1557 {
1558 let candidate = fallback_cursor.node();
1559 #[allow(clippy::needless_question_mark)]
1560 if (|| -> ::core::result::Result<
1561 _,
1562 ::treesitter_types::ParseError,
1563 > {
1564 let child = candidate;
1565 Ok(
1566 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
1567 child,
1568 src,
1569 ))?,
1570 )
1571 })()
1572 .is_ok()
1573 {
1574 fallback_child = Some(candidate);
1575 break;
1576 }
1577 }
1578 if !fallback_cursor.goto_next_sibling() {
1579 break;
1580 }
1581 }
1582 }
1583 if fallback_child.is_none() {
1584 let mut cursor2 = node.walk();
1585 if cursor2.goto_first_child() {
1586 loop {
1587 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1588 let candidate = cursor2.node();
1589 #[allow(clippy::needless_question_mark)]
1590 if (|| -> ::core::result::Result<
1591 _,
1592 ::treesitter_types::ParseError,
1593 > {
1594 let child = candidate;
1595 Ok(
1596 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
1597 child,
1598 src,
1599 ))?,
1600 )
1601 })()
1602 .is_ok()
1603 {
1604 fallback_child = Some(candidate);
1605 break;
1606 }
1607 }
1608 if !cursor2.goto_next_sibling() {
1609 break;
1610 }
1611 }
1612 }
1613 }
1614 fallback_child.ok_or_else(|| {
1615 ::treesitter_types::ParseError::missing_field("children", node)
1616 })?
1617 };
1618 ::treesitter_types::runtime::maybe_grow_stack(|| {
1619 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1620 })?
1621 },
1622 })
1623 }
1624}
1625impl ::treesitter_types::Spanned for LabelStatement<'_> {
1626 fn span(&self) -> ::treesitter_types::Span {
1627 self.span
1628 }
1629}
1630#[derive(Debug, Clone, PartialEq, Eq)]
1631pub struct MethodIndexExpression<'tree> {
1632 pub span: ::treesitter_types::Span,
1633 pub method: Identifier<'tree>,
1634 pub table: MethodIndexExpressionTable<'tree>,
1635}
1636impl<'tree> ::treesitter_types::FromNode<'tree> for MethodIndexExpression<'tree> {
1637 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1638 fn from_node(
1639 node: ::treesitter_types::tree_sitter::Node<'tree>,
1640 src: &'tree [u8],
1641 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1642 debug_assert_eq!(node.kind(), "method_index_expression");
1643 Ok(Self {
1644 span: ::treesitter_types::Span::from(node),
1645 method: {
1646 let child = node
1647 .child_by_field_name("method")
1648 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("method", node))?;
1649 ::treesitter_types::runtime::maybe_grow_stack(|| {
1650 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1651 })?
1652 },
1653 table: {
1654 let child = node
1655 .child_by_field_name("table")
1656 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("table", node))?;
1657 ::treesitter_types::runtime::maybe_grow_stack(|| {
1658 <MethodIndexExpressionTable as ::treesitter_types::FromNode>::from_node(
1659 child, src,
1660 )
1661 })?
1662 },
1663 })
1664 }
1665}
1666impl ::treesitter_types::Spanned for MethodIndexExpression<'_> {
1667 fn span(&self) -> ::treesitter_types::Span {
1668 self.span
1669 }
1670}
1671#[derive(Debug, Clone, PartialEq, Eq)]
1672pub struct Parameters<'tree> {
1673 pub span: ::treesitter_types::Span,
1674 pub name: ::std::vec::Vec<Identifier<'tree>>,
1675 pub children: ::core::option::Option<VarargExpression<'tree>>,
1676}
1677impl<'tree> ::treesitter_types::FromNode<'tree> for Parameters<'tree> {
1678 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1679 fn from_node(
1680 node: ::treesitter_types::tree_sitter::Node<'tree>,
1681 src: &'tree [u8],
1682 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1683 debug_assert_eq!(node.kind(), "parameters");
1684 Ok(Self {
1685 span: ::treesitter_types::Span::from(node),
1686 name: {
1687 let mut cursor = node.walk();
1688 let mut items = ::std::vec::Vec::new();
1689 for child in node.children_by_field_name("name", &mut cursor) {
1690 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1691 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1692 })?);
1693 }
1694 items
1695 },
1696 children: {
1697 #[allow(clippy::suspicious_else_formatting)]
1698 let non_field_children = {
1699 let mut cursor = node.walk();
1700 let mut result = ::std::vec::Vec::new();
1701 if cursor.goto_first_child() {
1702 loop {
1703 if cursor.field_name().is_none()
1704 && cursor.node().is_named()
1705 && !cursor.node().is_extra()
1706 {
1707 result.push(cursor.node());
1708 }
1709 if !cursor.goto_next_sibling() {
1710 break;
1711 }
1712 }
1713 }
1714 result
1715 };
1716 match non_field_children.first() {
1717 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1718 <VarargExpression as ::treesitter_types::FromNode>::from_node(child, src)
1719 })?),
1720 None => None,
1721 }
1722 },
1723 })
1724 }
1725}
1726impl ::treesitter_types::Spanned for Parameters<'_> {
1727 fn span(&self) -> ::treesitter_types::Span {
1728 self.span
1729 }
1730}
1731#[derive(Debug, Clone, PartialEq, Eq)]
1732pub struct ParenthesizedExpression<'tree> {
1733 pub span: ::treesitter_types::Span,
1734 pub children: Expression<'tree>,
1735}
1736impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
1737 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1738 fn from_node(
1739 node: ::treesitter_types::tree_sitter::Node<'tree>,
1740 src: &'tree [u8],
1741 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1742 debug_assert_eq!(node.kind(), "parenthesized_expression");
1743 Ok(Self {
1744 span: ::treesitter_types::Span::from(node),
1745 children: {
1746 #[allow(clippy::suspicious_else_formatting)]
1747 let non_field_children = {
1748 let mut cursor = node.walk();
1749 let mut result = ::std::vec::Vec::new();
1750 if cursor.goto_first_child() {
1751 loop {
1752 if cursor.field_name().is_none()
1753 && cursor.node().is_named()
1754 && !cursor.node().is_extra()
1755 {
1756 result.push(cursor.node());
1757 }
1758 if !cursor.goto_next_sibling() {
1759 break;
1760 }
1761 }
1762 }
1763 result
1764 };
1765 let child = if let Some(&c) = non_field_children.first() {
1766 c
1767 } else {
1768 let mut fallback_cursor = node.walk();
1769 let mut fallback_child = None;
1770 if fallback_cursor.goto_first_child() {
1771 loop {
1772 if fallback_cursor.field_name().is_none()
1773 && !fallback_cursor.node().is_extra()
1774 {
1775 let candidate = fallback_cursor.node();
1776 #[allow(clippy::needless_question_mark)]
1777 if (|| -> ::core::result::Result<
1778 _,
1779 ::treesitter_types::ParseError,
1780 > {
1781 let child = candidate;
1782 Ok(
1783 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1784 child,
1785 src,
1786 ))?,
1787 )
1788 })()
1789 .is_ok()
1790 {
1791 fallback_child = Some(candidate);
1792 break;
1793 }
1794 }
1795 if !fallback_cursor.goto_next_sibling() {
1796 break;
1797 }
1798 }
1799 }
1800 if fallback_child.is_none() {
1801 let mut cursor2 = node.walk();
1802 if cursor2.goto_first_child() {
1803 loop {
1804 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1805 let candidate = cursor2.node();
1806 #[allow(clippy::needless_question_mark)]
1807 if (|| -> ::core::result::Result<
1808 _,
1809 ::treesitter_types::ParseError,
1810 > {
1811 let child = candidate;
1812 Ok(
1813 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1814 child,
1815 src,
1816 ))?,
1817 )
1818 })()
1819 .is_ok()
1820 {
1821 fallback_child = Some(candidate);
1822 break;
1823 }
1824 }
1825 if !cursor2.goto_next_sibling() {
1826 break;
1827 }
1828 }
1829 }
1830 }
1831 fallback_child.ok_or_else(|| {
1832 ::treesitter_types::ParseError::missing_field("children", node)
1833 })?
1834 };
1835 ::treesitter_types::runtime::maybe_grow_stack(|| {
1836 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1837 })?
1838 },
1839 })
1840 }
1841}
1842impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
1843 fn span(&self) -> ::treesitter_types::Span {
1844 self.span
1845 }
1846}
1847#[derive(Debug, Clone, PartialEq, Eq)]
1848pub struct RepeatStatement<'tree> {
1849 pub span: ::treesitter_types::Span,
1850 pub body: ::core::option::Option<Block<'tree>>,
1851 pub condition: Expression<'tree>,
1852}
1853impl<'tree> ::treesitter_types::FromNode<'tree> for RepeatStatement<'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(), "repeat_statement");
1860 Ok(Self {
1861 span: ::treesitter_types::Span::from(node),
1862 body: match node.child_by_field_name("body") {
1863 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1864 <Block as ::treesitter_types::FromNode>::from_node(child, src)
1865 })?),
1866 None => None,
1867 },
1868 condition: {
1869 let child = node.child_by_field_name("condition").ok_or_else(|| {
1870 ::treesitter_types::ParseError::missing_field("condition", node)
1871 })?;
1872 ::treesitter_types::runtime::maybe_grow_stack(|| {
1873 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1874 })?
1875 },
1876 })
1877 }
1878}
1879impl ::treesitter_types::Spanned for RepeatStatement<'_> {
1880 fn span(&self) -> ::treesitter_types::Span {
1881 self.span
1882 }
1883}
1884#[derive(Debug, Clone, PartialEq, Eq)]
1885pub struct ReturnStatement<'tree> {
1886 pub span: ::treesitter_types::Span,
1887 pub children: ::core::option::Option<ExpressionList<'tree>>,
1888}
1889impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
1890 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1891 fn from_node(
1892 node: ::treesitter_types::tree_sitter::Node<'tree>,
1893 src: &'tree [u8],
1894 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1895 debug_assert_eq!(node.kind(), "return_statement");
1896 Ok(Self {
1897 span: ::treesitter_types::Span::from(node),
1898 children: {
1899 #[allow(clippy::suspicious_else_formatting)]
1900 let non_field_children = {
1901 let mut cursor = node.walk();
1902 let mut result = ::std::vec::Vec::new();
1903 if cursor.goto_first_child() {
1904 loop {
1905 if cursor.field_name().is_none()
1906 && cursor.node().is_named()
1907 && !cursor.node().is_extra()
1908 {
1909 result.push(cursor.node());
1910 }
1911 if !cursor.goto_next_sibling() {
1912 break;
1913 }
1914 }
1915 }
1916 result
1917 };
1918 match non_field_children.first() {
1919 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1920 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
1921 })?),
1922 None => None,
1923 }
1924 },
1925 })
1926 }
1927}
1928impl ::treesitter_types::Spanned for ReturnStatement<'_> {
1929 fn span(&self) -> ::treesitter_types::Span {
1930 self.span
1931 }
1932}
1933#[derive(Debug, Clone, PartialEq, Eq)]
1934pub struct String<'tree> {
1935 pub span: ::treesitter_types::Span,
1936 pub content: ::core::option::Option<StringContent<'tree>>,
1937 pub end: StringEnd,
1938 pub start: StringStart,
1939}
1940impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
1941 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1942 fn from_node(
1943 node: ::treesitter_types::tree_sitter::Node<'tree>,
1944 src: &'tree [u8],
1945 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1946 debug_assert_eq!(node.kind(), "string");
1947 Ok(Self {
1948 span: ::treesitter_types::Span::from(node),
1949 content: match node.child_by_field_name("content") {
1950 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1951 <StringContent as ::treesitter_types::FromNode>::from_node(child, src)
1952 })?),
1953 None => None,
1954 },
1955 end: {
1956 let child = node
1957 .child_by_field_name("end")
1958 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("end", node))?;
1959 ::treesitter_types::runtime::maybe_grow_stack(|| {
1960 <StringEnd as ::treesitter_types::FromNode>::from_node(child, src)
1961 })?
1962 },
1963 start: {
1964 let child = node
1965 .child_by_field_name("start")
1966 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("start", node))?;
1967 ::treesitter_types::runtime::maybe_grow_stack(|| {
1968 <StringStart as ::treesitter_types::FromNode>::from_node(child, src)
1969 })?
1970 },
1971 })
1972 }
1973}
1974impl ::treesitter_types::Spanned for String<'_> {
1975 fn span(&self) -> ::treesitter_types::Span {
1976 self.span
1977 }
1978}
1979#[derive(Debug, Clone, PartialEq, Eq)]
1980pub struct StringContent<'tree> {
1981 pub span: ::treesitter_types::Span,
1982 pub children: ::std::vec::Vec<EscapeSequence<'tree>>,
1983}
1984impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
1985 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1986 fn from_node(
1987 node: ::treesitter_types::tree_sitter::Node<'tree>,
1988 src: &'tree [u8],
1989 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1990 debug_assert_eq!(node.kind(), "string_content");
1991 Ok(Self {
1992 span: ::treesitter_types::Span::from(node),
1993 children: {
1994 #[allow(clippy::suspicious_else_formatting)]
1995 let non_field_children = {
1996 let mut cursor = node.walk();
1997 let mut result = ::std::vec::Vec::new();
1998 if cursor.goto_first_child() {
1999 loop {
2000 if cursor.field_name().is_none()
2001 && cursor.node().is_named()
2002 && !cursor.node().is_extra()
2003 {
2004 result.push(cursor.node());
2005 }
2006 if !cursor.goto_next_sibling() {
2007 break;
2008 }
2009 }
2010 }
2011 result
2012 };
2013 let mut items = ::std::vec::Vec::new();
2014 for child in non_field_children {
2015 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2016 <EscapeSequence as ::treesitter_types::FromNode>::from_node(child, src)
2017 })?);
2018 }
2019 items
2020 },
2021 })
2022 }
2023}
2024impl ::treesitter_types::Spanned for StringContent<'_> {
2025 fn span(&self) -> ::treesitter_types::Span {
2026 self.span
2027 }
2028}
2029#[derive(Debug, Clone, PartialEq, Eq)]
2030pub struct TableConstructor<'tree> {
2031 pub span: ::treesitter_types::Span,
2032 pub children: ::std::vec::Vec<Field<'tree>>,
2033}
2034impl<'tree> ::treesitter_types::FromNode<'tree> for TableConstructor<'tree> {
2035 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2036 fn from_node(
2037 node: ::treesitter_types::tree_sitter::Node<'tree>,
2038 src: &'tree [u8],
2039 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2040 debug_assert_eq!(node.kind(), "table_constructor");
2041 Ok(Self {
2042 span: ::treesitter_types::Span::from(node),
2043 children: {
2044 #[allow(clippy::suspicious_else_formatting)]
2045 let non_field_children = {
2046 let mut cursor = node.walk();
2047 let mut result = ::std::vec::Vec::new();
2048 if cursor.goto_first_child() {
2049 loop {
2050 if cursor.field_name().is_none()
2051 && cursor.node().is_named()
2052 && !cursor.node().is_extra()
2053 {
2054 result.push(cursor.node());
2055 }
2056 if !cursor.goto_next_sibling() {
2057 break;
2058 }
2059 }
2060 }
2061 result
2062 };
2063 let mut items = ::std::vec::Vec::new();
2064 for child in non_field_children {
2065 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2066 <Field as ::treesitter_types::FromNode>::from_node(child, src)
2067 })?);
2068 }
2069 items
2070 },
2071 })
2072 }
2073}
2074impl ::treesitter_types::Spanned for TableConstructor<'_> {
2075 fn span(&self) -> ::treesitter_types::Span {
2076 self.span
2077 }
2078}
2079#[derive(Debug, Clone, PartialEq, Eq)]
2080pub struct UnaryExpression<'tree> {
2081 pub span: ::treesitter_types::Span,
2082 pub operand: Expression<'tree>,
2083 pub operator: UnaryExpressionOperator,
2084}
2085impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
2086 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2087 fn from_node(
2088 node: ::treesitter_types::tree_sitter::Node<'tree>,
2089 src: &'tree [u8],
2090 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2091 debug_assert_eq!(node.kind(), "unary_expression");
2092 Ok(Self {
2093 span: ::treesitter_types::Span::from(node),
2094 operand: {
2095 let child = node.child_by_field_name("operand").ok_or_else(|| {
2096 ::treesitter_types::ParseError::missing_field("operand", node)
2097 })?;
2098 ::treesitter_types::runtime::maybe_grow_stack(|| {
2099 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2100 })?
2101 },
2102 operator: {
2103 let child = node.child_by_field_name("operator").ok_or_else(|| {
2104 ::treesitter_types::ParseError::missing_field("operator", node)
2105 })?;
2106 ::treesitter_types::runtime::maybe_grow_stack(|| {
2107 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
2108 })?
2109 },
2110 })
2111 }
2112}
2113impl ::treesitter_types::Spanned for UnaryExpression<'_> {
2114 fn span(&self) -> ::treesitter_types::Span {
2115 self.span
2116 }
2117}
2118#[derive(Debug, Clone, PartialEq, Eq)]
2119pub struct VariableDeclaration<'tree> {
2120 pub span: ::treesitter_types::Span,
2121 pub children: VariableDeclarationChildren<'tree>,
2122}
2123impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaration<'tree> {
2124 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2125 fn from_node(
2126 node: ::treesitter_types::tree_sitter::Node<'tree>,
2127 src: &'tree [u8],
2128 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2129 debug_assert_eq!(node.kind(), "variable_declaration");
2130 Ok(Self {
2131 span: ::treesitter_types::Span::from(node),
2132 children: {
2133 #[allow(clippy::suspicious_else_formatting)]
2134 let non_field_children = {
2135 let mut cursor = node.walk();
2136 let mut result = ::std::vec::Vec::new();
2137 if cursor.goto_first_child() {
2138 loop {
2139 if cursor.field_name().is_none()
2140 && cursor.node().is_named()
2141 && !cursor.node().is_extra()
2142 {
2143 result.push(cursor.node());
2144 }
2145 if !cursor.goto_next_sibling() {
2146 break;
2147 }
2148 }
2149 }
2150 result
2151 };
2152 let child = if let Some(&c) = non_field_children.first() {
2153 c
2154 } else {
2155 let mut fallback_cursor = node.walk();
2156 let mut fallback_child = None;
2157 if fallback_cursor.goto_first_child() {
2158 loop {
2159 if fallback_cursor.field_name().is_none()
2160 && !fallback_cursor.node().is_extra()
2161 {
2162 let candidate = fallback_cursor.node();
2163 #[allow(clippy::needless_question_mark)]
2164 if (|| -> ::core::result::Result<
2165 _,
2166 ::treesitter_types::ParseError,
2167 > {
2168 let child = candidate;
2169 Ok(
2170 ::treesitter_types::runtime::maybe_grow_stack(|| <VariableDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2171 child,
2172 src,
2173 ))?,
2174 )
2175 })()
2176 .is_ok()
2177 {
2178 fallback_child = Some(candidate);
2179 break;
2180 }
2181 }
2182 if !fallback_cursor.goto_next_sibling() {
2183 break;
2184 }
2185 }
2186 }
2187 if fallback_child.is_none() {
2188 let mut cursor2 = node.walk();
2189 if cursor2.goto_first_child() {
2190 loop {
2191 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2192 let candidate = cursor2.node();
2193 #[allow(clippy::needless_question_mark)]
2194 if (|| -> ::core::result::Result<
2195 _,
2196 ::treesitter_types::ParseError,
2197 > {
2198 let child = candidate;
2199 Ok(
2200 ::treesitter_types::runtime::maybe_grow_stack(|| <VariableDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2201 child,
2202 src,
2203 ))?,
2204 )
2205 })()
2206 .is_ok()
2207 {
2208 fallback_child = Some(candidate);
2209 break;
2210 }
2211 }
2212 if !cursor2.goto_next_sibling() {
2213 break;
2214 }
2215 }
2216 }
2217 }
2218 fallback_child.ok_or_else(|| {
2219 ::treesitter_types::ParseError::missing_field("children", node)
2220 })?
2221 };
2222 ::treesitter_types::runtime::maybe_grow_stack(|| {
2223 <VariableDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2224 child, src,
2225 )
2226 })?
2227 },
2228 })
2229 }
2230}
2231impl ::treesitter_types::Spanned for VariableDeclaration<'_> {
2232 fn span(&self) -> ::treesitter_types::Span {
2233 self.span
2234 }
2235}
2236#[derive(Debug, Clone, PartialEq, Eq)]
2237pub struct VariableList<'tree> {
2238 pub span: ::treesitter_types::Span,
2239 pub attribute: ::std::vec::Vec<Attribute<'tree>>,
2240 pub name: ::std::vec::Vec<Variable<'tree>>,
2241}
2242impl<'tree> ::treesitter_types::FromNode<'tree> for VariableList<'tree> {
2243 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2244 fn from_node(
2245 node: ::treesitter_types::tree_sitter::Node<'tree>,
2246 src: &'tree [u8],
2247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2248 debug_assert_eq!(node.kind(), "variable_list");
2249 Ok(Self {
2250 span: ::treesitter_types::Span::from(node),
2251 attribute: {
2252 let mut cursor = node.walk();
2253 let mut items = ::std::vec::Vec::new();
2254 for child in node.children_by_field_name("attribute", &mut cursor) {
2255 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2256 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)
2257 })?);
2258 }
2259 items
2260 },
2261 name: {
2262 let mut cursor = node.walk();
2263 let mut items = ::std::vec::Vec::new();
2264 for child in node.children_by_field_name("name", &mut cursor) {
2265 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2266 <Variable as ::treesitter_types::FromNode>::from_node(child, src)
2267 })?);
2268 }
2269 items
2270 },
2271 })
2272 }
2273}
2274impl ::treesitter_types::Spanned for VariableList<'_> {
2275 fn span(&self) -> ::treesitter_types::Span {
2276 self.span
2277 }
2278}
2279#[derive(Debug, Clone, PartialEq, Eq)]
2280pub struct WhileStatement<'tree> {
2281 pub span: ::treesitter_types::Span,
2282 pub body: ::core::option::Option<Block<'tree>>,
2283 pub condition: Expression<'tree>,
2284}
2285impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
2286 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2287 fn from_node(
2288 node: ::treesitter_types::tree_sitter::Node<'tree>,
2289 src: &'tree [u8],
2290 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2291 debug_assert_eq!(node.kind(), "while_statement");
2292 Ok(Self {
2293 span: ::treesitter_types::Span::from(node),
2294 body: match node.child_by_field_name("body") {
2295 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2296 <Block as ::treesitter_types::FromNode>::from_node(child, src)
2297 })?),
2298 None => None,
2299 },
2300 condition: {
2301 let child = node.child_by_field_name("condition").ok_or_else(|| {
2302 ::treesitter_types::ParseError::missing_field("condition", node)
2303 })?;
2304 ::treesitter_types::runtime::maybe_grow_stack(|| {
2305 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2306 })?
2307 },
2308 })
2309 }
2310}
2311impl ::treesitter_types::Spanned for WhileStatement<'_> {
2312 fn span(&self) -> ::treesitter_types::Span {
2313 self.span
2314 }
2315}
2316#[derive(Debug, Clone, PartialEq, Eq)]
2317pub struct BreakStatement<'tree> {
2318 pub span: ::treesitter_types::Span,
2319 text: &'tree str,
2320}
2321impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
2322 fn from_node(
2323 node: ::treesitter_types::tree_sitter::Node<'tree>,
2324 src: &'tree [u8],
2325 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2326 debug_assert_eq!(node.kind(), "break_statement");
2327 Ok(Self {
2328 span: ::treesitter_types::Span::from(node),
2329 text: node.utf8_text(src)?,
2330 })
2331 }
2332}
2333impl<'tree> ::treesitter_types::LeafNode<'tree> for BreakStatement<'tree> {
2334 fn text(&self) -> &'tree str {
2335 self.text
2336 }
2337}
2338impl ::treesitter_types::Spanned for BreakStatement<'_> {
2339 fn span(&self) -> ::treesitter_types::Span {
2340 self.span
2341 }
2342}
2343#[derive(Debug, Clone, PartialEq, Eq)]
2344pub struct CommentContent<'tree> {
2345 pub span: ::treesitter_types::Span,
2346 text: &'tree str,
2347}
2348impl<'tree> ::treesitter_types::FromNode<'tree> for CommentContent<'tree> {
2349 fn from_node(
2350 node: ::treesitter_types::tree_sitter::Node<'tree>,
2351 src: &'tree [u8],
2352 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2353 debug_assert_eq!(node.kind(), "comment_content");
2354 Ok(Self {
2355 span: ::treesitter_types::Span::from(node),
2356 text: node.utf8_text(src)?,
2357 })
2358 }
2359}
2360impl<'tree> ::treesitter_types::LeafNode<'tree> for CommentContent<'tree> {
2361 fn text(&self) -> &'tree str {
2362 self.text
2363 }
2364}
2365impl ::treesitter_types::Spanned for CommentContent<'_> {
2366 fn span(&self) -> ::treesitter_types::Span {
2367 self.span
2368 }
2369}
2370#[derive(Debug, Clone, PartialEq, Eq)]
2371pub struct EscapeSequence<'tree> {
2372 pub span: ::treesitter_types::Span,
2373 text: &'tree str,
2374}
2375impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
2376 fn from_node(
2377 node: ::treesitter_types::tree_sitter::Node<'tree>,
2378 src: &'tree [u8],
2379 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2380 debug_assert_eq!(node.kind(), "escape_sequence");
2381 Ok(Self {
2382 span: ::treesitter_types::Span::from(node),
2383 text: node.utf8_text(src)?,
2384 })
2385 }
2386}
2387impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
2388 fn text(&self) -> &'tree str {
2389 self.text
2390 }
2391}
2392impl ::treesitter_types::Spanned for EscapeSequence<'_> {
2393 fn span(&self) -> ::treesitter_types::Span {
2394 self.span
2395 }
2396}
2397#[derive(Debug, Clone, PartialEq, Eq)]
2398pub struct False<'tree> {
2399 pub span: ::treesitter_types::Span,
2400 text: &'tree str,
2401}
2402impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
2403 fn from_node(
2404 node: ::treesitter_types::tree_sitter::Node<'tree>,
2405 src: &'tree [u8],
2406 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2407 debug_assert_eq!(node.kind(), "false");
2408 Ok(Self {
2409 span: ::treesitter_types::Span::from(node),
2410 text: node.utf8_text(src)?,
2411 })
2412 }
2413}
2414impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
2415 fn text(&self) -> &'tree str {
2416 self.text
2417 }
2418}
2419impl ::treesitter_types::Spanned for False<'_> {
2420 fn span(&self) -> ::treesitter_types::Span {
2421 self.span
2422 }
2423}
2424#[derive(Debug, Clone, PartialEq, Eq)]
2425pub struct HashBangLine<'tree> {
2426 pub span: ::treesitter_types::Span,
2427 text: &'tree str,
2428}
2429impl<'tree> ::treesitter_types::FromNode<'tree> for HashBangLine<'tree> {
2430 fn from_node(
2431 node: ::treesitter_types::tree_sitter::Node<'tree>,
2432 src: &'tree [u8],
2433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2434 debug_assert_eq!(node.kind(), "hash_bang_line");
2435 Ok(Self {
2436 span: ::treesitter_types::Span::from(node),
2437 text: node.utf8_text(src)?,
2438 })
2439 }
2440}
2441impl<'tree> ::treesitter_types::LeafNode<'tree> for HashBangLine<'tree> {
2442 fn text(&self) -> &'tree str {
2443 self.text
2444 }
2445}
2446impl ::treesitter_types::Spanned for HashBangLine<'_> {
2447 fn span(&self) -> ::treesitter_types::Span {
2448 self.span
2449 }
2450}
2451#[derive(Debug, Clone, PartialEq, Eq)]
2452pub struct Identifier<'tree> {
2453 pub span: ::treesitter_types::Span,
2454 text: &'tree str,
2455}
2456impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
2457 fn from_node(
2458 node: ::treesitter_types::tree_sitter::Node<'tree>,
2459 src: &'tree [u8],
2460 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2461 debug_assert_eq!(node.kind(), "identifier");
2462 Ok(Self {
2463 span: ::treesitter_types::Span::from(node),
2464 text: node.utf8_text(src)?,
2465 })
2466 }
2467}
2468impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
2469 fn text(&self) -> &'tree str {
2470 self.text
2471 }
2472}
2473impl ::treesitter_types::Spanned for Identifier<'_> {
2474 fn span(&self) -> ::treesitter_types::Span {
2475 self.span
2476 }
2477}
2478#[derive(Debug, Clone, PartialEq, Eq)]
2479pub struct Nil<'tree> {
2480 pub span: ::treesitter_types::Span,
2481 text: &'tree str,
2482}
2483impl<'tree> ::treesitter_types::FromNode<'tree> for Nil<'tree> {
2484 fn from_node(
2485 node: ::treesitter_types::tree_sitter::Node<'tree>,
2486 src: &'tree [u8],
2487 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2488 debug_assert_eq!(node.kind(), "nil");
2489 Ok(Self {
2490 span: ::treesitter_types::Span::from(node),
2491 text: node.utf8_text(src)?,
2492 })
2493 }
2494}
2495impl<'tree> ::treesitter_types::LeafNode<'tree> for Nil<'tree> {
2496 fn text(&self) -> &'tree str {
2497 self.text
2498 }
2499}
2500impl ::treesitter_types::Spanned for Nil<'_> {
2501 fn span(&self) -> ::treesitter_types::Span {
2502 self.span
2503 }
2504}
2505#[derive(Debug, Clone, PartialEq, Eq)]
2506pub struct Number<'tree> {
2507 pub span: ::treesitter_types::Span,
2508 text: &'tree str,
2509}
2510impl<'tree> ::treesitter_types::FromNode<'tree> for Number<'tree> {
2511 fn from_node(
2512 node: ::treesitter_types::tree_sitter::Node<'tree>,
2513 src: &'tree [u8],
2514 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2515 debug_assert_eq!(node.kind(), "number");
2516 Ok(Self {
2517 span: ::treesitter_types::Span::from(node),
2518 text: node.utf8_text(src)?,
2519 })
2520 }
2521}
2522impl<'tree> ::treesitter_types::LeafNode<'tree> for Number<'tree> {
2523 fn text(&self) -> &'tree str {
2524 self.text
2525 }
2526}
2527impl ::treesitter_types::Spanned for Number<'_> {
2528 fn span(&self) -> ::treesitter_types::Span {
2529 self.span
2530 }
2531}
2532#[derive(Debug, Clone, PartialEq, Eq)]
2533pub struct True<'tree> {
2534 pub span: ::treesitter_types::Span,
2535 text: &'tree str,
2536}
2537impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
2538 fn from_node(
2539 node: ::treesitter_types::tree_sitter::Node<'tree>,
2540 src: &'tree [u8],
2541 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2542 debug_assert_eq!(node.kind(), "true");
2543 Ok(Self {
2544 span: ::treesitter_types::Span::from(node),
2545 text: node.utf8_text(src)?,
2546 })
2547 }
2548}
2549impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
2550 fn text(&self) -> &'tree str {
2551 self.text
2552 }
2553}
2554impl ::treesitter_types::Spanned for True<'_> {
2555 fn span(&self) -> ::treesitter_types::Span {
2556 self.span
2557 }
2558}
2559#[derive(Debug, Clone, PartialEq, Eq)]
2560pub struct VarargExpression<'tree> {
2561 pub span: ::treesitter_types::Span,
2562 text: &'tree str,
2563}
2564impl<'tree> ::treesitter_types::FromNode<'tree> for VarargExpression<'tree> {
2565 fn from_node(
2566 node: ::treesitter_types::tree_sitter::Node<'tree>,
2567 src: &'tree [u8],
2568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2569 debug_assert_eq!(node.kind(), "vararg_expression");
2570 Ok(Self {
2571 span: ::treesitter_types::Span::from(node),
2572 text: node.utf8_text(src)?,
2573 })
2574 }
2575}
2576impl<'tree> ::treesitter_types::LeafNode<'tree> for VarargExpression<'tree> {
2577 fn text(&self) -> &'tree str {
2578 self.text
2579 }
2580}
2581impl ::treesitter_types::Spanned for VarargExpression<'_> {
2582 fn span(&self) -> ::treesitter_types::Span {
2583 self.span
2584 }
2585}
2586#[derive(Debug, Clone, PartialEq, Eq)]
2587pub enum AssignmentStatementOperator {
2588 Eq(::treesitter_types::Span),
2589}
2590impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentStatementOperator {
2591 #[allow(clippy::collapsible_else_if)]
2592 fn from_node(
2593 node: ::treesitter_types::tree_sitter::Node<'tree>,
2594 _src: &'tree [u8],
2595 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2596 match node.kind() {
2597 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
2598 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2599 }
2600 }
2601}
2602impl ::treesitter_types::Spanned for AssignmentStatementOperator {
2603 fn span(&self) -> ::treesitter_types::Span {
2604 match self {
2605 Self::Eq(span) => *span,
2606 }
2607 }
2608}
2609#[derive(Debug, Clone, PartialEq, Eq)]
2610pub enum AssignmentStatementChildren<'tree> {
2611 ExpressionList(::std::boxed::Box<ExpressionList<'tree>>),
2612 VariableList(::std::boxed::Box<VariableList<'tree>>),
2613}
2614impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentStatementChildren<'tree> {
2615 #[allow(clippy::collapsible_else_if)]
2616 fn from_node(
2617 node: ::treesitter_types::tree_sitter::Node<'tree>,
2618 src: &'tree [u8],
2619 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2620 match node.kind() {
2621 "expression_list" => Ok(Self::ExpressionList(::std::boxed::Box::new(
2622 ::treesitter_types::runtime::maybe_grow_stack(|| {
2623 <ExpressionList as ::treesitter_types::FromNode>::from_node(node, src)
2624 })?,
2625 ))),
2626 "variable_list" => Ok(Self::VariableList(::std::boxed::Box::new(
2627 ::treesitter_types::runtime::maybe_grow_stack(|| {
2628 <VariableList as ::treesitter_types::FromNode>::from_node(node, src)
2629 })?,
2630 ))),
2631 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2632 }
2633 }
2634}
2635impl ::treesitter_types::Spanned for AssignmentStatementChildren<'_> {
2636 fn span(&self) -> ::treesitter_types::Span {
2637 match self {
2638 Self::ExpressionList(inner) => inner.span(),
2639 Self::VariableList(inner) => inner.span(),
2640 }
2641 }
2642}
2643#[derive(Debug, Clone, PartialEq, Eq)]
2644pub enum BinaryExpressionOperator {
2645 Percent(::treesitter_types::Span),
2646 Amp(::treesitter_types::Span),
2647 Star(::treesitter_types::Span),
2648 Plus(::treesitter_types::Span),
2649 Minus(::treesitter_types::Span),
2650 DotDot(::treesitter_types::Span),
2651 Slash(::treesitter_types::Span),
2652 SlashSlash(::treesitter_types::Span),
2653 Lt(::treesitter_types::Span),
2654 Shl(::treesitter_types::Span),
2655 LtEq(::treesitter_types::Span),
2656 EqEq(::treesitter_types::Span),
2657 Gt(::treesitter_types::Span),
2658 GtEq(::treesitter_types::Span),
2659 Shr(::treesitter_types::Span),
2660 Caret(::treesitter_types::Span),
2661 And(::treesitter_types::Span),
2662 Or(::treesitter_types::Span),
2663 Pipe(::treesitter_types::Span),
2664 Tilde(::treesitter_types::Span),
2665 TildeEq(::treesitter_types::Span),
2666}
2667impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
2668 #[allow(clippy::collapsible_else_if)]
2669 fn from_node(
2670 node: ::treesitter_types::tree_sitter::Node<'tree>,
2671 _src: &'tree [u8],
2672 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2673 match node.kind() {
2674 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
2675 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
2676 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
2677 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
2678 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
2679 ".." => Ok(Self::DotDot(::treesitter_types::Span::from(node))),
2680 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
2681 "//" => Ok(Self::SlashSlash(::treesitter_types::Span::from(node))),
2682 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
2683 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
2684 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
2685 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
2686 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
2687 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
2688 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
2689 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
2690 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
2691 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
2692 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
2693 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
2694 "~=" => Ok(Self::TildeEq(::treesitter_types::Span::from(node))),
2695 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2696 }
2697 }
2698}
2699impl ::treesitter_types::Spanned for BinaryExpressionOperator {
2700 fn span(&self) -> ::treesitter_types::Span {
2701 match self {
2702 Self::Percent(span) => *span,
2703 Self::Amp(span) => *span,
2704 Self::Star(span) => *span,
2705 Self::Plus(span) => *span,
2706 Self::Minus(span) => *span,
2707 Self::DotDot(span) => *span,
2708 Self::Slash(span) => *span,
2709 Self::SlashSlash(span) => *span,
2710 Self::Lt(span) => *span,
2711 Self::Shl(span) => *span,
2712 Self::LtEq(span) => *span,
2713 Self::EqEq(span) => *span,
2714 Self::Gt(span) => *span,
2715 Self::GtEq(span) => *span,
2716 Self::Shr(span) => *span,
2717 Self::Caret(span) => *span,
2718 Self::And(span) => *span,
2719 Self::Or(span) => *span,
2720 Self::Pipe(span) => *span,
2721 Self::Tilde(span) => *span,
2722 Self::TildeEq(span) => *span,
2723 }
2724 }
2725}
2726#[derive(Debug, Clone, PartialEq, Eq)]
2727pub enum BlockChildren<'tree> {
2728 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
2729 Statement(::std::boxed::Box<Statement<'tree>>),
2730}
2731impl<'tree> ::treesitter_types::FromNode<'tree> for BlockChildren<'tree> {
2732 #[allow(clippy::collapsible_else_if)]
2733 fn from_node(
2734 node: ::treesitter_types::tree_sitter::Node<'tree>,
2735 src: &'tree [u8],
2736 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2737 match node.kind() {
2738 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
2739 ::treesitter_types::runtime::maybe_grow_stack(|| {
2740 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
2741 })?,
2742 ))),
2743 _other => {
2744 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
2745 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
2746 }) {
2747 Ok(Self::Statement(::std::boxed::Box::new(v)))
2748 } else {
2749 Err(::treesitter_types::ParseError::unexpected_kind(
2750 _other, node,
2751 ))
2752 }
2753 }
2754 }
2755 }
2756}
2757impl ::treesitter_types::Spanned for BlockChildren<'_> {
2758 fn span(&self) -> ::treesitter_types::Span {
2759 match self {
2760 Self::ReturnStatement(inner) => inner.span(),
2761 Self::Statement(inner) => inner.span(),
2762 }
2763 }
2764}
2765#[derive(Debug, Clone, PartialEq, Eq)]
2766pub enum BracketIndexExpressionTable<'tree> {
2767 FunctionCall(::std::boxed::Box<FunctionCall<'tree>>),
2768 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
2769 Variable(::std::boxed::Box<Variable<'tree>>),
2770}
2771impl<'tree> ::treesitter_types::FromNode<'tree> for BracketIndexExpressionTable<'tree> {
2772 #[allow(clippy::collapsible_else_if)]
2773 fn from_node(
2774 node: ::treesitter_types::tree_sitter::Node<'tree>,
2775 src: &'tree [u8],
2776 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2777 match node.kind() {
2778 "function_call" => Ok(Self::FunctionCall(::std::boxed::Box::new(
2779 ::treesitter_types::runtime::maybe_grow_stack(|| {
2780 <FunctionCall as ::treesitter_types::FromNode>::from_node(node, src)
2781 })?,
2782 ))),
2783 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
2784 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
2785 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
2786 })?),
2787 )),
2788 _other => {
2789 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
2790 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
2791 }) {
2792 Ok(Self::Variable(::std::boxed::Box::new(v)))
2793 } else {
2794 Err(::treesitter_types::ParseError::unexpected_kind(
2795 _other, node,
2796 ))
2797 }
2798 }
2799 }
2800 }
2801}
2802impl ::treesitter_types::Spanned for BracketIndexExpressionTable<'_> {
2803 fn span(&self) -> ::treesitter_types::Span {
2804 match self {
2805 Self::FunctionCall(inner) => inner.span(),
2806 Self::ParenthesizedExpression(inner) => inner.span(),
2807 Self::Variable(inner) => inner.span(),
2808 }
2809 }
2810}
2811#[derive(Debug, Clone, PartialEq, Eq)]
2812pub enum ChunkChildren<'tree> {
2813 HashBangLine(::std::boxed::Box<HashBangLine<'tree>>),
2814 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
2815 Statement(::std::boxed::Box<Statement<'tree>>),
2816}
2817impl<'tree> ::treesitter_types::FromNode<'tree> for ChunkChildren<'tree> {
2818 #[allow(clippy::collapsible_else_if)]
2819 fn from_node(
2820 node: ::treesitter_types::tree_sitter::Node<'tree>,
2821 src: &'tree [u8],
2822 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2823 match node.kind() {
2824 "hash_bang_line" => Ok(Self::HashBangLine(::std::boxed::Box::new(
2825 ::treesitter_types::runtime::maybe_grow_stack(|| {
2826 <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)
2827 })?,
2828 ))),
2829 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
2830 ::treesitter_types::runtime::maybe_grow_stack(|| {
2831 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
2832 })?,
2833 ))),
2834 _other => {
2835 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
2836 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
2837 }) {
2838 Ok(Self::Statement(::std::boxed::Box::new(v)))
2839 } else {
2840 Err(::treesitter_types::ParseError::unexpected_kind(
2841 _other, node,
2842 ))
2843 }
2844 }
2845 }
2846 }
2847}
2848impl ::treesitter_types::Spanned for ChunkChildren<'_> {
2849 fn span(&self) -> ::treesitter_types::Span {
2850 match self {
2851 Self::HashBangLine(inner) => inner.span(),
2852 Self::ReturnStatement(inner) => inner.span(),
2853 Self::Statement(inner) => inner.span(),
2854 }
2855 }
2856}
2857#[derive(Debug, Clone, PartialEq, Eq)]
2858pub enum CommentEnd {
2859 RBracketRBracket(::treesitter_types::Span),
2860}
2861impl<'tree> ::treesitter_types::FromNode<'tree> for CommentEnd {
2862 #[allow(clippy::collapsible_else_if)]
2863 fn from_node(
2864 node: ::treesitter_types::tree_sitter::Node<'tree>,
2865 _src: &'tree [u8],
2866 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2867 match node.kind() {
2868 "]]" => Ok(Self::RBracketRBracket(::treesitter_types::Span::from(node))),
2869 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2870 }
2871 }
2872}
2873impl ::treesitter_types::Spanned for CommentEnd {
2874 fn span(&self) -> ::treesitter_types::Span {
2875 match self {
2876 Self::RBracketRBracket(span) => *span,
2877 }
2878 }
2879}
2880#[derive(Debug, Clone, PartialEq, Eq)]
2881pub enum CommentStart {
2882 MinusMinus(::treesitter_types::Span),
2883 LBracketLBracket(::treesitter_types::Span),
2884}
2885impl<'tree> ::treesitter_types::FromNode<'tree> for CommentStart {
2886 #[allow(clippy::collapsible_else_if)]
2887 fn from_node(
2888 node: ::treesitter_types::tree_sitter::Node<'tree>,
2889 _src: &'tree [u8],
2890 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2891 match node.kind() {
2892 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
2893 "[[" => Ok(Self::LBracketLBracket(::treesitter_types::Span::from(node))),
2894 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2895 }
2896 }
2897}
2898impl ::treesitter_types::Spanned for CommentStart {
2899 fn span(&self) -> ::treesitter_types::Span {
2900 match self {
2901 Self::MinusMinus(span) => *span,
2902 Self::LBracketLBracket(span) => *span,
2903 }
2904 }
2905}
2906#[derive(Debug, Clone, PartialEq, Eq)]
2907pub enum DotIndexExpressionTable<'tree> {
2908 FunctionCall(::std::boxed::Box<FunctionCall<'tree>>),
2909 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
2910 Variable(::std::boxed::Box<Variable<'tree>>),
2911}
2912impl<'tree> ::treesitter_types::FromNode<'tree> for DotIndexExpressionTable<'tree> {
2913 #[allow(clippy::collapsible_else_if)]
2914 fn from_node(
2915 node: ::treesitter_types::tree_sitter::Node<'tree>,
2916 src: &'tree [u8],
2917 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2918 match node.kind() {
2919 "function_call" => Ok(Self::FunctionCall(::std::boxed::Box::new(
2920 ::treesitter_types::runtime::maybe_grow_stack(|| {
2921 <FunctionCall as ::treesitter_types::FromNode>::from_node(node, src)
2922 })?,
2923 ))),
2924 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
2925 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
2926 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
2927 })?),
2928 )),
2929 _other => {
2930 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
2931 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
2932 }) {
2933 Ok(Self::Variable(::std::boxed::Box::new(v)))
2934 } else {
2935 Err(::treesitter_types::ParseError::unexpected_kind(
2936 _other, node,
2937 ))
2938 }
2939 }
2940 }
2941 }
2942}
2943impl ::treesitter_types::Spanned for DotIndexExpressionTable<'_> {
2944 fn span(&self) -> ::treesitter_types::Span {
2945 match self {
2946 Self::FunctionCall(inner) => inner.span(),
2947 Self::ParenthesizedExpression(inner) => inner.span(),
2948 Self::Variable(inner) => inner.span(),
2949 }
2950 }
2951}
2952#[derive(Debug, Clone, PartialEq, Eq)]
2953pub enum FieldName<'tree> {
2954 Expression(::std::boxed::Box<Expression<'tree>>),
2955 Global(::treesitter_types::Span),
2956 Identifier(::std::boxed::Box<Identifier<'tree>>),
2957}
2958impl<'tree> ::treesitter_types::FromNode<'tree> for FieldName<'tree> {
2959 #[allow(clippy::collapsible_else_if)]
2960 fn from_node(
2961 node: ::treesitter_types::tree_sitter::Node<'tree>,
2962 src: &'tree [u8],
2963 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2964 match node.kind() {
2965 "global" => Ok(Self::Global(::treesitter_types::Span::from(node))),
2966 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
2967 ::treesitter_types::runtime::maybe_grow_stack(|| {
2968 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
2969 })?,
2970 ))),
2971 _other => {
2972 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
2973 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
2974 }) {
2975 Ok(Self::Expression(::std::boxed::Box::new(v)))
2976 } else {
2977 Err(::treesitter_types::ParseError::unexpected_kind(
2978 _other, node,
2979 ))
2980 }
2981 }
2982 }
2983 }
2984}
2985impl ::treesitter_types::Spanned for FieldName<'_> {
2986 fn span(&self) -> ::treesitter_types::Span {
2987 match self {
2988 Self::Expression(inner) => inner.span(),
2989 Self::Global(span) => *span,
2990 Self::Identifier(inner) => inner.span(),
2991 }
2992 }
2993}
2994#[derive(Debug, Clone, PartialEq, Eq)]
2995pub enum FieldOperator {
2996 Eq(::treesitter_types::Span),
2997}
2998impl<'tree> ::treesitter_types::FromNode<'tree> for FieldOperator {
2999 #[allow(clippy::collapsible_else_if)]
3000 fn from_node(
3001 node: ::treesitter_types::tree_sitter::Node<'tree>,
3002 _src: &'tree [u8],
3003 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3004 match node.kind() {
3005 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
3006 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3007 }
3008 }
3009}
3010impl ::treesitter_types::Spanned for FieldOperator {
3011 fn span(&self) -> ::treesitter_types::Span {
3012 match self {
3013 Self::Eq(span) => *span,
3014 }
3015 }
3016}
3017#[derive(Debug, Clone, PartialEq, Eq)]
3018pub enum ForGenericClauseChildren<'tree> {
3019 ExpressionList(::std::boxed::Box<ExpressionList<'tree>>),
3020 VariableList(::std::boxed::Box<VariableList<'tree>>),
3021}
3022impl<'tree> ::treesitter_types::FromNode<'tree> for ForGenericClauseChildren<'tree> {
3023 #[allow(clippy::collapsible_else_if)]
3024 fn from_node(
3025 node: ::treesitter_types::tree_sitter::Node<'tree>,
3026 src: &'tree [u8],
3027 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3028 match node.kind() {
3029 "expression_list" => Ok(Self::ExpressionList(::std::boxed::Box::new(
3030 ::treesitter_types::runtime::maybe_grow_stack(|| {
3031 <ExpressionList as ::treesitter_types::FromNode>::from_node(node, src)
3032 })?,
3033 ))),
3034 "variable_list" => Ok(Self::VariableList(::std::boxed::Box::new(
3035 ::treesitter_types::runtime::maybe_grow_stack(|| {
3036 <VariableList as ::treesitter_types::FromNode>::from_node(node, src)
3037 })?,
3038 ))),
3039 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3040 }
3041 }
3042}
3043impl ::treesitter_types::Spanned for ForGenericClauseChildren<'_> {
3044 fn span(&self) -> ::treesitter_types::Span {
3045 match self {
3046 Self::ExpressionList(inner) => inner.span(),
3047 Self::VariableList(inner) => inner.span(),
3048 }
3049 }
3050}
3051#[derive(Debug, Clone, PartialEq, Eq)]
3052pub enum ForNumericClauseOperator {
3053 Eq(::treesitter_types::Span),
3054}
3055impl<'tree> ::treesitter_types::FromNode<'tree> for ForNumericClauseOperator {
3056 #[allow(clippy::collapsible_else_if)]
3057 fn from_node(
3058 node: ::treesitter_types::tree_sitter::Node<'tree>,
3059 _src: &'tree [u8],
3060 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3061 match node.kind() {
3062 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
3063 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3064 }
3065 }
3066}
3067impl ::treesitter_types::Spanned for ForNumericClauseOperator {
3068 fn span(&self) -> ::treesitter_types::Span {
3069 match self {
3070 Self::Eq(span) => *span,
3071 }
3072 }
3073}
3074#[derive(Debug, Clone, PartialEq, Eq)]
3075pub enum ForStatementClause<'tree> {
3076 ForGenericClause(::std::boxed::Box<ForGenericClause<'tree>>),
3077 ForNumericClause(::std::boxed::Box<ForNumericClause<'tree>>),
3078}
3079impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementClause<'tree> {
3080 #[allow(clippy::collapsible_else_if)]
3081 fn from_node(
3082 node: ::treesitter_types::tree_sitter::Node<'tree>,
3083 src: &'tree [u8],
3084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3085 match node.kind() {
3086 "for_generic_clause" => Ok(Self::ForGenericClause(::std::boxed::Box::new(
3087 ::treesitter_types::runtime::maybe_grow_stack(|| {
3088 <ForGenericClause as ::treesitter_types::FromNode>::from_node(node, src)
3089 })?,
3090 ))),
3091 "for_numeric_clause" => Ok(Self::ForNumericClause(::std::boxed::Box::new(
3092 ::treesitter_types::runtime::maybe_grow_stack(|| {
3093 <ForNumericClause as ::treesitter_types::FromNode>::from_node(node, src)
3094 })?,
3095 ))),
3096 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3097 }
3098 }
3099}
3100impl ::treesitter_types::Spanned for ForStatementClause<'_> {
3101 fn span(&self) -> ::treesitter_types::Span {
3102 match self {
3103 Self::ForGenericClause(inner) => inner.span(),
3104 Self::ForNumericClause(inner) => inner.span(),
3105 }
3106 }
3107}
3108#[derive(Debug, Clone, PartialEq, Eq)]
3109pub enum FunctionCallName<'tree> {
3110 FunctionCall(::std::boxed::Box<FunctionCall<'tree>>),
3111 MethodIndexExpression(::std::boxed::Box<MethodIndexExpression<'tree>>),
3112 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
3113 Variable(::std::boxed::Box<Variable<'tree>>),
3114}
3115impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionCallName<'tree> {
3116 #[allow(clippy::collapsible_else_if)]
3117 fn from_node(
3118 node: ::treesitter_types::tree_sitter::Node<'tree>,
3119 src: &'tree [u8],
3120 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3121 match node.kind() {
3122 "function_call" => Ok(Self::FunctionCall(::std::boxed::Box::new(
3123 ::treesitter_types::runtime::maybe_grow_stack(|| {
3124 <FunctionCall as ::treesitter_types::FromNode>::from_node(node, src)
3125 })?,
3126 ))),
3127 "method_index_expression" => Ok(Self::MethodIndexExpression(::std::boxed::Box::new(
3128 ::treesitter_types::runtime::maybe_grow_stack(|| {
3129 <MethodIndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
3130 })?,
3131 ))),
3132 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
3133 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
3134 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
3135 })?),
3136 )),
3137 _other => {
3138 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
3139 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
3140 }) {
3141 Ok(Self::Variable(::std::boxed::Box::new(v)))
3142 } else {
3143 Err(::treesitter_types::ParseError::unexpected_kind(
3144 _other, node,
3145 ))
3146 }
3147 }
3148 }
3149 }
3150}
3151impl ::treesitter_types::Spanned for FunctionCallName<'_> {
3152 fn span(&self) -> ::treesitter_types::Span {
3153 match self {
3154 Self::FunctionCall(inner) => inner.span(),
3155 Self::MethodIndexExpression(inner) => inner.span(),
3156 Self::ParenthesizedExpression(inner) => inner.span(),
3157 Self::Variable(inner) => inner.span(),
3158 }
3159 }
3160}
3161#[derive(Debug, Clone, PartialEq, Eq)]
3162pub enum FunctionDeclarationName<'tree> {
3163 DotIndexExpression(::std::boxed::Box<DotIndexExpression<'tree>>),
3164 Identifier(::std::boxed::Box<Identifier<'tree>>),
3165 MethodIndexExpression(::std::boxed::Box<MethodIndexExpression<'tree>>),
3166}
3167impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclarationName<'tree> {
3168 #[allow(clippy::collapsible_else_if)]
3169 fn from_node(
3170 node: ::treesitter_types::tree_sitter::Node<'tree>,
3171 src: &'tree [u8],
3172 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3173 match node.kind() {
3174 "dot_index_expression" => Ok(Self::DotIndexExpression(::std::boxed::Box::new(
3175 ::treesitter_types::runtime::maybe_grow_stack(|| {
3176 <DotIndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
3177 })?,
3178 ))),
3179 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
3180 ::treesitter_types::runtime::maybe_grow_stack(|| {
3181 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
3182 })?,
3183 ))),
3184 "method_index_expression" => Ok(Self::MethodIndexExpression(::std::boxed::Box::new(
3185 ::treesitter_types::runtime::maybe_grow_stack(|| {
3186 <MethodIndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
3187 })?,
3188 ))),
3189 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3190 }
3191 }
3192}
3193impl ::treesitter_types::Spanned for FunctionDeclarationName<'_> {
3194 fn span(&self) -> ::treesitter_types::Span {
3195 match self {
3196 Self::DotIndexExpression(inner) => inner.span(),
3197 Self::Identifier(inner) => inner.span(),
3198 Self::MethodIndexExpression(inner) => inner.span(),
3199 }
3200 }
3201}
3202#[derive(Debug, Clone, PartialEq, Eq)]
3203pub enum IfStatementAlternative<'tree> {
3204 ElseStatement(::std::boxed::Box<ElseStatement<'tree>>),
3205 ElseifStatement(::std::boxed::Box<ElseifStatement<'tree>>),
3206}
3207impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatementAlternative<'tree> {
3208 #[allow(clippy::collapsible_else_if)]
3209 fn from_node(
3210 node: ::treesitter_types::tree_sitter::Node<'tree>,
3211 src: &'tree [u8],
3212 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3213 match node.kind() {
3214 "else_statement" => Ok(Self::ElseStatement(::std::boxed::Box::new(
3215 ::treesitter_types::runtime::maybe_grow_stack(|| {
3216 <ElseStatement as ::treesitter_types::FromNode>::from_node(node, src)
3217 })?,
3218 ))),
3219 "elseif_statement" => Ok(Self::ElseifStatement(::std::boxed::Box::new(
3220 ::treesitter_types::runtime::maybe_grow_stack(|| {
3221 <ElseifStatement as ::treesitter_types::FromNode>::from_node(node, src)
3222 })?,
3223 ))),
3224 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3225 }
3226 }
3227}
3228impl ::treesitter_types::Spanned for IfStatementAlternative<'_> {
3229 fn span(&self) -> ::treesitter_types::Span {
3230 match self {
3231 Self::ElseStatement(inner) => inner.span(),
3232 Self::ElseifStatement(inner) => inner.span(),
3233 }
3234 }
3235}
3236#[derive(Debug, Clone, PartialEq, Eq)]
3237pub enum MethodIndexExpressionTable<'tree> {
3238 FunctionCall(::std::boxed::Box<FunctionCall<'tree>>),
3239 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
3240 Variable(::std::boxed::Box<Variable<'tree>>),
3241}
3242impl<'tree> ::treesitter_types::FromNode<'tree> for MethodIndexExpressionTable<'tree> {
3243 #[allow(clippy::collapsible_else_if)]
3244 fn from_node(
3245 node: ::treesitter_types::tree_sitter::Node<'tree>,
3246 src: &'tree [u8],
3247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3248 match node.kind() {
3249 "function_call" => Ok(Self::FunctionCall(::std::boxed::Box::new(
3250 ::treesitter_types::runtime::maybe_grow_stack(|| {
3251 <FunctionCall as ::treesitter_types::FromNode>::from_node(node, src)
3252 })?,
3253 ))),
3254 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
3255 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
3256 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
3257 })?),
3258 )),
3259 _other => {
3260 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
3261 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
3262 }) {
3263 Ok(Self::Variable(::std::boxed::Box::new(v)))
3264 } else {
3265 Err(::treesitter_types::ParseError::unexpected_kind(
3266 _other, node,
3267 ))
3268 }
3269 }
3270 }
3271 }
3272}
3273impl ::treesitter_types::Spanned for MethodIndexExpressionTable<'_> {
3274 fn span(&self) -> ::treesitter_types::Span {
3275 match self {
3276 Self::FunctionCall(inner) => inner.span(),
3277 Self::ParenthesizedExpression(inner) => inner.span(),
3278 Self::Variable(inner) => inner.span(),
3279 }
3280 }
3281}
3282#[derive(Debug, Clone, PartialEq, Eq)]
3283pub enum StringEnd {
3284 DoubleQuote(::treesitter_types::Span),
3285 SingleQuote(::treesitter_types::Span),
3286 RBracketRBracket(::treesitter_types::Span),
3287}
3288impl<'tree> ::treesitter_types::FromNode<'tree> for StringEnd {
3289 #[allow(clippy::collapsible_else_if)]
3290 fn from_node(
3291 node: ::treesitter_types::tree_sitter::Node<'tree>,
3292 _src: &'tree [u8],
3293 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3294 match node.kind() {
3295 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
3296 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
3297 "]]" => Ok(Self::RBracketRBracket(::treesitter_types::Span::from(node))),
3298 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3299 }
3300 }
3301}
3302impl ::treesitter_types::Spanned for StringEnd {
3303 fn span(&self) -> ::treesitter_types::Span {
3304 match self {
3305 Self::DoubleQuote(span) => *span,
3306 Self::SingleQuote(span) => *span,
3307 Self::RBracketRBracket(span) => *span,
3308 }
3309 }
3310}
3311#[derive(Debug, Clone, PartialEq, Eq)]
3312pub enum StringStart {
3313 DoubleQuote(::treesitter_types::Span),
3314 SingleQuote(::treesitter_types::Span),
3315 LBracketLBracket(::treesitter_types::Span),
3316}
3317impl<'tree> ::treesitter_types::FromNode<'tree> for StringStart {
3318 #[allow(clippy::collapsible_else_if)]
3319 fn from_node(
3320 node: ::treesitter_types::tree_sitter::Node<'tree>,
3321 _src: &'tree [u8],
3322 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3323 match node.kind() {
3324 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
3325 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
3326 "[[" => Ok(Self::LBracketLBracket(::treesitter_types::Span::from(node))),
3327 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3328 }
3329 }
3330}
3331impl ::treesitter_types::Spanned for StringStart {
3332 fn span(&self) -> ::treesitter_types::Span {
3333 match self {
3334 Self::DoubleQuote(span) => *span,
3335 Self::SingleQuote(span) => *span,
3336 Self::LBracketLBracket(span) => *span,
3337 }
3338 }
3339}
3340#[derive(Debug, Clone, PartialEq, Eq)]
3341pub enum UnaryExpressionOperator {
3342 Hash(::treesitter_types::Span),
3343 Minus(::treesitter_types::Span),
3344 Not(::treesitter_types::Span),
3345 Tilde(::treesitter_types::Span),
3346}
3347impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
3348 #[allow(clippy::collapsible_else_if)]
3349 fn from_node(
3350 node: ::treesitter_types::tree_sitter::Node<'tree>,
3351 _src: &'tree [u8],
3352 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3353 match node.kind() {
3354 "#" => Ok(Self::Hash(::treesitter_types::Span::from(node))),
3355 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
3356 "not" => Ok(Self::Not(::treesitter_types::Span::from(node))),
3357 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
3358 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3359 }
3360 }
3361}
3362impl ::treesitter_types::Spanned for UnaryExpressionOperator {
3363 fn span(&self) -> ::treesitter_types::Span {
3364 match self {
3365 Self::Hash(span) => *span,
3366 Self::Minus(span) => *span,
3367 Self::Not(span) => *span,
3368 Self::Tilde(span) => *span,
3369 }
3370 }
3371}
3372#[derive(Debug, Clone, PartialEq, Eq)]
3373pub enum VariableDeclarationChildren<'tree> {
3374 AssignmentStatement(::std::boxed::Box<AssignmentStatement<'tree>>),
3375 VariableList(::std::boxed::Box<VariableList<'tree>>),
3376}
3377impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarationChildren<'tree> {
3378 #[allow(clippy::collapsible_else_if)]
3379 fn from_node(
3380 node: ::treesitter_types::tree_sitter::Node<'tree>,
3381 src: &'tree [u8],
3382 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3383 match node.kind() {
3384 "assignment_statement" => Ok(Self::AssignmentStatement(::std::boxed::Box::new(
3385 ::treesitter_types::runtime::maybe_grow_stack(|| {
3386 <AssignmentStatement as ::treesitter_types::FromNode>::from_node(node, src)
3387 })?,
3388 ))),
3389 "variable_list" => Ok(Self::VariableList(::std::boxed::Box::new(
3390 ::treesitter_types::runtime::maybe_grow_stack(|| {
3391 <VariableList as ::treesitter_types::FromNode>::from_node(node, src)
3392 })?,
3393 ))),
3394 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3395 }
3396 }
3397}
3398impl ::treesitter_types::Spanned for VariableDeclarationChildren<'_> {
3399 fn span(&self) -> ::treesitter_types::Span {
3400 match self {
3401 Self::AssignmentStatement(inner) => inner.span(),
3402 Self::VariableList(inner) => inner.span(),
3403 }
3404 }
3405}
3406#[derive(Debug, Clone, PartialEq, Eq)]
3407pub enum AnyNode<'tree> {
3408 Declaration(Declaration<'tree>),
3409 Expression(Expression<'tree>),
3410 Statement(Statement<'tree>),
3411 Variable(Variable<'tree>),
3412 Arguments(Arguments<'tree>),
3413 AssignmentStatement(AssignmentStatement<'tree>),
3414 Attribute(Attribute<'tree>),
3415 BinaryExpression(BinaryExpression<'tree>),
3416 Block(Block<'tree>),
3417 BracketIndexExpression(BracketIndexExpression<'tree>),
3418 Chunk(Chunk<'tree>),
3419 Comment(Comment<'tree>),
3420 DoStatement(DoStatement<'tree>),
3421 DotIndexExpression(DotIndexExpression<'tree>),
3422 ElseStatement(ElseStatement<'tree>),
3423 ElseifStatement(ElseifStatement<'tree>),
3424 EmptyStatement(EmptyStatement<'tree>),
3425 ExpressionList(ExpressionList<'tree>),
3426 Field(Field<'tree>),
3427 ForGenericClause(ForGenericClause<'tree>),
3428 ForNumericClause(ForNumericClause<'tree>),
3429 ForStatement(ForStatement<'tree>),
3430 FunctionCall(FunctionCall<'tree>),
3431 FunctionDeclaration(FunctionDeclaration<'tree>),
3432 FunctionDefinition(FunctionDefinition<'tree>),
3433 GotoStatement(GotoStatement<'tree>),
3434 IfStatement(IfStatement<'tree>),
3435 ImplicitVariableDeclaration(ImplicitVariableDeclaration<'tree>),
3436 LabelStatement(LabelStatement<'tree>),
3437 MethodIndexExpression(MethodIndexExpression<'tree>),
3438 Parameters(Parameters<'tree>),
3439 ParenthesizedExpression(ParenthesizedExpression<'tree>),
3440 RepeatStatement(RepeatStatement<'tree>),
3441 ReturnStatement(ReturnStatement<'tree>),
3442 String(String<'tree>),
3443 StringContent(StringContent<'tree>),
3444 TableConstructor(TableConstructor<'tree>),
3445 UnaryExpression(UnaryExpression<'tree>),
3446 VariableDeclaration(VariableDeclaration<'tree>),
3447 VariableList(VariableList<'tree>),
3448 WhileStatement(WhileStatement<'tree>),
3449 BreakStatement(BreakStatement<'tree>),
3450 CommentContent(CommentContent<'tree>),
3451 EscapeSequence(EscapeSequence<'tree>),
3452 False(False<'tree>),
3453 HashBangLine(HashBangLine<'tree>),
3454 Identifier(Identifier<'tree>),
3455 Nil(Nil<'tree>),
3456 Number(Number<'tree>),
3457 True(True<'tree>),
3458 VarargExpression(VarargExpression<'tree>),
3459 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
3460}
3461impl<'tree> AnyNode<'tree> {
3462 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
3463 match node.kind() {
3464 "declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3465 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
3466 })
3467 .map(Self::Declaration)
3468 .unwrap_or(Self::Unknown(node)),
3469 "expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3470 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
3471 })
3472 .map(Self::Expression)
3473 .unwrap_or(Self::Unknown(node)),
3474 "statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3475 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
3476 })
3477 .map(Self::Statement)
3478 .unwrap_or(Self::Unknown(node)),
3479 "variable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3480 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
3481 })
3482 .map(Self::Variable)
3483 .unwrap_or(Self::Unknown(node)),
3484 "arguments" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3485 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
3486 })
3487 .map(Self::Arguments)
3488 .unwrap_or(Self::Unknown(node)),
3489 "assignment_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3490 <AssignmentStatement as ::treesitter_types::FromNode>::from_node(node, src)
3491 })
3492 .map(Self::AssignmentStatement)
3493 .unwrap_or(Self::Unknown(node)),
3494 "attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3495 <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
3496 })
3497 .map(Self::Attribute)
3498 .unwrap_or(Self::Unknown(node)),
3499 "binary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3500 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
3501 })
3502 .map(Self::BinaryExpression)
3503 .unwrap_or(Self::Unknown(node)),
3504 "block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3505 <Block as ::treesitter_types::FromNode>::from_node(node, src)
3506 })
3507 .map(Self::Block)
3508 .unwrap_or(Self::Unknown(node)),
3509 "bracket_index_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3510 <BracketIndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
3511 })
3512 .map(Self::BracketIndexExpression)
3513 .unwrap_or(Self::Unknown(node)),
3514 "chunk" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3515 <Chunk as ::treesitter_types::FromNode>::from_node(node, src)
3516 })
3517 .map(Self::Chunk)
3518 .unwrap_or(Self::Unknown(node)),
3519 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3520 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
3521 })
3522 .map(Self::Comment)
3523 .unwrap_or(Self::Unknown(node)),
3524 "do_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3525 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
3526 })
3527 .map(Self::DoStatement)
3528 .unwrap_or(Self::Unknown(node)),
3529 "dot_index_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3530 <DotIndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
3531 })
3532 .map(Self::DotIndexExpression)
3533 .unwrap_or(Self::Unknown(node)),
3534 "else_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3535 <ElseStatement as ::treesitter_types::FromNode>::from_node(node, src)
3536 })
3537 .map(Self::ElseStatement)
3538 .unwrap_or(Self::Unknown(node)),
3539 "elseif_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3540 <ElseifStatement as ::treesitter_types::FromNode>::from_node(node, src)
3541 })
3542 .map(Self::ElseifStatement)
3543 .unwrap_or(Self::Unknown(node)),
3544 "empty_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3545 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
3546 })
3547 .map(Self::EmptyStatement)
3548 .unwrap_or(Self::Unknown(node)),
3549 "expression_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3550 <ExpressionList as ::treesitter_types::FromNode>::from_node(node, src)
3551 })
3552 .map(Self::ExpressionList)
3553 .unwrap_or(Self::Unknown(node)),
3554 "field" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3555 <Field as ::treesitter_types::FromNode>::from_node(node, src)
3556 })
3557 .map(Self::Field)
3558 .unwrap_or(Self::Unknown(node)),
3559 "for_generic_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3560 <ForGenericClause as ::treesitter_types::FromNode>::from_node(node, src)
3561 })
3562 .map(Self::ForGenericClause)
3563 .unwrap_or(Self::Unknown(node)),
3564 "for_numeric_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3565 <ForNumericClause as ::treesitter_types::FromNode>::from_node(node, src)
3566 })
3567 .map(Self::ForNumericClause)
3568 .unwrap_or(Self::Unknown(node)),
3569 "for_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3570 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
3571 })
3572 .map(Self::ForStatement)
3573 .unwrap_or(Self::Unknown(node)),
3574 "function_call" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3575 <FunctionCall as ::treesitter_types::FromNode>::from_node(node, src)
3576 })
3577 .map(Self::FunctionCall)
3578 .unwrap_or(Self::Unknown(node)),
3579 "function_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3580 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
3581 })
3582 .map(Self::FunctionDeclaration)
3583 .unwrap_or(Self::Unknown(node)),
3584 "function_definition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3585 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
3586 })
3587 .map(Self::FunctionDefinition)
3588 .unwrap_or(Self::Unknown(node)),
3589 "goto_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3590 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
3591 })
3592 .map(Self::GotoStatement)
3593 .unwrap_or(Self::Unknown(node)),
3594 "if_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3595 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
3596 })
3597 .map(Self::IfStatement)
3598 .unwrap_or(Self::Unknown(node)),
3599 "implicit_variable_declaration" => {
3600 ::treesitter_types::runtime::maybe_grow_stack(|| {
3601 <ImplicitVariableDeclaration as ::treesitter_types::FromNode>::from_node(
3602 node, src,
3603 )
3604 })
3605 .map(Self::ImplicitVariableDeclaration)
3606 .unwrap_or(Self::Unknown(node))
3607 }
3608 "label_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3609 <LabelStatement as ::treesitter_types::FromNode>::from_node(node, src)
3610 })
3611 .map(Self::LabelStatement)
3612 .unwrap_or(Self::Unknown(node)),
3613 "method_index_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3614 <MethodIndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
3615 })
3616 .map(Self::MethodIndexExpression)
3617 .unwrap_or(Self::Unknown(node)),
3618 "parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3619 <Parameters as ::treesitter_types::FromNode>::from_node(node, src)
3620 })
3621 .map(Self::Parameters)
3622 .unwrap_or(Self::Unknown(node)),
3623 "parenthesized_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3624 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
3625 })
3626 .map(Self::ParenthesizedExpression)
3627 .unwrap_or(Self::Unknown(node)),
3628 "repeat_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3629 <RepeatStatement as ::treesitter_types::FromNode>::from_node(node, src)
3630 })
3631 .map(Self::RepeatStatement)
3632 .unwrap_or(Self::Unknown(node)),
3633 "return_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3634 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
3635 })
3636 .map(Self::ReturnStatement)
3637 .unwrap_or(Self::Unknown(node)),
3638 "string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3639 <String as ::treesitter_types::FromNode>::from_node(node, src)
3640 })
3641 .map(Self::String)
3642 .unwrap_or(Self::Unknown(node)),
3643 "string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3644 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
3645 })
3646 .map(Self::StringContent)
3647 .unwrap_or(Self::Unknown(node)),
3648 "table_constructor" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3649 <TableConstructor as ::treesitter_types::FromNode>::from_node(node, src)
3650 })
3651 .map(Self::TableConstructor)
3652 .unwrap_or(Self::Unknown(node)),
3653 "unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3654 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
3655 })
3656 .map(Self::UnaryExpression)
3657 .unwrap_or(Self::Unknown(node)),
3658 "variable_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3659 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
3660 })
3661 .map(Self::VariableDeclaration)
3662 .unwrap_or(Self::Unknown(node)),
3663 "variable_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3664 <VariableList as ::treesitter_types::FromNode>::from_node(node, src)
3665 })
3666 .map(Self::VariableList)
3667 .unwrap_or(Self::Unknown(node)),
3668 "while_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3669 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
3670 })
3671 .map(Self::WhileStatement)
3672 .unwrap_or(Self::Unknown(node)),
3673 "break_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3674 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
3675 })
3676 .map(Self::BreakStatement)
3677 .unwrap_or(Self::Unknown(node)),
3678 "comment_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3679 <CommentContent as ::treesitter_types::FromNode>::from_node(node, src)
3680 })
3681 .map(Self::CommentContent)
3682 .unwrap_or(Self::Unknown(node)),
3683 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3684 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
3685 })
3686 .map(Self::EscapeSequence)
3687 .unwrap_or(Self::Unknown(node)),
3688 "false" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3689 <False as ::treesitter_types::FromNode>::from_node(node, src)
3690 })
3691 .map(Self::False)
3692 .unwrap_or(Self::Unknown(node)),
3693 "hash_bang_line" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3694 <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)
3695 })
3696 .map(Self::HashBangLine)
3697 .unwrap_or(Self::Unknown(node)),
3698 "identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3699 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
3700 })
3701 .map(Self::Identifier)
3702 .unwrap_or(Self::Unknown(node)),
3703 "nil" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3704 <Nil as ::treesitter_types::FromNode>::from_node(node, src)
3705 })
3706 .map(Self::Nil)
3707 .unwrap_or(Self::Unknown(node)),
3708 "number" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3709 <Number as ::treesitter_types::FromNode>::from_node(node, src)
3710 })
3711 .map(Self::Number)
3712 .unwrap_or(Self::Unknown(node)),
3713 "true" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3714 <True as ::treesitter_types::FromNode>::from_node(node, src)
3715 })
3716 .map(Self::True)
3717 .unwrap_or(Self::Unknown(node)),
3718 "vararg_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
3719 <VarargExpression as ::treesitter_types::FromNode>::from_node(node, src)
3720 })
3721 .map(Self::VarargExpression)
3722 .unwrap_or(Self::Unknown(node)),
3723 _ => Self::Unknown(node),
3724 }
3725 }
3726}
3727impl ::treesitter_types::Spanned for AnyNode<'_> {
3728 fn span(&self) -> ::treesitter_types::Span {
3729 match self {
3730 Self::Declaration(inner) => inner.span(),
3731 Self::Expression(inner) => inner.span(),
3732 Self::Statement(inner) => inner.span(),
3733 Self::Variable(inner) => inner.span(),
3734 Self::Arguments(inner) => inner.span(),
3735 Self::AssignmentStatement(inner) => inner.span(),
3736 Self::Attribute(inner) => inner.span(),
3737 Self::BinaryExpression(inner) => inner.span(),
3738 Self::Block(inner) => inner.span(),
3739 Self::BracketIndexExpression(inner) => inner.span(),
3740 Self::Chunk(inner) => inner.span(),
3741 Self::Comment(inner) => inner.span(),
3742 Self::DoStatement(inner) => inner.span(),
3743 Self::DotIndexExpression(inner) => inner.span(),
3744 Self::ElseStatement(inner) => inner.span(),
3745 Self::ElseifStatement(inner) => inner.span(),
3746 Self::EmptyStatement(inner) => inner.span(),
3747 Self::ExpressionList(inner) => inner.span(),
3748 Self::Field(inner) => inner.span(),
3749 Self::ForGenericClause(inner) => inner.span(),
3750 Self::ForNumericClause(inner) => inner.span(),
3751 Self::ForStatement(inner) => inner.span(),
3752 Self::FunctionCall(inner) => inner.span(),
3753 Self::FunctionDeclaration(inner) => inner.span(),
3754 Self::FunctionDefinition(inner) => inner.span(),
3755 Self::GotoStatement(inner) => inner.span(),
3756 Self::IfStatement(inner) => inner.span(),
3757 Self::ImplicitVariableDeclaration(inner) => inner.span(),
3758 Self::LabelStatement(inner) => inner.span(),
3759 Self::MethodIndexExpression(inner) => inner.span(),
3760 Self::Parameters(inner) => inner.span(),
3761 Self::ParenthesizedExpression(inner) => inner.span(),
3762 Self::RepeatStatement(inner) => inner.span(),
3763 Self::ReturnStatement(inner) => inner.span(),
3764 Self::String(inner) => inner.span(),
3765 Self::StringContent(inner) => inner.span(),
3766 Self::TableConstructor(inner) => inner.span(),
3767 Self::UnaryExpression(inner) => inner.span(),
3768 Self::VariableDeclaration(inner) => inner.span(),
3769 Self::VariableList(inner) => inner.span(),
3770 Self::WhileStatement(inner) => inner.span(),
3771 Self::BreakStatement(inner) => inner.span(),
3772 Self::CommentContent(inner) => inner.span(),
3773 Self::EscapeSequence(inner) => inner.span(),
3774 Self::False(inner) => inner.span(),
3775 Self::HashBangLine(inner) => inner.span(),
3776 Self::Identifier(inner) => inner.span(),
3777 Self::Nil(inner) => inner.span(),
3778 Self::Number(inner) => inner.span(),
3779 Self::True(inner) => inner.span(),
3780 Self::VarargExpression(inner) => inner.span(),
3781 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
3782 }
3783 }
3784}