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