Skip to main content

treesitter_types_ruby/
generated.rs

1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Arg<'tree> {
3    Primary(::std::boxed::Box<Primary<'tree>>),
4    Assignment(::std::boxed::Box<Assignment<'tree>>),
5    Binary(::std::boxed::Box<Binary<'tree>>),
6    Conditional(::std::boxed::Box<Conditional<'tree>>),
7    OperatorAssignment(::std::boxed::Box<OperatorAssignment<'tree>>),
8    Range(::std::boxed::Box<Range<'tree>>),
9    Unary(::std::boxed::Box<Unary<'tree>>),
10}
11impl<'tree> ::treesitter_types::FromNode<'tree> for Arg<'tree> {
12    #[allow(clippy::collapsible_else_if)]
13    fn from_node(
14        node: ::treesitter_types::tree_sitter::Node<'tree>,
15        src: &'tree [u8],
16    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17        match node.kind() {
18            "assignment" => Ok(Self::Assignment(::std::boxed::Box::new(
19                ::treesitter_types::runtime::maybe_grow_stack(|| {
20                    <Assignment as ::treesitter_types::FromNode>::from_node(node, src)
21                })?,
22            ))),
23            "binary" => Ok(Self::Binary(::std::boxed::Box::new(
24                ::treesitter_types::runtime::maybe_grow_stack(|| {
25                    <Binary as ::treesitter_types::FromNode>::from_node(node, src)
26                })?,
27            ))),
28            "conditional" => Ok(Self::Conditional(::std::boxed::Box::new(
29                ::treesitter_types::runtime::maybe_grow_stack(|| {
30                    <Conditional as ::treesitter_types::FromNode>::from_node(node, src)
31                })?,
32            ))),
33            "operator_assignment" => Ok(Self::OperatorAssignment(::std::boxed::Box::new(
34                ::treesitter_types::runtime::maybe_grow_stack(|| {
35                    <OperatorAssignment as ::treesitter_types::FromNode>::from_node(node, src)
36                })?,
37            ))),
38            "range" => Ok(Self::Range(::std::boxed::Box::new(
39                ::treesitter_types::runtime::maybe_grow_stack(|| {
40                    <Range as ::treesitter_types::FromNode>::from_node(node, src)
41                })?,
42            ))),
43            "unary" => Ok(Self::Unary(::std::boxed::Box::new(
44                ::treesitter_types::runtime::maybe_grow_stack(|| {
45                    <Unary as ::treesitter_types::FromNode>::from_node(node, src)
46                })?,
47            ))),
48            _other => {
49                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
50                    <Primary as ::treesitter_types::FromNode>::from_node(node, src)
51                }) {
52                    Ok(Self::Primary(::std::boxed::Box::new(v)))
53                } else {
54                    Err(::treesitter_types::ParseError::unexpected_kind(
55                        _other, node,
56                    ))
57                }
58            }
59        }
60    }
61}
62impl ::treesitter_types::Spanned for Arg<'_> {
63    fn span(&self) -> ::treesitter_types::Span {
64        match self {
65            Self::Primary(inner) => inner.span(),
66            Self::Assignment(inner) => inner.span(),
67            Self::Binary(inner) => inner.span(),
68            Self::Conditional(inner) => inner.span(),
69            Self::OperatorAssignment(inner) => inner.span(),
70            Self::Range(inner) => inner.span(),
71            Self::Unary(inner) => inner.span(),
72        }
73    }
74}
75#[derive(Debug, Clone, PartialEq, Eq)]
76pub enum CallOperator {
77    AmpDot(::treesitter_types::Span),
78    Dot(::treesitter_types::Span),
79    DoubleColon(::treesitter_types::Span),
80}
81impl<'tree> ::treesitter_types::FromNode<'tree> for CallOperator {
82    #[allow(clippy::collapsible_else_if)]
83    fn from_node(
84        node: ::treesitter_types::tree_sitter::Node<'tree>,
85        _src: &'tree [u8],
86    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
87        match node.kind() {
88            "&." => Ok(Self::AmpDot(::treesitter_types::Span::from(node))),
89            "." => Ok(Self::Dot(::treesitter_types::Span::from(node))),
90            "::" => Ok(Self::DoubleColon(::treesitter_types::Span::from(node))),
91            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
92        }
93    }
94}
95impl ::treesitter_types::Spanned for CallOperator {
96    fn span(&self) -> ::treesitter_types::Span {
97        match self {
98            Self::AmpDot(span) => *span,
99            Self::Dot(span) => *span,
100            Self::DoubleColon(span) => *span,
101        }
102    }
103}
104#[derive(Debug, Clone, PartialEq, Eq)]
105pub enum Expression<'tree> {
106    Arg(::std::boxed::Box<Arg<'tree>>),
107    Assignment(::std::boxed::Box<Assignment<'tree>>),
108    Binary(::std::boxed::Box<Binary<'tree>>),
109    Break(::std::boxed::Box<Break<'tree>>),
110    Call(::std::boxed::Box<Call<'tree>>),
111    MatchPattern(::std::boxed::Box<MatchPattern<'tree>>),
112    Next(::std::boxed::Box<Next<'tree>>),
113    OperatorAssignment(::std::boxed::Box<OperatorAssignment<'tree>>),
114    Return(::std::boxed::Box<Return<'tree>>),
115    TestPattern(::std::boxed::Box<TestPattern<'tree>>),
116    Unary(::std::boxed::Box<Unary<'tree>>),
117    Yield(::std::boxed::Box<Yield<'tree>>),
118}
119impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
120    #[allow(clippy::collapsible_else_if)]
121    fn from_node(
122        node: ::treesitter_types::tree_sitter::Node<'tree>,
123        src: &'tree [u8],
124    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
125        match node.kind() {
126            "assignment" => Ok(Self::Assignment(::std::boxed::Box::new(
127                ::treesitter_types::runtime::maybe_grow_stack(|| {
128                    <Assignment as ::treesitter_types::FromNode>::from_node(node, src)
129                })?,
130            ))),
131            "binary" => Ok(Self::Binary(::std::boxed::Box::new(
132                ::treesitter_types::runtime::maybe_grow_stack(|| {
133                    <Binary as ::treesitter_types::FromNode>::from_node(node, src)
134                })?,
135            ))),
136            "break" => Ok(Self::Break(::std::boxed::Box::new(
137                ::treesitter_types::runtime::maybe_grow_stack(|| {
138                    <Break as ::treesitter_types::FromNode>::from_node(node, src)
139                })?,
140            ))),
141            "call" => Ok(Self::Call(::std::boxed::Box::new(
142                ::treesitter_types::runtime::maybe_grow_stack(|| {
143                    <Call as ::treesitter_types::FromNode>::from_node(node, src)
144                })?,
145            ))),
146            "match_pattern" => Ok(Self::MatchPattern(::std::boxed::Box::new(
147                ::treesitter_types::runtime::maybe_grow_stack(|| {
148                    <MatchPattern as ::treesitter_types::FromNode>::from_node(node, src)
149                })?,
150            ))),
151            "next" => Ok(Self::Next(::std::boxed::Box::new(
152                ::treesitter_types::runtime::maybe_grow_stack(|| {
153                    <Next as ::treesitter_types::FromNode>::from_node(node, src)
154                })?,
155            ))),
156            "operator_assignment" => Ok(Self::OperatorAssignment(::std::boxed::Box::new(
157                ::treesitter_types::runtime::maybe_grow_stack(|| {
158                    <OperatorAssignment as ::treesitter_types::FromNode>::from_node(node, src)
159                })?,
160            ))),
161            "return" => Ok(Self::Return(::std::boxed::Box::new(
162                ::treesitter_types::runtime::maybe_grow_stack(|| {
163                    <Return as ::treesitter_types::FromNode>::from_node(node, src)
164                })?,
165            ))),
166            "test_pattern" => Ok(Self::TestPattern(::std::boxed::Box::new(
167                ::treesitter_types::runtime::maybe_grow_stack(|| {
168                    <TestPattern as ::treesitter_types::FromNode>::from_node(node, src)
169                })?,
170            ))),
171            "unary" => Ok(Self::Unary(::std::boxed::Box::new(
172                ::treesitter_types::runtime::maybe_grow_stack(|| {
173                    <Unary as ::treesitter_types::FromNode>::from_node(node, src)
174                })?,
175            ))),
176            "yield" => Ok(Self::Yield(::std::boxed::Box::new(
177                ::treesitter_types::runtime::maybe_grow_stack(|| {
178                    <Yield as ::treesitter_types::FromNode>::from_node(node, src)
179                })?,
180            ))),
181            _other => {
182                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
183                    <Arg as ::treesitter_types::FromNode>::from_node(node, src)
184                }) {
185                    Ok(Self::Arg(::std::boxed::Box::new(v)))
186                } else {
187                    Err(::treesitter_types::ParseError::unexpected_kind(
188                        _other, node,
189                    ))
190                }
191            }
192        }
193    }
194}
195impl ::treesitter_types::Spanned for Expression<'_> {
196    fn span(&self) -> ::treesitter_types::Span {
197        match self {
198            Self::Arg(inner) => inner.span(),
199            Self::Assignment(inner) => inner.span(),
200            Self::Binary(inner) => inner.span(),
201            Self::Break(inner) => inner.span(),
202            Self::Call(inner) => inner.span(),
203            Self::MatchPattern(inner) => inner.span(),
204            Self::Next(inner) => inner.span(),
205            Self::OperatorAssignment(inner) => inner.span(),
206            Self::Return(inner) => inner.span(),
207            Self::TestPattern(inner) => inner.span(),
208            Self::Unary(inner) => inner.span(),
209            Self::Yield(inner) => inner.span(),
210        }
211    }
212}
213#[derive(Debug, Clone, PartialEq, Eq)]
214pub enum Lhs<'tree> {
215    Variable(::std::boxed::Box<Variable<'tree>>),
216    Call(::std::boxed::Box<Call<'tree>>),
217    ElementReference(::std::boxed::Box<ElementReference<'tree>>),
218    False(::std::boxed::Box<False<'tree>>),
219    Nil(::std::boxed::Box<Nil<'tree>>),
220    ScopeResolution(::std::boxed::Box<ScopeResolution<'tree>>),
221    True(::std::boxed::Box<True<'tree>>),
222}
223impl<'tree> ::treesitter_types::FromNode<'tree> for Lhs<'tree> {
224    #[allow(clippy::collapsible_else_if)]
225    fn from_node(
226        node: ::treesitter_types::tree_sitter::Node<'tree>,
227        src: &'tree [u8],
228    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
229        match node.kind() {
230            "call" => Ok(Self::Call(::std::boxed::Box::new(
231                ::treesitter_types::runtime::maybe_grow_stack(|| {
232                    <Call as ::treesitter_types::FromNode>::from_node(node, src)
233                })?,
234            ))),
235            "element_reference" => Ok(Self::ElementReference(::std::boxed::Box::new(
236                ::treesitter_types::runtime::maybe_grow_stack(|| {
237                    <ElementReference as ::treesitter_types::FromNode>::from_node(node, src)
238                })?,
239            ))),
240            "false" => Ok(Self::False(::std::boxed::Box::new(
241                ::treesitter_types::runtime::maybe_grow_stack(|| {
242                    <False as ::treesitter_types::FromNode>::from_node(node, src)
243                })?,
244            ))),
245            "nil" => Ok(Self::Nil(::std::boxed::Box::new(
246                ::treesitter_types::runtime::maybe_grow_stack(|| {
247                    <Nil as ::treesitter_types::FromNode>::from_node(node, src)
248                })?,
249            ))),
250            "scope_resolution" => Ok(Self::ScopeResolution(::std::boxed::Box::new(
251                ::treesitter_types::runtime::maybe_grow_stack(|| {
252                    <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)
253                })?,
254            ))),
255            "true" => Ok(Self::True(::std::boxed::Box::new(
256                ::treesitter_types::runtime::maybe_grow_stack(|| {
257                    <True as ::treesitter_types::FromNode>::from_node(node, src)
258                })?,
259            ))),
260            _other => {
261                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
262                    <Variable as ::treesitter_types::FromNode>::from_node(node, src)
263                }) {
264                    Ok(Self::Variable(::std::boxed::Box::new(v)))
265                } else {
266                    Err(::treesitter_types::ParseError::unexpected_kind(
267                        _other, node,
268                    ))
269                }
270            }
271        }
272    }
273}
274impl ::treesitter_types::Spanned for Lhs<'_> {
275    fn span(&self) -> ::treesitter_types::Span {
276        match self {
277            Self::Variable(inner) => inner.span(),
278            Self::Call(inner) => inner.span(),
279            Self::ElementReference(inner) => inner.span(),
280            Self::False(inner) => inner.span(),
281            Self::Nil(inner) => inner.span(),
282            Self::ScopeResolution(inner) => inner.span(),
283            Self::True(inner) => inner.span(),
284        }
285    }
286}
287#[derive(Debug, Clone, PartialEq, Eq)]
288pub enum MethodName<'tree> {
289    NonlocalVariable(::std::boxed::Box<NonlocalVariable<'tree>>),
290    Constant(::std::boxed::Box<Constant<'tree>>),
291    DelimitedSymbol(::std::boxed::Box<DelimitedSymbol<'tree>>),
292    Identifier(::std::boxed::Box<Identifier<'tree>>),
293    Operator(::std::boxed::Box<Operator<'tree>>),
294    Setter(::std::boxed::Box<Setter<'tree>>),
295    SimpleSymbol(::std::boxed::Box<SimpleSymbol<'tree>>),
296}
297impl<'tree> ::treesitter_types::FromNode<'tree> for MethodName<'tree> {
298    #[allow(clippy::collapsible_else_if)]
299    fn from_node(
300        node: ::treesitter_types::tree_sitter::Node<'tree>,
301        src: &'tree [u8],
302    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
303        match node.kind() {
304            "constant" => Ok(Self::Constant(::std::boxed::Box::new(
305                ::treesitter_types::runtime::maybe_grow_stack(|| {
306                    <Constant as ::treesitter_types::FromNode>::from_node(node, src)
307                })?,
308            ))),
309            "delimited_symbol" => Ok(Self::DelimitedSymbol(::std::boxed::Box::new(
310                ::treesitter_types::runtime::maybe_grow_stack(|| {
311                    <DelimitedSymbol as ::treesitter_types::FromNode>::from_node(node, src)
312                })?,
313            ))),
314            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
315                ::treesitter_types::runtime::maybe_grow_stack(|| {
316                    <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
317                })?,
318            ))),
319            "operator" => Ok(Self::Operator(::std::boxed::Box::new(
320                ::treesitter_types::runtime::maybe_grow_stack(|| {
321                    <Operator as ::treesitter_types::FromNode>::from_node(node, src)
322                })?,
323            ))),
324            "setter" => Ok(Self::Setter(::std::boxed::Box::new(
325                ::treesitter_types::runtime::maybe_grow_stack(|| {
326                    <Setter as ::treesitter_types::FromNode>::from_node(node, src)
327                })?,
328            ))),
329            "simple_symbol" => Ok(Self::SimpleSymbol(::std::boxed::Box::new(
330                ::treesitter_types::runtime::maybe_grow_stack(|| {
331                    <SimpleSymbol as ::treesitter_types::FromNode>::from_node(node, src)
332                })?,
333            ))),
334            _other => {
335                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
336                    <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
337                }) {
338                    Ok(Self::NonlocalVariable(::std::boxed::Box::new(v)))
339                } else {
340                    Err(::treesitter_types::ParseError::unexpected_kind(
341                        _other, node,
342                    ))
343                }
344            }
345        }
346    }
347}
348impl ::treesitter_types::Spanned for MethodName<'_> {
349    fn span(&self) -> ::treesitter_types::Span {
350        match self {
351            Self::NonlocalVariable(inner) => inner.span(),
352            Self::Constant(inner) => inner.span(),
353            Self::DelimitedSymbol(inner) => inner.span(),
354            Self::Identifier(inner) => inner.span(),
355            Self::Operator(inner) => inner.span(),
356            Self::Setter(inner) => inner.span(),
357            Self::SimpleSymbol(inner) => inner.span(),
358        }
359    }
360}
361#[derive(Debug, Clone, PartialEq, Eq)]
362pub enum NonlocalVariable<'tree> {
363    ClassVariable(::std::boxed::Box<ClassVariable<'tree>>),
364    GlobalVariable(::std::boxed::Box<GlobalVariable<'tree>>),
365    InstanceVariable(::std::boxed::Box<InstanceVariable<'tree>>),
366}
367impl<'tree> ::treesitter_types::FromNode<'tree> for NonlocalVariable<'tree> {
368    #[allow(clippy::collapsible_else_if)]
369    fn from_node(
370        node: ::treesitter_types::tree_sitter::Node<'tree>,
371        src: &'tree [u8],
372    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
373        match node.kind() {
374            "class_variable" => Ok(Self::ClassVariable(::std::boxed::Box::new(
375                ::treesitter_types::runtime::maybe_grow_stack(|| {
376                    <ClassVariable as ::treesitter_types::FromNode>::from_node(node, src)
377                })?,
378            ))),
379            "global_variable" => Ok(Self::GlobalVariable(::std::boxed::Box::new(
380                ::treesitter_types::runtime::maybe_grow_stack(|| {
381                    <GlobalVariable as ::treesitter_types::FromNode>::from_node(node, src)
382                })?,
383            ))),
384            "instance_variable" => Ok(Self::InstanceVariable(::std::boxed::Box::new(
385                ::treesitter_types::runtime::maybe_grow_stack(|| {
386                    <InstanceVariable as ::treesitter_types::FromNode>::from_node(node, src)
387                })?,
388            ))),
389            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
390        }
391    }
392}
393impl ::treesitter_types::Spanned for NonlocalVariable<'_> {
394    fn span(&self) -> ::treesitter_types::Span {
395        match self {
396            Self::ClassVariable(inner) => inner.span(),
397            Self::GlobalVariable(inner) => inner.span(),
398            Self::InstanceVariable(inner) => inner.span(),
399        }
400    }
401}
402#[derive(Debug, Clone, PartialEq, Eq)]
403pub enum PatternConstant<'tree> {
404    Constant(::std::boxed::Box<Constant<'tree>>),
405    ScopeResolution(::std::boxed::Box<ScopeResolution<'tree>>),
406}
407impl<'tree> ::treesitter_types::FromNode<'tree> for PatternConstant<'tree> {
408    #[allow(clippy::collapsible_else_if)]
409    fn from_node(
410        node: ::treesitter_types::tree_sitter::Node<'tree>,
411        src: &'tree [u8],
412    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
413        match node.kind() {
414            "constant" => Ok(Self::Constant(::std::boxed::Box::new(
415                ::treesitter_types::runtime::maybe_grow_stack(|| {
416                    <Constant as ::treesitter_types::FromNode>::from_node(node, src)
417                })?,
418            ))),
419            "scope_resolution" => Ok(Self::ScopeResolution(::std::boxed::Box::new(
420                ::treesitter_types::runtime::maybe_grow_stack(|| {
421                    <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)
422                })?,
423            ))),
424            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
425        }
426    }
427}
428impl ::treesitter_types::Spanned for PatternConstant<'_> {
429    fn span(&self) -> ::treesitter_types::Span {
430        match self {
431            Self::Constant(inner) => inner.span(),
432            Self::ScopeResolution(inner) => inner.span(),
433        }
434    }
435}
436#[derive(Debug, Clone, PartialEq, Eq)]
437pub enum PatternExpr<'tree> {
438    PatternExprBasic(::std::boxed::Box<PatternExprBasic<'tree>>),
439    AlternativePattern(::std::boxed::Box<AlternativePattern<'tree>>),
440    AsPattern(::std::boxed::Box<AsPattern<'tree>>),
441}
442impl<'tree> ::treesitter_types::FromNode<'tree> for PatternExpr<'tree> {
443    #[allow(clippy::collapsible_else_if)]
444    fn from_node(
445        node: ::treesitter_types::tree_sitter::Node<'tree>,
446        src: &'tree [u8],
447    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
448        match node.kind() {
449            "alternative_pattern" => Ok(Self::AlternativePattern(::std::boxed::Box::new(
450                ::treesitter_types::runtime::maybe_grow_stack(|| {
451                    <AlternativePattern as ::treesitter_types::FromNode>::from_node(node, src)
452                })?,
453            ))),
454            "as_pattern" => Ok(Self::AsPattern(::std::boxed::Box::new(
455                ::treesitter_types::runtime::maybe_grow_stack(|| {
456                    <AsPattern as ::treesitter_types::FromNode>::from_node(node, src)
457                })?,
458            ))),
459            _other => {
460                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
461                    <PatternExprBasic as ::treesitter_types::FromNode>::from_node(node, src)
462                }) {
463                    Ok(Self::PatternExprBasic(::std::boxed::Box::new(v)))
464                } else {
465                    Err(::treesitter_types::ParseError::unexpected_kind(
466                        _other, node,
467                    ))
468                }
469            }
470        }
471    }
472}
473impl ::treesitter_types::Spanned for PatternExpr<'_> {
474    fn span(&self) -> ::treesitter_types::Span {
475        match self {
476            Self::PatternExprBasic(inner) => inner.span(),
477            Self::AlternativePattern(inner) => inner.span(),
478            Self::AsPattern(inner) => inner.span(),
479        }
480    }
481}
482#[derive(Debug, Clone, PartialEq, Eq)]
483pub enum PatternExprBasic<'tree> {
484    PatternConstant(::std::boxed::Box<PatternConstant<'tree>>),
485    PatternPrimitive(::std::boxed::Box<PatternPrimitive<'tree>>),
486    ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
487    ExpressionReferencePattern(::std::boxed::Box<ExpressionReferencePattern<'tree>>),
488    FindPattern(::std::boxed::Box<FindPattern<'tree>>),
489    HashPattern(::std::boxed::Box<HashPattern<'tree>>),
490    Identifier(::std::boxed::Box<Identifier<'tree>>),
491    ParenthesizedPattern(::std::boxed::Box<ParenthesizedPattern<'tree>>),
492    Range(::std::boxed::Box<Range<'tree>>),
493    VariableReferencePattern(::std::boxed::Box<VariableReferencePattern<'tree>>),
494}
495impl<'tree> ::treesitter_types::FromNode<'tree> for PatternExprBasic<'tree> {
496    #[allow(clippy::collapsible_else_if)]
497    fn from_node(
498        node: ::treesitter_types::tree_sitter::Node<'tree>,
499        src: &'tree [u8],
500    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
501        match node.kind() {
502            "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
503                ::treesitter_types::runtime::maybe_grow_stack(|| {
504                    <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
505                })?,
506            ))),
507            "expression_reference_pattern" => Ok(Self::ExpressionReferencePattern(
508                ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
509                    <ExpressionReferencePattern as ::treesitter_types::FromNode>::from_node(
510                        node, src,
511                    )
512                })?),
513            )),
514            "find_pattern" => Ok(Self::FindPattern(::std::boxed::Box::new(
515                ::treesitter_types::runtime::maybe_grow_stack(|| {
516                    <FindPattern as ::treesitter_types::FromNode>::from_node(node, src)
517                })?,
518            ))),
519            "hash_pattern" => Ok(Self::HashPattern(::std::boxed::Box::new(
520                ::treesitter_types::runtime::maybe_grow_stack(|| {
521                    <HashPattern as ::treesitter_types::FromNode>::from_node(node, src)
522                })?,
523            ))),
524            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
525                ::treesitter_types::runtime::maybe_grow_stack(|| {
526                    <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
527                })?,
528            ))),
529            "parenthesized_pattern" => Ok(Self::ParenthesizedPattern(::std::boxed::Box::new(
530                ::treesitter_types::runtime::maybe_grow_stack(|| {
531                    <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)
532                })?,
533            ))),
534            "range" => Ok(Self::Range(::std::boxed::Box::new(
535                ::treesitter_types::runtime::maybe_grow_stack(|| {
536                    <Range as ::treesitter_types::FromNode>::from_node(node, src)
537                })?,
538            ))),
539            "variable_reference_pattern" => Ok(Self::VariableReferencePattern(
540                ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
541                    <VariableReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)
542                })?),
543            )),
544            _other => {
545                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
546                    <PatternConstant as ::treesitter_types::FromNode>::from_node(node, src)
547                }) {
548                    Ok(Self::PatternConstant(::std::boxed::Box::new(v)))
549                } else {
550                    if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
551                        <PatternPrimitive as ::treesitter_types::FromNode>::from_node(node, src)
552                    }) {
553                        Ok(Self::PatternPrimitive(::std::boxed::Box::new(v)))
554                    } else {
555                        Err(::treesitter_types::ParseError::unexpected_kind(
556                            _other, node,
557                        ))
558                    }
559                }
560            }
561        }
562    }
563}
564impl ::treesitter_types::Spanned for PatternExprBasic<'_> {
565    fn span(&self) -> ::treesitter_types::Span {
566        match self {
567            Self::PatternConstant(inner) => inner.span(),
568            Self::PatternPrimitive(inner) => inner.span(),
569            Self::ArrayPattern(inner) => inner.span(),
570            Self::ExpressionReferencePattern(inner) => inner.span(),
571            Self::FindPattern(inner) => inner.span(),
572            Self::HashPattern(inner) => inner.span(),
573            Self::Identifier(inner) => inner.span(),
574            Self::ParenthesizedPattern(inner) => inner.span(),
575            Self::Range(inner) => inner.span(),
576            Self::VariableReferencePattern(inner) => inner.span(),
577        }
578    }
579}
580#[derive(Debug, Clone, PartialEq, Eq)]
581pub enum PatternPrimitive<'tree> {
582    SimpleNumeric(::std::boxed::Box<SimpleNumeric<'tree>>),
583    DelimitedSymbol(::std::boxed::Box<DelimitedSymbol<'tree>>),
584    Encoding(::std::boxed::Box<Encoding<'tree>>),
585    False(::std::boxed::Box<False<'tree>>),
586    File(::std::boxed::Box<File<'tree>>),
587    HeredocBeginning(::std::boxed::Box<HeredocBeginning<'tree>>),
588    Lambda(::std::boxed::Box<Lambda<'tree>>),
589    Line(::std::boxed::Box<Line<'tree>>),
590    Nil(::std::boxed::Box<Nil<'tree>>),
591    Regex(::std::boxed::Box<Regex<'tree>>),
592    SelfType(::std::boxed::Box<SelfType<'tree>>),
593    SimpleSymbol(::std::boxed::Box<SimpleSymbol<'tree>>),
594    String(::std::boxed::Box<String<'tree>>),
595    StringArray(::std::boxed::Box<StringArray<'tree>>),
596    Subshell(::std::boxed::Box<Subshell<'tree>>),
597    SymbolArray(::std::boxed::Box<SymbolArray<'tree>>),
598    True(::std::boxed::Box<True<'tree>>),
599    Unary(::std::boxed::Box<Unary<'tree>>),
600}
601impl<'tree> ::treesitter_types::FromNode<'tree> for PatternPrimitive<'tree> {
602    #[allow(clippy::collapsible_else_if)]
603    fn from_node(
604        node: ::treesitter_types::tree_sitter::Node<'tree>,
605        src: &'tree [u8],
606    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
607        match node.kind() {
608            "delimited_symbol" => Ok(Self::DelimitedSymbol(::std::boxed::Box::new(
609                ::treesitter_types::runtime::maybe_grow_stack(|| {
610                    <DelimitedSymbol as ::treesitter_types::FromNode>::from_node(node, src)
611                })?,
612            ))),
613            "encoding" => Ok(Self::Encoding(::std::boxed::Box::new(
614                ::treesitter_types::runtime::maybe_grow_stack(|| {
615                    <Encoding as ::treesitter_types::FromNode>::from_node(node, src)
616                })?,
617            ))),
618            "false" => Ok(Self::False(::std::boxed::Box::new(
619                ::treesitter_types::runtime::maybe_grow_stack(|| {
620                    <False as ::treesitter_types::FromNode>::from_node(node, src)
621                })?,
622            ))),
623            "file" => Ok(Self::File(::std::boxed::Box::new(
624                ::treesitter_types::runtime::maybe_grow_stack(|| {
625                    <File as ::treesitter_types::FromNode>::from_node(node, src)
626                })?,
627            ))),
628            "heredoc_beginning" => Ok(Self::HeredocBeginning(::std::boxed::Box::new(
629                ::treesitter_types::runtime::maybe_grow_stack(|| {
630                    <HeredocBeginning as ::treesitter_types::FromNode>::from_node(node, src)
631                })?,
632            ))),
633            "lambda" => Ok(Self::Lambda(::std::boxed::Box::new(
634                ::treesitter_types::runtime::maybe_grow_stack(|| {
635                    <Lambda as ::treesitter_types::FromNode>::from_node(node, src)
636                })?,
637            ))),
638            "line" => Ok(Self::Line(::std::boxed::Box::new(
639                ::treesitter_types::runtime::maybe_grow_stack(|| {
640                    <Line as ::treesitter_types::FromNode>::from_node(node, src)
641                })?,
642            ))),
643            "nil" => Ok(Self::Nil(::std::boxed::Box::new(
644                ::treesitter_types::runtime::maybe_grow_stack(|| {
645                    <Nil as ::treesitter_types::FromNode>::from_node(node, src)
646                })?,
647            ))),
648            "regex" => Ok(Self::Regex(::std::boxed::Box::new(
649                ::treesitter_types::runtime::maybe_grow_stack(|| {
650                    <Regex as ::treesitter_types::FromNode>::from_node(node, src)
651                })?,
652            ))),
653            "self" => Ok(Self::SelfType(::std::boxed::Box::new(
654                ::treesitter_types::runtime::maybe_grow_stack(|| {
655                    <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
656                })?,
657            ))),
658            "simple_symbol" => Ok(Self::SimpleSymbol(::std::boxed::Box::new(
659                ::treesitter_types::runtime::maybe_grow_stack(|| {
660                    <SimpleSymbol as ::treesitter_types::FromNode>::from_node(node, src)
661                })?,
662            ))),
663            "string" => Ok(Self::String(::std::boxed::Box::new(
664                ::treesitter_types::runtime::maybe_grow_stack(|| {
665                    <String as ::treesitter_types::FromNode>::from_node(node, src)
666                })?,
667            ))),
668            "string_array" => Ok(Self::StringArray(::std::boxed::Box::new(
669                ::treesitter_types::runtime::maybe_grow_stack(|| {
670                    <StringArray as ::treesitter_types::FromNode>::from_node(node, src)
671                })?,
672            ))),
673            "subshell" => Ok(Self::Subshell(::std::boxed::Box::new(
674                ::treesitter_types::runtime::maybe_grow_stack(|| {
675                    <Subshell as ::treesitter_types::FromNode>::from_node(node, src)
676                })?,
677            ))),
678            "symbol_array" => Ok(Self::SymbolArray(::std::boxed::Box::new(
679                ::treesitter_types::runtime::maybe_grow_stack(|| {
680                    <SymbolArray as ::treesitter_types::FromNode>::from_node(node, src)
681                })?,
682            ))),
683            "true" => Ok(Self::True(::std::boxed::Box::new(
684                ::treesitter_types::runtime::maybe_grow_stack(|| {
685                    <True as ::treesitter_types::FromNode>::from_node(node, src)
686                })?,
687            ))),
688            "unary" => Ok(Self::Unary(::std::boxed::Box::new(
689                ::treesitter_types::runtime::maybe_grow_stack(|| {
690                    <Unary as ::treesitter_types::FromNode>::from_node(node, src)
691                })?,
692            ))),
693            _other => {
694                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
695                    <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src)
696                }) {
697                    Ok(Self::SimpleNumeric(::std::boxed::Box::new(v)))
698                } else {
699                    Err(::treesitter_types::ParseError::unexpected_kind(
700                        _other, node,
701                    ))
702                }
703            }
704        }
705    }
706}
707impl ::treesitter_types::Spanned for PatternPrimitive<'_> {
708    fn span(&self) -> ::treesitter_types::Span {
709        match self {
710            Self::SimpleNumeric(inner) => inner.span(),
711            Self::DelimitedSymbol(inner) => inner.span(),
712            Self::Encoding(inner) => inner.span(),
713            Self::False(inner) => inner.span(),
714            Self::File(inner) => inner.span(),
715            Self::HeredocBeginning(inner) => inner.span(),
716            Self::Lambda(inner) => inner.span(),
717            Self::Line(inner) => inner.span(),
718            Self::Nil(inner) => inner.span(),
719            Self::Regex(inner) => inner.span(),
720            Self::SelfType(inner) => inner.span(),
721            Self::SimpleSymbol(inner) => inner.span(),
722            Self::String(inner) => inner.span(),
723            Self::StringArray(inner) => inner.span(),
724            Self::Subshell(inner) => inner.span(),
725            Self::SymbolArray(inner) => inner.span(),
726            Self::True(inner) => inner.span(),
727            Self::Unary(inner) => inner.span(),
728        }
729    }
730}
731#[derive(Debug, Clone, PartialEq, Eq)]
732pub enum PatternTopExprBody<'tree> {
733    PatternExpr(::std::boxed::Box<PatternExpr<'tree>>),
734    ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
735    FindPattern(::std::boxed::Box<FindPattern<'tree>>),
736    HashPattern(::std::boxed::Box<HashPattern<'tree>>),
737}
738impl<'tree> ::treesitter_types::FromNode<'tree> for PatternTopExprBody<'tree> {
739    #[allow(clippy::collapsible_else_if)]
740    fn from_node(
741        node: ::treesitter_types::tree_sitter::Node<'tree>,
742        src: &'tree [u8],
743    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
744        match node.kind() {
745            "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
746                ::treesitter_types::runtime::maybe_grow_stack(|| {
747                    <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
748                })?,
749            ))),
750            "find_pattern" => Ok(Self::FindPattern(::std::boxed::Box::new(
751                ::treesitter_types::runtime::maybe_grow_stack(|| {
752                    <FindPattern as ::treesitter_types::FromNode>::from_node(node, src)
753                })?,
754            ))),
755            "hash_pattern" => Ok(Self::HashPattern(::std::boxed::Box::new(
756                ::treesitter_types::runtime::maybe_grow_stack(|| {
757                    <HashPattern as ::treesitter_types::FromNode>::from_node(node, src)
758                })?,
759            ))),
760            _other => {
761                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
762                    <PatternExpr as ::treesitter_types::FromNode>::from_node(node, src)
763                }) {
764                    Ok(Self::PatternExpr(::std::boxed::Box::new(v)))
765                } else {
766                    Err(::treesitter_types::ParseError::unexpected_kind(
767                        _other, node,
768                    ))
769                }
770            }
771        }
772    }
773}
774impl ::treesitter_types::Spanned for PatternTopExprBody<'_> {
775    fn span(&self) -> ::treesitter_types::Span {
776        match self {
777            Self::PatternExpr(inner) => inner.span(),
778            Self::ArrayPattern(inner) => inner.span(),
779            Self::FindPattern(inner) => inner.span(),
780            Self::HashPattern(inner) => inner.span(),
781        }
782    }
783}
784#[derive(Debug, Clone, PartialEq, Eq)]
785pub enum Primary<'tree> {
786    Lhs(::std::boxed::Box<Lhs<'tree>>),
787    SimpleNumeric(::std::boxed::Box<SimpleNumeric<'tree>>),
788    Array(::std::boxed::Box<Array<'tree>>),
789    Begin(::std::boxed::Box<Begin<'tree>>),
790    Break(::std::boxed::Box<Break<'tree>>),
791    Call(::std::boxed::Box<Call<'tree>>),
792    Case(::std::boxed::Box<Case<'tree>>),
793    CaseMatch(::std::boxed::Box<CaseMatch<'tree>>),
794    ChainedString(::std::boxed::Box<ChainedString<'tree>>),
795    Character(::std::boxed::Box<Character<'tree>>),
796    Class(::std::boxed::Box<Class<'tree>>),
797    DelimitedSymbol(::std::boxed::Box<DelimitedSymbol<'tree>>),
798    For(::std::boxed::Box<For<'tree>>),
799    Hash(::std::boxed::Box<Hash<'tree>>),
800    HeredocBeginning(::std::boxed::Box<HeredocBeginning<'tree>>),
801    If(::std::boxed::Box<If<'tree>>),
802    Lambda(::std::boxed::Box<Lambda<'tree>>),
803    Method(::std::boxed::Box<Method<'tree>>),
804    Module(::std::boxed::Box<Module<'tree>>),
805    Next(::std::boxed::Box<Next<'tree>>),
806    ParenthesizedStatements(::std::boxed::Box<ParenthesizedStatements<'tree>>),
807    Redo(::std::boxed::Box<Redo<'tree>>),
808    Regex(::std::boxed::Box<Regex<'tree>>),
809    Retry(::std::boxed::Box<Retry<'tree>>),
810    Return(::std::boxed::Box<Return<'tree>>),
811    SimpleSymbol(::std::boxed::Box<SimpleSymbol<'tree>>),
812    SingletonClass(::std::boxed::Box<SingletonClass<'tree>>),
813    SingletonMethod(::std::boxed::Box<SingletonMethod<'tree>>),
814    String(::std::boxed::Box<String<'tree>>),
815    StringArray(::std::boxed::Box<StringArray<'tree>>),
816    Subshell(::std::boxed::Box<Subshell<'tree>>),
817    SymbolArray(::std::boxed::Box<SymbolArray<'tree>>),
818    Unary(::std::boxed::Box<Unary<'tree>>),
819    Unless(::std::boxed::Box<Unless<'tree>>),
820    Until(::std::boxed::Box<Until<'tree>>),
821    While(::std::boxed::Box<While<'tree>>),
822    Yield(::std::boxed::Box<Yield<'tree>>),
823}
824impl<'tree> ::treesitter_types::FromNode<'tree> for Primary<'tree> {
825    #[allow(clippy::collapsible_else_if)]
826    fn from_node(
827        node: ::treesitter_types::tree_sitter::Node<'tree>,
828        src: &'tree [u8],
829    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
830        match node.kind() {
831            "array" => Ok(Self::Array(::std::boxed::Box::new(
832                ::treesitter_types::runtime::maybe_grow_stack(|| {
833                    <Array as ::treesitter_types::FromNode>::from_node(node, src)
834                })?,
835            ))),
836            "begin" => Ok(Self::Begin(::std::boxed::Box::new(
837                ::treesitter_types::runtime::maybe_grow_stack(|| {
838                    <Begin as ::treesitter_types::FromNode>::from_node(node, src)
839                })?,
840            ))),
841            "break" => Ok(Self::Break(::std::boxed::Box::new(
842                ::treesitter_types::runtime::maybe_grow_stack(|| {
843                    <Break as ::treesitter_types::FromNode>::from_node(node, src)
844                })?,
845            ))),
846            "call" => Ok(Self::Call(::std::boxed::Box::new(
847                ::treesitter_types::runtime::maybe_grow_stack(|| {
848                    <Call as ::treesitter_types::FromNode>::from_node(node, src)
849                })?,
850            ))),
851            "case" => Ok(Self::Case(::std::boxed::Box::new(
852                ::treesitter_types::runtime::maybe_grow_stack(|| {
853                    <Case as ::treesitter_types::FromNode>::from_node(node, src)
854                })?,
855            ))),
856            "case_match" => Ok(Self::CaseMatch(::std::boxed::Box::new(
857                ::treesitter_types::runtime::maybe_grow_stack(|| {
858                    <CaseMatch as ::treesitter_types::FromNode>::from_node(node, src)
859                })?,
860            ))),
861            "chained_string" => Ok(Self::ChainedString(::std::boxed::Box::new(
862                ::treesitter_types::runtime::maybe_grow_stack(|| {
863                    <ChainedString as ::treesitter_types::FromNode>::from_node(node, src)
864                })?,
865            ))),
866            "character" => Ok(Self::Character(::std::boxed::Box::new(
867                ::treesitter_types::runtime::maybe_grow_stack(|| {
868                    <Character as ::treesitter_types::FromNode>::from_node(node, src)
869                })?,
870            ))),
871            "class" => Ok(Self::Class(::std::boxed::Box::new(
872                ::treesitter_types::runtime::maybe_grow_stack(|| {
873                    <Class as ::treesitter_types::FromNode>::from_node(node, src)
874                })?,
875            ))),
876            "delimited_symbol" => Ok(Self::DelimitedSymbol(::std::boxed::Box::new(
877                ::treesitter_types::runtime::maybe_grow_stack(|| {
878                    <DelimitedSymbol as ::treesitter_types::FromNode>::from_node(node, src)
879                })?,
880            ))),
881            "for" => Ok(Self::For(::std::boxed::Box::new(
882                ::treesitter_types::runtime::maybe_grow_stack(|| {
883                    <For as ::treesitter_types::FromNode>::from_node(node, src)
884                })?,
885            ))),
886            "hash" => Ok(Self::Hash(::std::boxed::Box::new(
887                ::treesitter_types::runtime::maybe_grow_stack(|| {
888                    <Hash as ::treesitter_types::FromNode>::from_node(node, src)
889                })?,
890            ))),
891            "heredoc_beginning" => Ok(Self::HeredocBeginning(::std::boxed::Box::new(
892                ::treesitter_types::runtime::maybe_grow_stack(|| {
893                    <HeredocBeginning as ::treesitter_types::FromNode>::from_node(node, src)
894                })?,
895            ))),
896            "if" => Ok(Self::If(::std::boxed::Box::new(
897                ::treesitter_types::runtime::maybe_grow_stack(|| {
898                    <If as ::treesitter_types::FromNode>::from_node(node, src)
899                })?,
900            ))),
901            "lambda" => Ok(Self::Lambda(::std::boxed::Box::new(
902                ::treesitter_types::runtime::maybe_grow_stack(|| {
903                    <Lambda as ::treesitter_types::FromNode>::from_node(node, src)
904                })?,
905            ))),
906            "method" => Ok(Self::Method(::std::boxed::Box::new(
907                ::treesitter_types::runtime::maybe_grow_stack(|| {
908                    <Method as ::treesitter_types::FromNode>::from_node(node, src)
909                })?,
910            ))),
911            "module" => Ok(Self::Module(::std::boxed::Box::new(
912                ::treesitter_types::runtime::maybe_grow_stack(|| {
913                    <Module as ::treesitter_types::FromNode>::from_node(node, src)
914                })?,
915            ))),
916            "next" => Ok(Self::Next(::std::boxed::Box::new(
917                ::treesitter_types::runtime::maybe_grow_stack(|| {
918                    <Next as ::treesitter_types::FromNode>::from_node(node, src)
919                })?,
920            ))),
921            "parenthesized_statements" => Ok(Self::ParenthesizedStatements(
922                ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
923                    <ParenthesizedStatements as ::treesitter_types::FromNode>::from_node(node, src)
924                })?),
925            )),
926            "redo" => Ok(Self::Redo(::std::boxed::Box::new(
927                ::treesitter_types::runtime::maybe_grow_stack(|| {
928                    <Redo as ::treesitter_types::FromNode>::from_node(node, src)
929                })?,
930            ))),
931            "regex" => Ok(Self::Regex(::std::boxed::Box::new(
932                ::treesitter_types::runtime::maybe_grow_stack(|| {
933                    <Regex as ::treesitter_types::FromNode>::from_node(node, src)
934                })?,
935            ))),
936            "retry" => Ok(Self::Retry(::std::boxed::Box::new(
937                ::treesitter_types::runtime::maybe_grow_stack(|| {
938                    <Retry as ::treesitter_types::FromNode>::from_node(node, src)
939                })?,
940            ))),
941            "return" => Ok(Self::Return(::std::boxed::Box::new(
942                ::treesitter_types::runtime::maybe_grow_stack(|| {
943                    <Return as ::treesitter_types::FromNode>::from_node(node, src)
944                })?,
945            ))),
946            "simple_symbol" => Ok(Self::SimpleSymbol(::std::boxed::Box::new(
947                ::treesitter_types::runtime::maybe_grow_stack(|| {
948                    <SimpleSymbol as ::treesitter_types::FromNode>::from_node(node, src)
949                })?,
950            ))),
951            "singleton_class" => Ok(Self::SingletonClass(::std::boxed::Box::new(
952                ::treesitter_types::runtime::maybe_grow_stack(|| {
953                    <SingletonClass as ::treesitter_types::FromNode>::from_node(node, src)
954                })?,
955            ))),
956            "singleton_method" => Ok(Self::SingletonMethod(::std::boxed::Box::new(
957                ::treesitter_types::runtime::maybe_grow_stack(|| {
958                    <SingletonMethod as ::treesitter_types::FromNode>::from_node(node, src)
959                })?,
960            ))),
961            "string" => Ok(Self::String(::std::boxed::Box::new(
962                ::treesitter_types::runtime::maybe_grow_stack(|| {
963                    <String as ::treesitter_types::FromNode>::from_node(node, src)
964                })?,
965            ))),
966            "string_array" => Ok(Self::StringArray(::std::boxed::Box::new(
967                ::treesitter_types::runtime::maybe_grow_stack(|| {
968                    <StringArray as ::treesitter_types::FromNode>::from_node(node, src)
969                })?,
970            ))),
971            "subshell" => Ok(Self::Subshell(::std::boxed::Box::new(
972                ::treesitter_types::runtime::maybe_grow_stack(|| {
973                    <Subshell as ::treesitter_types::FromNode>::from_node(node, src)
974                })?,
975            ))),
976            "symbol_array" => Ok(Self::SymbolArray(::std::boxed::Box::new(
977                ::treesitter_types::runtime::maybe_grow_stack(|| {
978                    <SymbolArray as ::treesitter_types::FromNode>::from_node(node, src)
979                })?,
980            ))),
981            "unary" => Ok(Self::Unary(::std::boxed::Box::new(
982                ::treesitter_types::runtime::maybe_grow_stack(|| {
983                    <Unary as ::treesitter_types::FromNode>::from_node(node, src)
984                })?,
985            ))),
986            "unless" => Ok(Self::Unless(::std::boxed::Box::new(
987                ::treesitter_types::runtime::maybe_grow_stack(|| {
988                    <Unless as ::treesitter_types::FromNode>::from_node(node, src)
989                })?,
990            ))),
991            "until" => Ok(Self::Until(::std::boxed::Box::new(
992                ::treesitter_types::runtime::maybe_grow_stack(|| {
993                    <Until as ::treesitter_types::FromNode>::from_node(node, src)
994                })?,
995            ))),
996            "while" => Ok(Self::While(::std::boxed::Box::new(
997                ::treesitter_types::runtime::maybe_grow_stack(|| {
998                    <While as ::treesitter_types::FromNode>::from_node(node, src)
999                })?,
1000            ))),
1001            "yield" => Ok(Self::Yield(::std::boxed::Box::new(
1002                ::treesitter_types::runtime::maybe_grow_stack(|| {
1003                    <Yield as ::treesitter_types::FromNode>::from_node(node, src)
1004                })?,
1005            ))),
1006            _other => {
1007                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
1008                    <Lhs as ::treesitter_types::FromNode>::from_node(node, src)
1009                }) {
1010                    Ok(Self::Lhs(::std::boxed::Box::new(v)))
1011                } else {
1012                    if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
1013                        <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src)
1014                    }) {
1015                        Ok(Self::SimpleNumeric(::std::boxed::Box::new(v)))
1016                    } else {
1017                        Err(::treesitter_types::ParseError::unexpected_kind(
1018                            _other, node,
1019                        ))
1020                    }
1021                }
1022            }
1023        }
1024    }
1025}
1026impl ::treesitter_types::Spanned for Primary<'_> {
1027    fn span(&self) -> ::treesitter_types::Span {
1028        match self {
1029            Self::Lhs(inner) => inner.span(),
1030            Self::SimpleNumeric(inner) => inner.span(),
1031            Self::Array(inner) => inner.span(),
1032            Self::Begin(inner) => inner.span(),
1033            Self::Break(inner) => inner.span(),
1034            Self::Call(inner) => inner.span(),
1035            Self::Case(inner) => inner.span(),
1036            Self::CaseMatch(inner) => inner.span(),
1037            Self::ChainedString(inner) => inner.span(),
1038            Self::Character(inner) => inner.span(),
1039            Self::Class(inner) => inner.span(),
1040            Self::DelimitedSymbol(inner) => inner.span(),
1041            Self::For(inner) => inner.span(),
1042            Self::Hash(inner) => inner.span(),
1043            Self::HeredocBeginning(inner) => inner.span(),
1044            Self::If(inner) => inner.span(),
1045            Self::Lambda(inner) => inner.span(),
1046            Self::Method(inner) => inner.span(),
1047            Self::Module(inner) => inner.span(),
1048            Self::Next(inner) => inner.span(),
1049            Self::ParenthesizedStatements(inner) => inner.span(),
1050            Self::Redo(inner) => inner.span(),
1051            Self::Regex(inner) => inner.span(),
1052            Self::Retry(inner) => inner.span(),
1053            Self::Return(inner) => inner.span(),
1054            Self::SimpleSymbol(inner) => inner.span(),
1055            Self::SingletonClass(inner) => inner.span(),
1056            Self::SingletonMethod(inner) => inner.span(),
1057            Self::String(inner) => inner.span(),
1058            Self::StringArray(inner) => inner.span(),
1059            Self::Subshell(inner) => inner.span(),
1060            Self::SymbolArray(inner) => inner.span(),
1061            Self::Unary(inner) => inner.span(),
1062            Self::Unless(inner) => inner.span(),
1063            Self::Until(inner) => inner.span(),
1064            Self::While(inner) => inner.span(),
1065            Self::Yield(inner) => inner.span(),
1066        }
1067    }
1068}
1069#[derive(Debug, Clone, PartialEq, Eq)]
1070pub enum SimpleNumeric<'tree> {
1071    Complex(::std::boxed::Box<Complex<'tree>>),
1072    Float(::std::boxed::Box<Float<'tree>>),
1073    Integer(::std::boxed::Box<Integer<'tree>>),
1074    Rational(::std::boxed::Box<Rational<'tree>>),
1075}
1076impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleNumeric<'tree> {
1077    #[allow(clippy::collapsible_else_if)]
1078    fn from_node(
1079        node: ::treesitter_types::tree_sitter::Node<'tree>,
1080        src: &'tree [u8],
1081    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1082        match node.kind() {
1083            "complex" => Ok(Self::Complex(::std::boxed::Box::new(
1084                ::treesitter_types::runtime::maybe_grow_stack(|| {
1085                    <Complex as ::treesitter_types::FromNode>::from_node(node, src)
1086                })?,
1087            ))),
1088            "float" => Ok(Self::Float(::std::boxed::Box::new(
1089                ::treesitter_types::runtime::maybe_grow_stack(|| {
1090                    <Float as ::treesitter_types::FromNode>::from_node(node, src)
1091                })?,
1092            ))),
1093            "integer" => Ok(Self::Integer(::std::boxed::Box::new(
1094                ::treesitter_types::runtime::maybe_grow_stack(|| {
1095                    <Integer as ::treesitter_types::FromNode>::from_node(node, src)
1096                })?,
1097            ))),
1098            "rational" => Ok(Self::Rational(::std::boxed::Box::new(
1099                ::treesitter_types::runtime::maybe_grow_stack(|| {
1100                    <Rational as ::treesitter_types::FromNode>::from_node(node, src)
1101                })?,
1102            ))),
1103            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1104        }
1105    }
1106}
1107impl ::treesitter_types::Spanned for SimpleNumeric<'_> {
1108    fn span(&self) -> ::treesitter_types::Span {
1109        match self {
1110            Self::Complex(inner) => inner.span(),
1111            Self::Float(inner) => inner.span(),
1112            Self::Integer(inner) => inner.span(),
1113            Self::Rational(inner) => inner.span(),
1114        }
1115    }
1116}
1117#[derive(Debug, Clone, PartialEq, Eq)]
1118pub enum Statement<'tree> {
1119    Expression(::std::boxed::Box<Expression<'tree>>),
1120    Alias(::std::boxed::Box<Alias<'tree>>),
1121    BeginBlock(::std::boxed::Box<BeginBlock<'tree>>),
1122    EndBlock(::std::boxed::Box<EndBlock<'tree>>),
1123    IfModifier(::std::boxed::Box<IfModifier<'tree>>),
1124    RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
1125    Undef(::std::boxed::Box<Undef<'tree>>),
1126    UnlessModifier(::std::boxed::Box<UnlessModifier<'tree>>),
1127    UntilModifier(::std::boxed::Box<UntilModifier<'tree>>),
1128    WhileModifier(::std::boxed::Box<WhileModifier<'tree>>),
1129}
1130impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
1131    #[allow(clippy::collapsible_else_if)]
1132    fn from_node(
1133        node: ::treesitter_types::tree_sitter::Node<'tree>,
1134        src: &'tree [u8],
1135    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1136        match node.kind() {
1137            "alias" => Ok(Self::Alias(::std::boxed::Box::new(
1138                ::treesitter_types::runtime::maybe_grow_stack(|| {
1139                    <Alias as ::treesitter_types::FromNode>::from_node(node, src)
1140                })?,
1141            ))),
1142            "begin_block" => Ok(Self::BeginBlock(::std::boxed::Box::new(
1143                ::treesitter_types::runtime::maybe_grow_stack(|| {
1144                    <BeginBlock as ::treesitter_types::FromNode>::from_node(node, src)
1145                })?,
1146            ))),
1147            "end_block" => Ok(Self::EndBlock(::std::boxed::Box::new(
1148                ::treesitter_types::runtime::maybe_grow_stack(|| {
1149                    <EndBlock as ::treesitter_types::FromNode>::from_node(node, src)
1150                })?,
1151            ))),
1152            "if_modifier" => Ok(Self::IfModifier(::std::boxed::Box::new(
1153                ::treesitter_types::runtime::maybe_grow_stack(|| {
1154                    <IfModifier as ::treesitter_types::FromNode>::from_node(node, src)
1155                })?,
1156            ))),
1157            "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
1158                ::treesitter_types::runtime::maybe_grow_stack(|| {
1159                    <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)
1160                })?,
1161            ))),
1162            "undef" => Ok(Self::Undef(::std::boxed::Box::new(
1163                ::treesitter_types::runtime::maybe_grow_stack(|| {
1164                    <Undef as ::treesitter_types::FromNode>::from_node(node, src)
1165                })?,
1166            ))),
1167            "unless_modifier" => Ok(Self::UnlessModifier(::std::boxed::Box::new(
1168                ::treesitter_types::runtime::maybe_grow_stack(|| {
1169                    <UnlessModifier as ::treesitter_types::FromNode>::from_node(node, src)
1170                })?,
1171            ))),
1172            "until_modifier" => Ok(Self::UntilModifier(::std::boxed::Box::new(
1173                ::treesitter_types::runtime::maybe_grow_stack(|| {
1174                    <UntilModifier as ::treesitter_types::FromNode>::from_node(node, src)
1175                })?,
1176            ))),
1177            "while_modifier" => Ok(Self::WhileModifier(::std::boxed::Box::new(
1178                ::treesitter_types::runtime::maybe_grow_stack(|| {
1179                    <WhileModifier as ::treesitter_types::FromNode>::from_node(node, src)
1180                })?,
1181            ))),
1182            _other => {
1183                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
1184                    <Expression as ::treesitter_types::FromNode>::from_node(node, src)
1185                }) {
1186                    Ok(Self::Expression(::std::boxed::Box::new(v)))
1187                } else {
1188                    Err(::treesitter_types::ParseError::unexpected_kind(
1189                        _other, node,
1190                    ))
1191                }
1192            }
1193        }
1194    }
1195}
1196impl ::treesitter_types::Spanned for Statement<'_> {
1197    fn span(&self) -> ::treesitter_types::Span {
1198        match self {
1199            Self::Expression(inner) => inner.span(),
1200            Self::Alias(inner) => inner.span(),
1201            Self::BeginBlock(inner) => inner.span(),
1202            Self::EndBlock(inner) => inner.span(),
1203            Self::IfModifier(inner) => inner.span(),
1204            Self::RescueModifier(inner) => inner.span(),
1205            Self::Undef(inner) => inner.span(),
1206            Self::UnlessModifier(inner) => inner.span(),
1207            Self::UntilModifier(inner) => inner.span(),
1208            Self::WhileModifier(inner) => inner.span(),
1209        }
1210    }
1211}
1212#[derive(Debug, Clone, PartialEq, Eq)]
1213pub enum Variable<'tree> {
1214    NonlocalVariable(::std::boxed::Box<NonlocalVariable<'tree>>),
1215    Constant(::std::boxed::Box<Constant<'tree>>),
1216    Identifier(::std::boxed::Box<Identifier<'tree>>),
1217    SelfType(::std::boxed::Box<SelfType<'tree>>),
1218    Super(::std::boxed::Box<Super<'tree>>),
1219}
1220impl<'tree> ::treesitter_types::FromNode<'tree> for Variable<'tree> {
1221    #[allow(clippy::collapsible_else_if)]
1222    fn from_node(
1223        node: ::treesitter_types::tree_sitter::Node<'tree>,
1224        src: &'tree [u8],
1225    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1226        match node.kind() {
1227            "constant" => Ok(Self::Constant(::std::boxed::Box::new(
1228                ::treesitter_types::runtime::maybe_grow_stack(|| {
1229                    <Constant as ::treesitter_types::FromNode>::from_node(node, src)
1230                })?,
1231            ))),
1232            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
1233                ::treesitter_types::runtime::maybe_grow_stack(|| {
1234                    <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
1235                })?,
1236            ))),
1237            "self" => Ok(Self::SelfType(::std::boxed::Box::new(
1238                ::treesitter_types::runtime::maybe_grow_stack(|| {
1239                    <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
1240                })?,
1241            ))),
1242            "super" => Ok(Self::Super(::std::boxed::Box::new(
1243                ::treesitter_types::runtime::maybe_grow_stack(|| {
1244                    <Super as ::treesitter_types::FromNode>::from_node(node, src)
1245                })?,
1246            ))),
1247            _other => {
1248                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
1249                    <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
1250                }) {
1251                    Ok(Self::NonlocalVariable(::std::boxed::Box::new(v)))
1252                } else {
1253                    Err(::treesitter_types::ParseError::unexpected_kind(
1254                        _other, node,
1255                    ))
1256                }
1257            }
1258        }
1259    }
1260}
1261impl ::treesitter_types::Spanned for Variable<'_> {
1262    fn span(&self) -> ::treesitter_types::Span {
1263        match self {
1264            Self::NonlocalVariable(inner) => inner.span(),
1265            Self::Constant(inner) => inner.span(),
1266            Self::Identifier(inner) => inner.span(),
1267            Self::SelfType(inner) => inner.span(),
1268            Self::Super(inner) => inner.span(),
1269        }
1270    }
1271}
1272#[derive(Debug, Clone, PartialEq, Eq)]
1273pub struct Alias<'tree> {
1274    pub span: ::treesitter_types::Span,
1275    pub alias: MethodName<'tree>,
1276    pub name: MethodName<'tree>,
1277}
1278impl<'tree> ::treesitter_types::FromNode<'tree> for Alias<'tree> {
1279    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1280    fn from_node(
1281        node: ::treesitter_types::tree_sitter::Node<'tree>,
1282        src: &'tree [u8],
1283    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1284        debug_assert_eq!(node.kind(), "alias");
1285        Ok(Self {
1286            span: ::treesitter_types::Span::from(node),
1287            alias: {
1288                let child = node
1289                    .child_by_field_name("alias")
1290                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
1291                ::treesitter_types::runtime::maybe_grow_stack(|| {
1292                    <MethodName as ::treesitter_types::FromNode>::from_node(child, src)
1293                })?
1294            },
1295            name: {
1296                let child = node
1297                    .child_by_field_name("name")
1298                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1299                ::treesitter_types::runtime::maybe_grow_stack(|| {
1300                    <MethodName as ::treesitter_types::FromNode>::from_node(child, src)
1301                })?
1302            },
1303        })
1304    }
1305}
1306impl ::treesitter_types::Spanned for Alias<'_> {
1307    fn span(&self) -> ::treesitter_types::Span {
1308        self.span
1309    }
1310}
1311#[derive(Debug, Clone, PartialEq, Eq)]
1312pub struct AlternativePattern<'tree> {
1313    pub span: ::treesitter_types::Span,
1314    pub alternatives: ::std::vec::Vec<PatternExprBasic<'tree>>,
1315}
1316impl<'tree> ::treesitter_types::FromNode<'tree> for AlternativePattern<'tree> {
1317    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1318    fn from_node(
1319        node: ::treesitter_types::tree_sitter::Node<'tree>,
1320        src: &'tree [u8],
1321    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1322        debug_assert_eq!(node.kind(), "alternative_pattern");
1323        Ok(Self {
1324            span: ::treesitter_types::Span::from(node),
1325            alternatives: {
1326                let mut cursor = node.walk();
1327                let mut items = ::std::vec::Vec::new();
1328                for child in node.children_by_field_name("alternatives", &mut cursor) {
1329                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1330                        <PatternExprBasic as ::treesitter_types::FromNode>::from_node(child, src)
1331                    })?);
1332                }
1333                items
1334            },
1335        })
1336    }
1337}
1338impl ::treesitter_types::Spanned for AlternativePattern<'_> {
1339    fn span(&self) -> ::treesitter_types::Span {
1340        self.span
1341    }
1342}
1343#[derive(Debug, Clone, PartialEq, Eq)]
1344pub struct ArgumentList<'tree> {
1345    pub span: ::treesitter_types::Span,
1346    pub children: ::std::vec::Vec<ArgumentListChildren<'tree>>,
1347}
1348impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
1349    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1350    fn from_node(
1351        node: ::treesitter_types::tree_sitter::Node<'tree>,
1352        src: &'tree [u8],
1353    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1354        debug_assert_eq!(node.kind(), "argument_list");
1355        Ok(Self {
1356            span: ::treesitter_types::Span::from(node),
1357            children: {
1358                #[allow(clippy::suspicious_else_formatting)]
1359                let non_field_children = {
1360                    let mut cursor = node.walk();
1361                    let mut result = ::std::vec::Vec::new();
1362                    if cursor.goto_first_child() {
1363                        loop {
1364                            if cursor.field_name().is_none()
1365                                && cursor.node().is_named()
1366                                && !cursor.node().is_extra()
1367                            {
1368                                result.push(cursor.node());
1369                            }
1370                            if !cursor.goto_next_sibling() {
1371                                break;
1372                            }
1373                        }
1374                    }
1375                    result
1376                };
1377                let mut items = ::std::vec::Vec::new();
1378                for child in non_field_children {
1379                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1380                        <ArgumentListChildren as ::treesitter_types::FromNode>::from_node(
1381                            child, src,
1382                        )
1383                    })?);
1384                }
1385                items
1386            },
1387        })
1388    }
1389}
1390impl ::treesitter_types::Spanned for ArgumentList<'_> {
1391    fn span(&self) -> ::treesitter_types::Span {
1392        self.span
1393    }
1394}
1395#[derive(Debug, Clone, PartialEq, Eq)]
1396pub struct Array<'tree> {
1397    pub span: ::treesitter_types::Span,
1398    pub children: ::std::vec::Vec<ArrayChildren<'tree>>,
1399}
1400impl<'tree> ::treesitter_types::FromNode<'tree> for Array<'tree> {
1401    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1402    fn from_node(
1403        node: ::treesitter_types::tree_sitter::Node<'tree>,
1404        src: &'tree [u8],
1405    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1406        debug_assert_eq!(node.kind(), "array");
1407        Ok(Self {
1408            span: ::treesitter_types::Span::from(node),
1409            children: {
1410                #[allow(clippy::suspicious_else_formatting)]
1411                let non_field_children = {
1412                    let mut cursor = node.walk();
1413                    let mut result = ::std::vec::Vec::new();
1414                    if cursor.goto_first_child() {
1415                        loop {
1416                            if cursor.field_name().is_none()
1417                                && cursor.node().is_named()
1418                                && !cursor.node().is_extra()
1419                            {
1420                                result.push(cursor.node());
1421                            }
1422                            if !cursor.goto_next_sibling() {
1423                                break;
1424                            }
1425                        }
1426                    }
1427                    result
1428                };
1429                let mut items = ::std::vec::Vec::new();
1430                for child in non_field_children {
1431                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1432                        <ArrayChildren as ::treesitter_types::FromNode>::from_node(child, src)
1433                    })?);
1434                }
1435                items
1436            },
1437        })
1438    }
1439}
1440impl ::treesitter_types::Spanned for Array<'_> {
1441    fn span(&self) -> ::treesitter_types::Span {
1442        self.span
1443    }
1444}
1445#[derive(Debug, Clone, PartialEq, Eq)]
1446pub struct ArrayPattern<'tree> {
1447    pub span: ::treesitter_types::Span,
1448    pub class: ::core::option::Option<PatternConstant<'tree>>,
1449    pub children: ::std::vec::Vec<ArrayPatternChildren<'tree>>,
1450}
1451impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPattern<'tree> {
1452    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1453    fn from_node(
1454        node: ::treesitter_types::tree_sitter::Node<'tree>,
1455        src: &'tree [u8],
1456    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1457        debug_assert_eq!(node.kind(), "array_pattern");
1458        Ok(Self {
1459            span: ::treesitter_types::Span::from(node),
1460            class: match node.child_by_field_name("class") {
1461                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1462                    <PatternConstant as ::treesitter_types::FromNode>::from_node(child, src)
1463                })?),
1464                None => None,
1465            },
1466            children: {
1467                #[allow(clippy::suspicious_else_formatting)]
1468                let non_field_children = {
1469                    let mut cursor = node.walk();
1470                    let mut result = ::std::vec::Vec::new();
1471                    if cursor.goto_first_child() {
1472                        loop {
1473                            if cursor.field_name().is_none()
1474                                && cursor.node().is_named()
1475                                && !cursor.node().is_extra()
1476                            {
1477                                result.push(cursor.node());
1478                            }
1479                            if !cursor.goto_next_sibling() {
1480                                break;
1481                            }
1482                        }
1483                    }
1484                    result
1485                };
1486                let mut items = ::std::vec::Vec::new();
1487                for child in non_field_children {
1488                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1489                        <ArrayPatternChildren as ::treesitter_types::FromNode>::from_node(
1490                            child, src,
1491                        )
1492                    })?);
1493                }
1494                items
1495            },
1496        })
1497    }
1498}
1499impl ::treesitter_types::Spanned for ArrayPattern<'_> {
1500    fn span(&self) -> ::treesitter_types::Span {
1501        self.span
1502    }
1503}
1504#[derive(Debug, Clone, PartialEq, Eq)]
1505pub struct AsPattern<'tree> {
1506    pub span: ::treesitter_types::Span,
1507    pub name: Identifier<'tree>,
1508    pub value: PatternExpr<'tree>,
1509}
1510impl<'tree> ::treesitter_types::FromNode<'tree> for AsPattern<'tree> {
1511    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1512    fn from_node(
1513        node: ::treesitter_types::tree_sitter::Node<'tree>,
1514        src: &'tree [u8],
1515    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1516        debug_assert_eq!(node.kind(), "as_pattern");
1517        Ok(Self {
1518            span: ::treesitter_types::Span::from(node),
1519            name: {
1520                let child = node
1521                    .child_by_field_name("name")
1522                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1523                ::treesitter_types::runtime::maybe_grow_stack(|| {
1524                    <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1525                })?
1526            },
1527            value: {
1528                let child = node
1529                    .child_by_field_name("value")
1530                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1531                ::treesitter_types::runtime::maybe_grow_stack(|| {
1532                    <PatternExpr as ::treesitter_types::FromNode>::from_node(child, src)
1533                })?
1534            },
1535        })
1536    }
1537}
1538impl ::treesitter_types::Spanned for AsPattern<'_> {
1539    fn span(&self) -> ::treesitter_types::Span {
1540        self.span
1541    }
1542}
1543#[derive(Debug, Clone, PartialEq, Eq)]
1544pub struct Assignment<'tree> {
1545    pub span: ::treesitter_types::Span,
1546    pub left: AssignmentLeft<'tree>,
1547    pub right: AssignmentRight<'tree>,
1548}
1549impl<'tree> ::treesitter_types::FromNode<'tree> for Assignment<'tree> {
1550    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1551    fn from_node(
1552        node: ::treesitter_types::tree_sitter::Node<'tree>,
1553        src: &'tree [u8],
1554    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1555        debug_assert_eq!(node.kind(), "assignment");
1556        Ok(Self {
1557            span: ::treesitter_types::Span::from(node),
1558            left: {
1559                let child = node
1560                    .child_by_field_name("left")
1561                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1562                ::treesitter_types::runtime::maybe_grow_stack(|| {
1563                    <AssignmentLeft as ::treesitter_types::FromNode>::from_node(child, src)
1564                })?
1565            },
1566            right: {
1567                let child = node
1568                    .child_by_field_name("right")
1569                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1570                ::treesitter_types::runtime::maybe_grow_stack(|| {
1571                    <AssignmentRight as ::treesitter_types::FromNode>::from_node(child, src)
1572                })?
1573            },
1574        })
1575    }
1576}
1577impl ::treesitter_types::Spanned for Assignment<'_> {
1578    fn span(&self) -> ::treesitter_types::Span {
1579        self.span
1580    }
1581}
1582#[derive(Debug, Clone, PartialEq, Eq)]
1583pub struct BareString<'tree> {
1584    pub span: ::treesitter_types::Span,
1585    pub children: ::std::vec::Vec<BareStringChildren<'tree>>,
1586}
1587impl<'tree> ::treesitter_types::FromNode<'tree> for BareString<'tree> {
1588    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1589    fn from_node(
1590        node: ::treesitter_types::tree_sitter::Node<'tree>,
1591        src: &'tree [u8],
1592    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1593        debug_assert_eq!(node.kind(), "bare_string");
1594        Ok(Self {
1595            span: ::treesitter_types::Span::from(node),
1596            children: {
1597                #[allow(clippy::suspicious_else_formatting)]
1598                let non_field_children = {
1599                    let mut cursor = node.walk();
1600                    let mut result = ::std::vec::Vec::new();
1601                    if cursor.goto_first_child() {
1602                        loop {
1603                            if cursor.field_name().is_none()
1604                                && cursor.node().is_named()
1605                                && !cursor.node().is_extra()
1606                            {
1607                                result.push(cursor.node());
1608                            }
1609                            if !cursor.goto_next_sibling() {
1610                                break;
1611                            }
1612                        }
1613                    }
1614                    result
1615                };
1616                let mut items = ::std::vec::Vec::new();
1617                for child in non_field_children {
1618                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1619                        <BareStringChildren as ::treesitter_types::FromNode>::from_node(child, src)
1620                    })?);
1621                }
1622                items
1623            },
1624        })
1625    }
1626}
1627impl ::treesitter_types::Spanned for BareString<'_> {
1628    fn span(&self) -> ::treesitter_types::Span {
1629        self.span
1630    }
1631}
1632#[derive(Debug, Clone, PartialEq, Eq)]
1633pub struct BareSymbol<'tree> {
1634    pub span: ::treesitter_types::Span,
1635    pub children: ::std::vec::Vec<BareSymbolChildren<'tree>>,
1636}
1637impl<'tree> ::treesitter_types::FromNode<'tree> for BareSymbol<'tree> {
1638    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1639    fn from_node(
1640        node: ::treesitter_types::tree_sitter::Node<'tree>,
1641        src: &'tree [u8],
1642    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1643        debug_assert_eq!(node.kind(), "bare_symbol");
1644        Ok(Self {
1645            span: ::treesitter_types::Span::from(node),
1646            children: {
1647                #[allow(clippy::suspicious_else_formatting)]
1648                let non_field_children = {
1649                    let mut cursor = node.walk();
1650                    let mut result = ::std::vec::Vec::new();
1651                    if cursor.goto_first_child() {
1652                        loop {
1653                            if cursor.field_name().is_none()
1654                                && cursor.node().is_named()
1655                                && !cursor.node().is_extra()
1656                            {
1657                                result.push(cursor.node());
1658                            }
1659                            if !cursor.goto_next_sibling() {
1660                                break;
1661                            }
1662                        }
1663                    }
1664                    result
1665                };
1666                let mut items = ::std::vec::Vec::new();
1667                for child in non_field_children {
1668                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1669                        <BareSymbolChildren as ::treesitter_types::FromNode>::from_node(child, src)
1670                    })?);
1671                }
1672                items
1673            },
1674        })
1675    }
1676}
1677impl ::treesitter_types::Spanned for BareSymbol<'_> {
1678    fn span(&self) -> ::treesitter_types::Span {
1679        self.span
1680    }
1681}
1682#[derive(Debug, Clone, PartialEq, Eq)]
1683pub struct Begin<'tree> {
1684    pub span: ::treesitter_types::Span,
1685    pub children: ::std::vec::Vec<BeginChildren<'tree>>,
1686}
1687impl<'tree> ::treesitter_types::FromNode<'tree> for Begin<'tree> {
1688    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1689    fn from_node(
1690        node: ::treesitter_types::tree_sitter::Node<'tree>,
1691        src: &'tree [u8],
1692    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1693        debug_assert_eq!(node.kind(), "begin");
1694        Ok(Self {
1695            span: ::treesitter_types::Span::from(node),
1696            children: {
1697                #[allow(clippy::suspicious_else_formatting)]
1698                let non_field_children = {
1699                    let mut cursor = node.walk();
1700                    let mut result = ::std::vec::Vec::new();
1701                    if cursor.goto_first_child() {
1702                        loop {
1703                            if cursor.field_name().is_none()
1704                                && cursor.node().is_named()
1705                                && !cursor.node().is_extra()
1706                            {
1707                                result.push(cursor.node());
1708                            }
1709                            if !cursor.goto_next_sibling() {
1710                                break;
1711                            }
1712                        }
1713                    }
1714                    result
1715                };
1716                let mut items = ::std::vec::Vec::new();
1717                for child in non_field_children {
1718                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1719                        <BeginChildren as ::treesitter_types::FromNode>::from_node(child, src)
1720                    })?);
1721                }
1722                items
1723            },
1724        })
1725    }
1726}
1727impl ::treesitter_types::Spanned for Begin<'_> {
1728    fn span(&self) -> ::treesitter_types::Span {
1729        self.span
1730    }
1731}
1732#[derive(Debug, Clone, PartialEq, Eq)]
1733pub struct BeginBlock<'tree> {
1734    pub span: ::treesitter_types::Span,
1735    pub children: ::std::vec::Vec<BeginBlockChildren<'tree>>,
1736}
1737impl<'tree> ::treesitter_types::FromNode<'tree> for BeginBlock<'tree> {
1738    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1739    fn from_node(
1740        node: ::treesitter_types::tree_sitter::Node<'tree>,
1741        src: &'tree [u8],
1742    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1743        debug_assert_eq!(node.kind(), "begin_block");
1744        Ok(Self {
1745            span: ::treesitter_types::Span::from(node),
1746            children: {
1747                #[allow(clippy::suspicious_else_formatting)]
1748                let non_field_children = {
1749                    let mut cursor = node.walk();
1750                    let mut result = ::std::vec::Vec::new();
1751                    if cursor.goto_first_child() {
1752                        loop {
1753                            if cursor.field_name().is_none()
1754                                && cursor.node().is_named()
1755                                && !cursor.node().is_extra()
1756                            {
1757                                result.push(cursor.node());
1758                            }
1759                            if !cursor.goto_next_sibling() {
1760                                break;
1761                            }
1762                        }
1763                    }
1764                    result
1765                };
1766                let mut items = ::std::vec::Vec::new();
1767                for child in non_field_children {
1768                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1769                        <BeginBlockChildren as ::treesitter_types::FromNode>::from_node(child, src)
1770                    })?);
1771                }
1772                items
1773            },
1774        })
1775    }
1776}
1777impl ::treesitter_types::Spanned for BeginBlock<'_> {
1778    fn span(&self) -> ::treesitter_types::Span {
1779        self.span
1780    }
1781}
1782#[derive(Debug, Clone, PartialEq, Eq)]
1783pub struct Binary<'tree> {
1784    pub span: ::treesitter_types::Span,
1785    pub left: BinaryLeft<'tree>,
1786    pub operator: BinaryOperator,
1787    pub right: Expression<'tree>,
1788}
1789impl<'tree> ::treesitter_types::FromNode<'tree> for Binary<'tree> {
1790    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1791    fn from_node(
1792        node: ::treesitter_types::tree_sitter::Node<'tree>,
1793        src: &'tree [u8],
1794    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1795        debug_assert_eq!(node.kind(), "binary");
1796        Ok(Self {
1797            span: ::treesitter_types::Span::from(node),
1798            left: {
1799                let child = node
1800                    .child_by_field_name("left")
1801                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1802                ::treesitter_types::runtime::maybe_grow_stack(|| {
1803                    <BinaryLeft as ::treesitter_types::FromNode>::from_node(child, src)
1804                })?
1805            },
1806            operator: {
1807                let child = node.child_by_field_name("operator").ok_or_else(|| {
1808                    ::treesitter_types::ParseError::missing_field("operator", node)
1809                })?;
1810                ::treesitter_types::runtime::maybe_grow_stack(|| {
1811                    <BinaryOperator as ::treesitter_types::FromNode>::from_node(child, src)
1812                })?
1813            },
1814            right: {
1815                let child = node
1816                    .child_by_field_name("right")
1817                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1818                ::treesitter_types::runtime::maybe_grow_stack(|| {
1819                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1820                })?
1821            },
1822        })
1823    }
1824}
1825impl ::treesitter_types::Spanned for Binary<'_> {
1826    fn span(&self) -> ::treesitter_types::Span {
1827        self.span
1828    }
1829}
1830#[derive(Debug, Clone, PartialEq, Eq)]
1831pub struct Block<'tree> {
1832    pub span: ::treesitter_types::Span,
1833    pub body: ::core::option::Option<BlockBody<'tree>>,
1834    pub parameters: ::core::option::Option<BlockParameters<'tree>>,
1835}
1836impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
1837    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1838    fn from_node(
1839        node: ::treesitter_types::tree_sitter::Node<'tree>,
1840        src: &'tree [u8],
1841    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1842        debug_assert_eq!(node.kind(), "block");
1843        Ok(Self {
1844            span: ::treesitter_types::Span::from(node),
1845            body: match node.child_by_field_name("body") {
1846                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1847                    <BlockBody as ::treesitter_types::FromNode>::from_node(child, src)
1848                })?),
1849                None => None,
1850            },
1851            parameters: match node.child_by_field_name("parameters") {
1852                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1853                    <BlockParameters as ::treesitter_types::FromNode>::from_node(child, src)
1854                })?),
1855                None => None,
1856            },
1857        })
1858    }
1859}
1860impl ::treesitter_types::Spanned for Block<'_> {
1861    fn span(&self) -> ::treesitter_types::Span {
1862        self.span
1863    }
1864}
1865#[derive(Debug, Clone, PartialEq, Eq)]
1866pub struct BlockArgument<'tree> {
1867    pub span: ::treesitter_types::Span,
1868    pub children: ::core::option::Option<Arg<'tree>>,
1869}
1870impl<'tree> ::treesitter_types::FromNode<'tree> for BlockArgument<'tree> {
1871    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1872    fn from_node(
1873        node: ::treesitter_types::tree_sitter::Node<'tree>,
1874        src: &'tree [u8],
1875    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1876        debug_assert_eq!(node.kind(), "block_argument");
1877        Ok(Self {
1878            span: ::treesitter_types::Span::from(node),
1879            children: {
1880                #[allow(clippy::suspicious_else_formatting)]
1881                let non_field_children = {
1882                    let mut cursor = node.walk();
1883                    let mut result = ::std::vec::Vec::new();
1884                    if cursor.goto_first_child() {
1885                        loop {
1886                            if cursor.field_name().is_none()
1887                                && cursor.node().is_named()
1888                                && !cursor.node().is_extra()
1889                            {
1890                                result.push(cursor.node());
1891                            }
1892                            if !cursor.goto_next_sibling() {
1893                                break;
1894                            }
1895                        }
1896                    }
1897                    result
1898                };
1899                match non_field_children.first() {
1900                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1901                        <Arg as ::treesitter_types::FromNode>::from_node(child, src)
1902                    })?),
1903                    None => None,
1904                }
1905            },
1906        })
1907    }
1908}
1909impl ::treesitter_types::Spanned for BlockArgument<'_> {
1910    fn span(&self) -> ::treesitter_types::Span {
1911        self.span
1912    }
1913}
1914#[derive(Debug, Clone, PartialEq, Eq)]
1915pub struct BlockBody<'tree> {
1916    pub span: ::treesitter_types::Span,
1917    pub children: ::std::vec::Vec<BlockBodyChildren<'tree>>,
1918}
1919impl<'tree> ::treesitter_types::FromNode<'tree> for BlockBody<'tree> {
1920    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1921    fn from_node(
1922        node: ::treesitter_types::tree_sitter::Node<'tree>,
1923        src: &'tree [u8],
1924    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1925        debug_assert_eq!(node.kind(), "block_body");
1926        Ok(Self {
1927            span: ::treesitter_types::Span::from(node),
1928            children: {
1929                #[allow(clippy::suspicious_else_formatting)]
1930                let non_field_children = {
1931                    let mut cursor = node.walk();
1932                    let mut result = ::std::vec::Vec::new();
1933                    if cursor.goto_first_child() {
1934                        loop {
1935                            if cursor.field_name().is_none()
1936                                && cursor.node().is_named()
1937                                && !cursor.node().is_extra()
1938                            {
1939                                result.push(cursor.node());
1940                            }
1941                            if !cursor.goto_next_sibling() {
1942                                break;
1943                            }
1944                        }
1945                    }
1946                    result
1947                };
1948                let mut items = ::std::vec::Vec::new();
1949                for child in non_field_children {
1950                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1951                        <BlockBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)
1952                    })?);
1953                }
1954                items
1955            },
1956        })
1957    }
1958}
1959impl ::treesitter_types::Spanned for BlockBody<'_> {
1960    fn span(&self) -> ::treesitter_types::Span {
1961        self.span
1962    }
1963}
1964#[derive(Debug, Clone, PartialEq, Eq)]
1965pub struct BlockParameter<'tree> {
1966    pub span: ::treesitter_types::Span,
1967    pub name: ::core::option::Option<Identifier<'tree>>,
1968}
1969impl<'tree> ::treesitter_types::FromNode<'tree> for BlockParameter<'tree> {
1970    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1971    fn from_node(
1972        node: ::treesitter_types::tree_sitter::Node<'tree>,
1973        src: &'tree [u8],
1974    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1975        debug_assert_eq!(node.kind(), "block_parameter");
1976        Ok(Self {
1977            span: ::treesitter_types::Span::from(node),
1978            name: match node.child_by_field_name("name") {
1979                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1980                    <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1981                })?),
1982                None => None,
1983            },
1984        })
1985    }
1986}
1987impl ::treesitter_types::Spanned for BlockParameter<'_> {
1988    fn span(&self) -> ::treesitter_types::Span {
1989        self.span
1990    }
1991}
1992#[derive(Debug, Clone, PartialEq, Eq)]
1993pub struct BlockParameters<'tree> {
1994    pub span: ::treesitter_types::Span,
1995    pub locals: ::std::vec::Vec<Identifier<'tree>>,
1996    pub children: ::std::vec::Vec<BlockParametersChildren<'tree>>,
1997}
1998impl<'tree> ::treesitter_types::FromNode<'tree> for BlockParameters<'tree> {
1999    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2000    fn from_node(
2001        node: ::treesitter_types::tree_sitter::Node<'tree>,
2002        src: &'tree [u8],
2003    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2004        debug_assert_eq!(node.kind(), "block_parameters");
2005        Ok(Self {
2006            span: ::treesitter_types::Span::from(node),
2007            locals: {
2008                let mut cursor = node.walk();
2009                let mut items = ::std::vec::Vec::new();
2010                for child in node.children_by_field_name("locals", &mut cursor) {
2011                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2012                        <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2013                    })?);
2014                }
2015                items
2016            },
2017            children: {
2018                #[allow(clippy::suspicious_else_formatting)]
2019                let non_field_children = {
2020                    let mut cursor = node.walk();
2021                    let mut result = ::std::vec::Vec::new();
2022                    if cursor.goto_first_child() {
2023                        loop {
2024                            if cursor.field_name().is_none()
2025                                && cursor.node().is_named()
2026                                && !cursor.node().is_extra()
2027                            {
2028                                result.push(cursor.node());
2029                            }
2030                            if !cursor.goto_next_sibling() {
2031                                break;
2032                            }
2033                        }
2034                    }
2035                    result
2036                };
2037                let mut items = ::std::vec::Vec::new();
2038                for child in non_field_children {
2039                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2040                        <BlockParametersChildren as ::treesitter_types::FromNode>::from_node(
2041                            child, src,
2042                        )
2043                    })?);
2044                }
2045                items
2046            },
2047        })
2048    }
2049}
2050impl ::treesitter_types::Spanned for BlockParameters<'_> {
2051    fn span(&self) -> ::treesitter_types::Span {
2052        self.span
2053    }
2054}
2055#[derive(Debug, Clone, PartialEq, Eq)]
2056pub struct BodyStatement<'tree> {
2057    pub span: ::treesitter_types::Span,
2058    pub children: ::std::vec::Vec<BodyStatementChildren<'tree>>,
2059}
2060impl<'tree> ::treesitter_types::FromNode<'tree> for BodyStatement<'tree> {
2061    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2062    fn from_node(
2063        node: ::treesitter_types::tree_sitter::Node<'tree>,
2064        src: &'tree [u8],
2065    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2066        debug_assert_eq!(node.kind(), "body_statement");
2067        Ok(Self {
2068            span: ::treesitter_types::Span::from(node),
2069            children: {
2070                #[allow(clippy::suspicious_else_formatting)]
2071                let non_field_children = {
2072                    let mut cursor = node.walk();
2073                    let mut result = ::std::vec::Vec::new();
2074                    if cursor.goto_first_child() {
2075                        loop {
2076                            if cursor.field_name().is_none()
2077                                && cursor.node().is_named()
2078                                && !cursor.node().is_extra()
2079                            {
2080                                result.push(cursor.node());
2081                            }
2082                            if !cursor.goto_next_sibling() {
2083                                break;
2084                            }
2085                        }
2086                    }
2087                    result
2088                };
2089                let mut items = ::std::vec::Vec::new();
2090                for child in non_field_children {
2091                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2092                        <BodyStatementChildren as ::treesitter_types::FromNode>::from_node(
2093                            child, src,
2094                        )
2095                    })?);
2096                }
2097                items
2098            },
2099        })
2100    }
2101}
2102impl ::treesitter_types::Spanned for BodyStatement<'_> {
2103    fn span(&self) -> ::treesitter_types::Span {
2104        self.span
2105    }
2106}
2107#[derive(Debug, Clone, PartialEq, Eq)]
2108pub struct Break<'tree> {
2109    pub span: ::treesitter_types::Span,
2110    pub children: ::core::option::Option<ArgumentList<'tree>>,
2111}
2112impl<'tree> ::treesitter_types::FromNode<'tree> for Break<'tree> {
2113    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2114    fn from_node(
2115        node: ::treesitter_types::tree_sitter::Node<'tree>,
2116        src: &'tree [u8],
2117    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2118        debug_assert_eq!(node.kind(), "break");
2119        Ok(Self {
2120            span: ::treesitter_types::Span::from(node),
2121            children: {
2122                #[allow(clippy::suspicious_else_formatting)]
2123                let non_field_children = {
2124                    let mut cursor = node.walk();
2125                    let mut result = ::std::vec::Vec::new();
2126                    if cursor.goto_first_child() {
2127                        loop {
2128                            if cursor.field_name().is_none()
2129                                && cursor.node().is_named()
2130                                && !cursor.node().is_extra()
2131                            {
2132                                result.push(cursor.node());
2133                            }
2134                            if !cursor.goto_next_sibling() {
2135                                break;
2136                            }
2137                        }
2138                    }
2139                    result
2140                };
2141                match non_field_children.first() {
2142                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2143                        <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
2144                    })?),
2145                    None => None,
2146                }
2147            },
2148        })
2149    }
2150}
2151impl ::treesitter_types::Spanned for Break<'_> {
2152    fn span(&self) -> ::treesitter_types::Span {
2153        self.span
2154    }
2155}
2156#[derive(Debug, Clone, PartialEq, Eq)]
2157pub struct Call<'tree> {
2158    pub span: ::treesitter_types::Span,
2159    pub arguments: ::core::option::Option<ArgumentList<'tree>>,
2160    pub block: ::core::option::Option<CallBlock<'tree>>,
2161    pub method: ::core::option::Option<CallMethod<'tree>>,
2162    pub operator: ::core::option::Option<CallOperator>,
2163    pub receiver: ::core::option::Option<Primary<'tree>>,
2164}
2165impl<'tree> ::treesitter_types::FromNode<'tree> for Call<'tree> {
2166    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2167    fn from_node(
2168        node: ::treesitter_types::tree_sitter::Node<'tree>,
2169        src: &'tree [u8],
2170    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2171        debug_assert_eq!(node.kind(), "call");
2172        Ok(Self {
2173            span: ::treesitter_types::Span::from(node),
2174            arguments: match node.child_by_field_name("arguments") {
2175                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2176                    <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
2177                })?),
2178                None => None,
2179            },
2180            block: match node.child_by_field_name("block") {
2181                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2182                    <CallBlock as ::treesitter_types::FromNode>::from_node(child, src)
2183                })?),
2184                None => None,
2185            },
2186            method: match node.child_by_field_name("method") {
2187                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2188                    <CallMethod as ::treesitter_types::FromNode>::from_node(child, src)
2189                })?),
2190                None => None,
2191            },
2192            operator: match node.child_by_field_name("operator") {
2193                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2194                    <CallOperator as ::treesitter_types::FromNode>::from_node(child, src)
2195                })?),
2196                None => None,
2197            },
2198            receiver: match node.child_by_field_name("receiver") {
2199                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2200                    <Primary as ::treesitter_types::FromNode>::from_node(child, src)
2201                })?),
2202                None => None,
2203            },
2204        })
2205    }
2206}
2207impl ::treesitter_types::Spanned for Call<'_> {
2208    fn span(&self) -> ::treesitter_types::Span {
2209        self.span
2210    }
2211}
2212#[derive(Debug, Clone, PartialEq, Eq)]
2213pub struct Case<'tree> {
2214    pub span: ::treesitter_types::Span,
2215    pub value: ::core::option::Option<Statement<'tree>>,
2216    pub children: ::std::vec::Vec<CaseChildren<'tree>>,
2217}
2218impl<'tree> ::treesitter_types::FromNode<'tree> for Case<'tree> {
2219    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2220    fn from_node(
2221        node: ::treesitter_types::tree_sitter::Node<'tree>,
2222        src: &'tree [u8],
2223    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2224        debug_assert_eq!(node.kind(), "case");
2225        Ok(Self {
2226            span: ::treesitter_types::Span::from(node),
2227            value: match node.child_by_field_name("value") {
2228                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2229                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2230                })?),
2231                None => None,
2232            },
2233            children: {
2234                #[allow(clippy::suspicious_else_formatting)]
2235                let non_field_children = {
2236                    let mut cursor = node.walk();
2237                    let mut result = ::std::vec::Vec::new();
2238                    if cursor.goto_first_child() {
2239                        loop {
2240                            if cursor.field_name().is_none()
2241                                && cursor.node().is_named()
2242                                && !cursor.node().is_extra()
2243                            {
2244                                result.push(cursor.node());
2245                            }
2246                            if !cursor.goto_next_sibling() {
2247                                break;
2248                            }
2249                        }
2250                    }
2251                    result
2252                };
2253                let mut items = ::std::vec::Vec::new();
2254                for child in non_field_children {
2255                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2256                        <CaseChildren as ::treesitter_types::FromNode>::from_node(child, src)
2257                    })?);
2258                }
2259                items
2260            },
2261        })
2262    }
2263}
2264impl ::treesitter_types::Spanned for Case<'_> {
2265    fn span(&self) -> ::treesitter_types::Span {
2266        self.span
2267    }
2268}
2269#[derive(Debug, Clone, PartialEq, Eq)]
2270pub struct CaseMatch<'tree> {
2271    pub span: ::treesitter_types::Span,
2272    pub clauses: ::std::vec::Vec<InClause<'tree>>,
2273    pub r#else: ::core::option::Option<Else<'tree>>,
2274    pub value: Statement<'tree>,
2275}
2276impl<'tree> ::treesitter_types::FromNode<'tree> for CaseMatch<'tree> {
2277    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2278    fn from_node(
2279        node: ::treesitter_types::tree_sitter::Node<'tree>,
2280        src: &'tree [u8],
2281    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2282        debug_assert_eq!(node.kind(), "case_match");
2283        Ok(Self {
2284            span: ::treesitter_types::Span::from(node),
2285            clauses: {
2286                let mut cursor = node.walk();
2287                let mut items = ::std::vec::Vec::new();
2288                for child in node.children_by_field_name("clauses", &mut cursor) {
2289                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2290                        <InClause as ::treesitter_types::FromNode>::from_node(child, src)
2291                    })?);
2292                }
2293                items
2294            },
2295            r#else: match node.child_by_field_name("else") {
2296                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2297                    <Else as ::treesitter_types::FromNode>::from_node(child, src)
2298                })?),
2299                None => None,
2300            },
2301            value: {
2302                let child = node
2303                    .child_by_field_name("value")
2304                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2305                ::treesitter_types::runtime::maybe_grow_stack(|| {
2306                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2307                })?
2308            },
2309        })
2310    }
2311}
2312impl ::treesitter_types::Spanned for CaseMatch<'_> {
2313    fn span(&self) -> ::treesitter_types::Span {
2314        self.span
2315    }
2316}
2317#[derive(Debug, Clone, PartialEq, Eq)]
2318pub struct ChainedString<'tree> {
2319    pub span: ::treesitter_types::Span,
2320    pub children: ::std::vec::Vec<String<'tree>>,
2321}
2322impl<'tree> ::treesitter_types::FromNode<'tree> for ChainedString<'tree> {
2323    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2324    fn from_node(
2325        node: ::treesitter_types::tree_sitter::Node<'tree>,
2326        src: &'tree [u8],
2327    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2328        debug_assert_eq!(node.kind(), "chained_string");
2329        Ok(Self {
2330            span: ::treesitter_types::Span::from(node),
2331            children: {
2332                #[allow(clippy::suspicious_else_formatting)]
2333                let non_field_children = {
2334                    let mut cursor = node.walk();
2335                    let mut result = ::std::vec::Vec::new();
2336                    if cursor.goto_first_child() {
2337                        loop {
2338                            if cursor.field_name().is_none()
2339                                && cursor.node().is_named()
2340                                && !cursor.node().is_extra()
2341                            {
2342                                result.push(cursor.node());
2343                            }
2344                            if !cursor.goto_next_sibling() {
2345                                break;
2346                            }
2347                        }
2348                    }
2349                    result
2350                };
2351                let mut items = ::std::vec::Vec::new();
2352                for child in non_field_children {
2353                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2354                        <String as ::treesitter_types::FromNode>::from_node(child, src)
2355                    })?);
2356                }
2357                items
2358            },
2359        })
2360    }
2361}
2362impl ::treesitter_types::Spanned for ChainedString<'_> {
2363    fn span(&self) -> ::treesitter_types::Span {
2364        self.span
2365    }
2366}
2367#[derive(Debug, Clone, PartialEq, Eq)]
2368pub struct Class<'tree> {
2369    pub span: ::treesitter_types::Span,
2370    pub body: ::core::option::Option<BodyStatement<'tree>>,
2371    pub name: ClassName<'tree>,
2372    pub superclass: ::core::option::Option<Superclass<'tree>>,
2373}
2374impl<'tree> ::treesitter_types::FromNode<'tree> for Class<'tree> {
2375    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2376    fn from_node(
2377        node: ::treesitter_types::tree_sitter::Node<'tree>,
2378        src: &'tree [u8],
2379    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2380        debug_assert_eq!(node.kind(), "class");
2381        Ok(Self {
2382            span: ::treesitter_types::Span::from(node),
2383            body: match node.child_by_field_name("body") {
2384                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2385                    <BodyStatement as ::treesitter_types::FromNode>::from_node(child, src)
2386                })?),
2387                None => None,
2388            },
2389            name: {
2390                let child = node
2391                    .child_by_field_name("name")
2392                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2393                ::treesitter_types::runtime::maybe_grow_stack(|| {
2394                    <ClassName as ::treesitter_types::FromNode>::from_node(child, src)
2395                })?
2396            },
2397            superclass: match node.child_by_field_name("superclass") {
2398                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2399                    <Superclass as ::treesitter_types::FromNode>::from_node(child, src)
2400                })?),
2401                None => None,
2402            },
2403        })
2404    }
2405}
2406impl ::treesitter_types::Spanned for Class<'_> {
2407    fn span(&self) -> ::treesitter_types::Span {
2408        self.span
2409    }
2410}
2411#[derive(Debug, Clone, PartialEq, Eq)]
2412pub struct Complex<'tree> {
2413    pub span: ::treesitter_types::Span,
2414    pub children: ComplexChildren<'tree>,
2415}
2416impl<'tree> ::treesitter_types::FromNode<'tree> for Complex<'tree> {
2417    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2418    fn from_node(
2419        node: ::treesitter_types::tree_sitter::Node<'tree>,
2420        src: &'tree [u8],
2421    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2422        debug_assert_eq!(node.kind(), "complex");
2423        Ok(Self {
2424            span: ::treesitter_types::Span::from(node),
2425            children: {
2426                #[allow(clippy::suspicious_else_formatting)]
2427                let non_field_children = {
2428                    let mut cursor = node.walk();
2429                    let mut result = ::std::vec::Vec::new();
2430                    if cursor.goto_first_child() {
2431                        loop {
2432                            if cursor.field_name().is_none()
2433                                && cursor.node().is_named()
2434                                && !cursor.node().is_extra()
2435                            {
2436                                result.push(cursor.node());
2437                            }
2438                            if !cursor.goto_next_sibling() {
2439                                break;
2440                            }
2441                        }
2442                    }
2443                    result
2444                };
2445                let child = if let Some(&c) = non_field_children.first() {
2446                    c
2447                } else {
2448                    let mut fallback_cursor = node.walk();
2449                    let mut fallback_child = None;
2450                    if fallback_cursor.goto_first_child() {
2451                        loop {
2452                            if fallback_cursor.field_name().is_none()
2453                                && !fallback_cursor.node().is_extra()
2454                            {
2455                                let candidate = fallback_cursor.node();
2456                                #[allow(clippy::needless_question_mark)]
2457                                if (|| -> ::core::result::Result<
2458                                    _,
2459                                    ::treesitter_types::ParseError,
2460                                > {
2461                                    let child = candidate;
2462                                    Ok(
2463                                        ::treesitter_types::runtime::maybe_grow_stack(|| <ComplexChildren as ::treesitter_types::FromNode>::from_node(
2464                                            child,
2465                                            src,
2466                                        ))?,
2467                                    )
2468                                })()
2469                                    .is_ok()
2470                                {
2471                                    fallback_child = Some(candidate);
2472                                    break;
2473                                }
2474                            }
2475                            if !fallback_cursor.goto_next_sibling() {
2476                                break;
2477                            }
2478                        }
2479                    }
2480                    if fallback_child.is_none() {
2481                        let mut cursor2 = node.walk();
2482                        if cursor2.goto_first_child() {
2483                            loop {
2484                                if cursor2.node().is_named() && !cursor2.node().is_extra() {
2485                                    let candidate = cursor2.node();
2486                                    #[allow(clippy::needless_question_mark)]
2487                                    if (|| -> ::core::result::Result<
2488                                        _,
2489                                        ::treesitter_types::ParseError,
2490                                    > {
2491                                        let child = candidate;
2492                                        Ok(
2493                                            ::treesitter_types::runtime::maybe_grow_stack(|| <ComplexChildren as ::treesitter_types::FromNode>::from_node(
2494                                                child,
2495                                                src,
2496                                            ))?,
2497                                        )
2498                                    })()
2499                                        .is_ok()
2500                                    {
2501                                        fallback_child = Some(candidate);
2502                                        break;
2503                                    }
2504                                }
2505                                if !cursor2.goto_next_sibling() {
2506                                    break;
2507                                }
2508                            }
2509                        }
2510                    }
2511                    fallback_child.ok_or_else(|| {
2512                        ::treesitter_types::ParseError::missing_field("children", node)
2513                    })?
2514                };
2515                ::treesitter_types::runtime::maybe_grow_stack(|| {
2516                    <ComplexChildren as ::treesitter_types::FromNode>::from_node(child, src)
2517                })?
2518            },
2519        })
2520    }
2521}
2522impl ::treesitter_types::Spanned for Complex<'_> {
2523    fn span(&self) -> ::treesitter_types::Span {
2524        self.span
2525    }
2526}
2527#[derive(Debug, Clone, PartialEq, Eq)]
2528pub struct Conditional<'tree> {
2529    pub span: ::treesitter_types::Span,
2530    pub alternative: Arg<'tree>,
2531    pub condition: Arg<'tree>,
2532    pub consequence: Arg<'tree>,
2533}
2534impl<'tree> ::treesitter_types::FromNode<'tree> for Conditional<'tree> {
2535    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2536    fn from_node(
2537        node: ::treesitter_types::tree_sitter::Node<'tree>,
2538        src: &'tree [u8],
2539    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2540        debug_assert_eq!(node.kind(), "conditional");
2541        Ok(Self {
2542            span: ::treesitter_types::Span::from(node),
2543            alternative: {
2544                let child = node.child_by_field_name("alternative").ok_or_else(|| {
2545                    ::treesitter_types::ParseError::missing_field("alternative", node)
2546                })?;
2547                ::treesitter_types::runtime::maybe_grow_stack(|| {
2548                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
2549                })?
2550            },
2551            condition: {
2552                let child = node.child_by_field_name("condition").ok_or_else(|| {
2553                    ::treesitter_types::ParseError::missing_field("condition", node)
2554                })?;
2555                ::treesitter_types::runtime::maybe_grow_stack(|| {
2556                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
2557                })?
2558            },
2559            consequence: {
2560                let child = node.child_by_field_name("consequence").ok_or_else(|| {
2561                    ::treesitter_types::ParseError::missing_field("consequence", node)
2562                })?;
2563                ::treesitter_types::runtime::maybe_grow_stack(|| {
2564                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
2565                })?
2566            },
2567        })
2568    }
2569}
2570impl ::treesitter_types::Spanned for Conditional<'_> {
2571    fn span(&self) -> ::treesitter_types::Span {
2572        self.span
2573    }
2574}
2575#[derive(Debug, Clone, PartialEq, Eq)]
2576pub struct Constant<'tree> {
2577    pub span: ::treesitter_types::Span,
2578    text: &'tree str,
2579}
2580impl<'tree> ::treesitter_types::FromNode<'tree> for Constant<'tree> {
2581    fn from_node(
2582        node: ::treesitter_types::tree_sitter::Node<'tree>,
2583        src: &'tree [u8],
2584    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2585        debug_assert_eq!(node.kind(), "constant");
2586        Ok(Self {
2587            span: ::treesitter_types::Span::from(node),
2588            text: node.utf8_text(src)?,
2589        })
2590    }
2591}
2592impl<'tree> ::treesitter_types::LeafNode<'tree> for Constant<'tree> {
2593    fn text(&self) -> &'tree str {
2594        self.text
2595    }
2596}
2597impl ::treesitter_types::Spanned for Constant<'_> {
2598    fn span(&self) -> ::treesitter_types::Span {
2599        self.span
2600    }
2601}
2602#[derive(Debug, Clone, PartialEq, Eq)]
2603pub struct DelimitedSymbol<'tree> {
2604    pub span: ::treesitter_types::Span,
2605    pub children: ::std::vec::Vec<DelimitedSymbolChildren<'tree>>,
2606}
2607impl<'tree> ::treesitter_types::FromNode<'tree> for DelimitedSymbol<'tree> {
2608    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2609    fn from_node(
2610        node: ::treesitter_types::tree_sitter::Node<'tree>,
2611        src: &'tree [u8],
2612    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2613        debug_assert_eq!(node.kind(), "delimited_symbol");
2614        Ok(Self {
2615            span: ::treesitter_types::Span::from(node),
2616            children: {
2617                #[allow(clippy::suspicious_else_formatting)]
2618                let non_field_children = {
2619                    let mut cursor = node.walk();
2620                    let mut result = ::std::vec::Vec::new();
2621                    if cursor.goto_first_child() {
2622                        loop {
2623                            if cursor.field_name().is_none()
2624                                && cursor.node().is_named()
2625                                && !cursor.node().is_extra()
2626                            {
2627                                result.push(cursor.node());
2628                            }
2629                            if !cursor.goto_next_sibling() {
2630                                break;
2631                            }
2632                        }
2633                    }
2634                    result
2635                };
2636                let mut items = ::std::vec::Vec::new();
2637                for child in non_field_children {
2638                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2639                        <DelimitedSymbolChildren as ::treesitter_types::FromNode>::from_node(
2640                            child, src,
2641                        )
2642                    })?);
2643                }
2644                items
2645            },
2646        })
2647    }
2648}
2649impl ::treesitter_types::Spanned for DelimitedSymbol<'_> {
2650    fn span(&self) -> ::treesitter_types::Span {
2651        self.span
2652    }
2653}
2654#[derive(Debug, Clone, PartialEq, Eq)]
2655pub struct DestructuredLeftAssignment<'tree> {
2656    pub span: ::treesitter_types::Span,
2657    pub children: ::std::vec::Vec<DestructuredLeftAssignmentChildren<'tree>>,
2658}
2659impl<'tree> ::treesitter_types::FromNode<'tree> for DestructuredLeftAssignment<'tree> {
2660    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2661    fn from_node(
2662        node: ::treesitter_types::tree_sitter::Node<'tree>,
2663        src: &'tree [u8],
2664    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2665        debug_assert_eq!(node.kind(), "destructured_left_assignment");
2666        Ok(Self {
2667            span: ::treesitter_types::Span::from(node),
2668            children: {
2669                #[allow(clippy::suspicious_else_formatting)]
2670                let non_field_children = {
2671                    let mut cursor = node.walk();
2672                    let mut result = ::std::vec::Vec::new();
2673                    if cursor.goto_first_child() {
2674                        loop {
2675                            if cursor.field_name().is_none()
2676                                && cursor.node().is_named()
2677                                && !cursor.node().is_extra()
2678                            {
2679                                result.push(cursor.node());
2680                            }
2681                            if !cursor.goto_next_sibling() {
2682                                break;
2683                            }
2684                        }
2685                    }
2686                    result
2687                };
2688                let mut items = ::std::vec::Vec::new();
2689                for child in non_field_children {
2690                    items
2691                        .push(
2692                            ::treesitter_types::runtime::maybe_grow_stack(|| <DestructuredLeftAssignmentChildren as ::treesitter_types::FromNode>::from_node(
2693                                child,
2694                                src,
2695                            ))?,
2696                        );
2697                }
2698                items
2699            },
2700        })
2701    }
2702}
2703impl ::treesitter_types::Spanned for DestructuredLeftAssignment<'_> {
2704    fn span(&self) -> ::treesitter_types::Span {
2705        self.span
2706    }
2707}
2708#[derive(Debug, Clone, PartialEq, Eq)]
2709pub struct DestructuredParameter<'tree> {
2710    pub span: ::treesitter_types::Span,
2711    pub children: ::std::vec::Vec<DestructuredParameterChildren<'tree>>,
2712}
2713impl<'tree> ::treesitter_types::FromNode<'tree> for DestructuredParameter<'tree> {
2714    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2715    fn from_node(
2716        node: ::treesitter_types::tree_sitter::Node<'tree>,
2717        src: &'tree [u8],
2718    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2719        debug_assert_eq!(node.kind(), "destructured_parameter");
2720        Ok(Self {
2721            span: ::treesitter_types::Span::from(node),
2722            children: {
2723                #[allow(clippy::suspicious_else_formatting)]
2724                let non_field_children = {
2725                    let mut cursor = node.walk();
2726                    let mut result = ::std::vec::Vec::new();
2727                    if cursor.goto_first_child() {
2728                        loop {
2729                            if cursor.field_name().is_none()
2730                                && cursor.node().is_named()
2731                                && !cursor.node().is_extra()
2732                            {
2733                                result.push(cursor.node());
2734                            }
2735                            if !cursor.goto_next_sibling() {
2736                                break;
2737                            }
2738                        }
2739                    }
2740                    result
2741                };
2742                let mut items = ::std::vec::Vec::new();
2743                for child in non_field_children {
2744                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2745                        <DestructuredParameterChildren as ::treesitter_types::FromNode>::from_node(
2746                            child, src,
2747                        )
2748                    })?);
2749                }
2750                items
2751            },
2752        })
2753    }
2754}
2755impl ::treesitter_types::Spanned for DestructuredParameter<'_> {
2756    fn span(&self) -> ::treesitter_types::Span {
2757        self.span
2758    }
2759}
2760#[derive(Debug, Clone, PartialEq, Eq)]
2761pub struct Do<'tree> {
2762    pub span: ::treesitter_types::Span,
2763    pub children: ::std::vec::Vec<DoChildren<'tree>>,
2764}
2765impl<'tree> ::treesitter_types::FromNode<'tree> for Do<'tree> {
2766    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2767    fn from_node(
2768        node: ::treesitter_types::tree_sitter::Node<'tree>,
2769        src: &'tree [u8],
2770    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2771        debug_assert_eq!(node.kind(), "do");
2772        Ok(Self {
2773            span: ::treesitter_types::Span::from(node),
2774            children: {
2775                #[allow(clippy::suspicious_else_formatting)]
2776                let non_field_children = {
2777                    let mut cursor = node.walk();
2778                    let mut result = ::std::vec::Vec::new();
2779                    if cursor.goto_first_child() {
2780                        loop {
2781                            if cursor.field_name().is_none()
2782                                && cursor.node().is_named()
2783                                && !cursor.node().is_extra()
2784                            {
2785                                result.push(cursor.node());
2786                            }
2787                            if !cursor.goto_next_sibling() {
2788                                break;
2789                            }
2790                        }
2791                    }
2792                    result
2793                };
2794                let mut items = ::std::vec::Vec::new();
2795                for child in non_field_children {
2796                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2797                        <DoChildren as ::treesitter_types::FromNode>::from_node(child, src)
2798                    })?);
2799                }
2800                items
2801            },
2802        })
2803    }
2804}
2805impl ::treesitter_types::Spanned for Do<'_> {
2806    fn span(&self) -> ::treesitter_types::Span {
2807        self.span
2808    }
2809}
2810#[derive(Debug, Clone, PartialEq, Eq)]
2811pub struct DoBlock<'tree> {
2812    pub span: ::treesitter_types::Span,
2813    pub body: ::core::option::Option<BodyStatement<'tree>>,
2814    pub parameters: ::core::option::Option<BlockParameters<'tree>>,
2815}
2816impl<'tree> ::treesitter_types::FromNode<'tree> for DoBlock<'tree> {
2817    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2818    fn from_node(
2819        node: ::treesitter_types::tree_sitter::Node<'tree>,
2820        src: &'tree [u8],
2821    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2822        debug_assert_eq!(node.kind(), "do_block");
2823        Ok(Self {
2824            span: ::treesitter_types::Span::from(node),
2825            body: match node.child_by_field_name("body") {
2826                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2827                    <BodyStatement as ::treesitter_types::FromNode>::from_node(child, src)
2828                })?),
2829                None => None,
2830            },
2831            parameters: match node.child_by_field_name("parameters") {
2832                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2833                    <BlockParameters as ::treesitter_types::FromNode>::from_node(child, src)
2834                })?),
2835                None => None,
2836            },
2837        })
2838    }
2839}
2840impl ::treesitter_types::Spanned for DoBlock<'_> {
2841    fn span(&self) -> ::treesitter_types::Span {
2842        self.span
2843    }
2844}
2845#[derive(Debug, Clone, PartialEq, Eq)]
2846pub struct ElementReference<'tree> {
2847    pub span: ::treesitter_types::Span,
2848    pub block: ::core::option::Option<ElementReferenceBlock<'tree>>,
2849    pub object: Primary<'tree>,
2850    pub children: ::std::vec::Vec<ElementReferenceChildren<'tree>>,
2851}
2852impl<'tree> ::treesitter_types::FromNode<'tree> for ElementReference<'tree> {
2853    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2854    fn from_node(
2855        node: ::treesitter_types::tree_sitter::Node<'tree>,
2856        src: &'tree [u8],
2857    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2858        debug_assert_eq!(node.kind(), "element_reference");
2859        Ok(Self {
2860            span: ::treesitter_types::Span::from(node),
2861            block: match node.child_by_field_name("block") {
2862                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2863                    <ElementReferenceBlock as ::treesitter_types::FromNode>::from_node(child, src)
2864                })?),
2865                None => None,
2866            },
2867            object: {
2868                let child = node
2869                    .child_by_field_name("object")
2870                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
2871                ::treesitter_types::runtime::maybe_grow_stack(|| {
2872                    <Primary as ::treesitter_types::FromNode>::from_node(child, src)
2873                })?
2874            },
2875            children: {
2876                #[allow(clippy::suspicious_else_formatting)]
2877                let non_field_children = {
2878                    let mut cursor = node.walk();
2879                    let mut result = ::std::vec::Vec::new();
2880                    if cursor.goto_first_child() {
2881                        loop {
2882                            if cursor.field_name().is_none()
2883                                && cursor.node().is_named()
2884                                && !cursor.node().is_extra()
2885                            {
2886                                result.push(cursor.node());
2887                            }
2888                            if !cursor.goto_next_sibling() {
2889                                break;
2890                            }
2891                        }
2892                    }
2893                    result
2894                };
2895                let mut items = ::std::vec::Vec::new();
2896                for child in non_field_children {
2897                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2898                        <ElementReferenceChildren as ::treesitter_types::FromNode>::from_node(
2899                            child, src,
2900                        )
2901                    })?);
2902                }
2903                items
2904            },
2905        })
2906    }
2907}
2908impl ::treesitter_types::Spanned for ElementReference<'_> {
2909    fn span(&self) -> ::treesitter_types::Span {
2910        self.span
2911    }
2912}
2913#[derive(Debug, Clone, PartialEq, Eq)]
2914pub struct Else<'tree> {
2915    pub span: ::treesitter_types::Span,
2916    pub children: ::std::vec::Vec<ElseChildren<'tree>>,
2917}
2918impl<'tree> ::treesitter_types::FromNode<'tree> for Else<'tree> {
2919    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2920    fn from_node(
2921        node: ::treesitter_types::tree_sitter::Node<'tree>,
2922        src: &'tree [u8],
2923    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2924        debug_assert_eq!(node.kind(), "else");
2925        Ok(Self {
2926            span: ::treesitter_types::Span::from(node),
2927            children: {
2928                #[allow(clippy::suspicious_else_formatting)]
2929                let non_field_children = {
2930                    let mut cursor = node.walk();
2931                    let mut result = ::std::vec::Vec::new();
2932                    if cursor.goto_first_child() {
2933                        loop {
2934                            if cursor.field_name().is_none()
2935                                && cursor.node().is_named()
2936                                && !cursor.node().is_extra()
2937                            {
2938                                result.push(cursor.node());
2939                            }
2940                            if !cursor.goto_next_sibling() {
2941                                break;
2942                            }
2943                        }
2944                    }
2945                    result
2946                };
2947                let mut items = ::std::vec::Vec::new();
2948                for child in non_field_children {
2949                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2950                        <ElseChildren as ::treesitter_types::FromNode>::from_node(child, src)
2951                    })?);
2952                }
2953                items
2954            },
2955        })
2956    }
2957}
2958impl ::treesitter_types::Spanned for Else<'_> {
2959    fn span(&self) -> ::treesitter_types::Span {
2960        self.span
2961    }
2962}
2963#[derive(Debug, Clone, PartialEq, Eq)]
2964pub struct Elsif<'tree> {
2965    pub span: ::treesitter_types::Span,
2966    pub alternative: ::core::option::Option<ElsifAlternative<'tree>>,
2967    pub condition: Statement<'tree>,
2968    pub consequence: ::core::option::Option<Then<'tree>>,
2969}
2970impl<'tree> ::treesitter_types::FromNode<'tree> for Elsif<'tree> {
2971    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2972    fn from_node(
2973        node: ::treesitter_types::tree_sitter::Node<'tree>,
2974        src: &'tree [u8],
2975    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2976        debug_assert_eq!(node.kind(), "elsif");
2977        Ok(Self {
2978            span: ::treesitter_types::Span::from(node),
2979            alternative: match node.child_by_field_name("alternative") {
2980                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2981                    <ElsifAlternative as ::treesitter_types::FromNode>::from_node(child, src)
2982                })?),
2983                None => None,
2984            },
2985            condition: {
2986                let child = node.child_by_field_name("condition").ok_or_else(|| {
2987                    ::treesitter_types::ParseError::missing_field("condition", node)
2988                })?;
2989                ::treesitter_types::runtime::maybe_grow_stack(|| {
2990                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2991                })?
2992            },
2993            consequence: match node.child_by_field_name("consequence") {
2994                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2995                    <Then as ::treesitter_types::FromNode>::from_node(child, src)
2996                })?),
2997                None => None,
2998            },
2999        })
3000    }
3001}
3002impl ::treesitter_types::Spanned for Elsif<'_> {
3003    fn span(&self) -> ::treesitter_types::Span {
3004        self.span
3005    }
3006}
3007#[derive(Debug, Clone, PartialEq, Eq)]
3008pub struct EmptyStatement<'tree> {
3009    pub span: ::treesitter_types::Span,
3010    text: &'tree str,
3011}
3012impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
3013    fn from_node(
3014        node: ::treesitter_types::tree_sitter::Node<'tree>,
3015        src: &'tree [u8],
3016    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3017        debug_assert_eq!(node.kind(), "empty_statement");
3018        Ok(Self {
3019            span: ::treesitter_types::Span::from(node),
3020            text: node.utf8_text(src)?,
3021        })
3022    }
3023}
3024impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
3025    fn text(&self) -> &'tree str {
3026        self.text
3027    }
3028}
3029impl ::treesitter_types::Spanned for EmptyStatement<'_> {
3030    fn span(&self) -> ::treesitter_types::Span {
3031        self.span
3032    }
3033}
3034#[derive(Debug, Clone, PartialEq, Eq)]
3035pub struct EndBlock<'tree> {
3036    pub span: ::treesitter_types::Span,
3037    pub children: ::std::vec::Vec<EndBlockChildren<'tree>>,
3038}
3039impl<'tree> ::treesitter_types::FromNode<'tree> for EndBlock<'tree> {
3040    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3041    fn from_node(
3042        node: ::treesitter_types::tree_sitter::Node<'tree>,
3043        src: &'tree [u8],
3044    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3045        debug_assert_eq!(node.kind(), "end_block");
3046        Ok(Self {
3047            span: ::treesitter_types::Span::from(node),
3048            children: {
3049                #[allow(clippy::suspicious_else_formatting)]
3050                let non_field_children = {
3051                    let mut cursor = node.walk();
3052                    let mut result = ::std::vec::Vec::new();
3053                    if cursor.goto_first_child() {
3054                        loop {
3055                            if cursor.field_name().is_none()
3056                                && cursor.node().is_named()
3057                                && !cursor.node().is_extra()
3058                            {
3059                                result.push(cursor.node());
3060                            }
3061                            if !cursor.goto_next_sibling() {
3062                                break;
3063                            }
3064                        }
3065                    }
3066                    result
3067                };
3068                let mut items = ::std::vec::Vec::new();
3069                for child in non_field_children {
3070                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3071                        <EndBlockChildren as ::treesitter_types::FromNode>::from_node(child, src)
3072                    })?);
3073                }
3074                items
3075            },
3076        })
3077    }
3078}
3079impl ::treesitter_types::Spanned for EndBlock<'_> {
3080    fn span(&self) -> ::treesitter_types::Span {
3081        self.span
3082    }
3083}
3084#[derive(Debug, Clone, PartialEq, Eq)]
3085pub struct Ensure<'tree> {
3086    pub span: ::treesitter_types::Span,
3087    pub children: ::std::vec::Vec<EnsureChildren<'tree>>,
3088}
3089impl<'tree> ::treesitter_types::FromNode<'tree> for Ensure<'tree> {
3090    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3091    fn from_node(
3092        node: ::treesitter_types::tree_sitter::Node<'tree>,
3093        src: &'tree [u8],
3094    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3095        debug_assert_eq!(node.kind(), "ensure");
3096        Ok(Self {
3097            span: ::treesitter_types::Span::from(node),
3098            children: {
3099                #[allow(clippy::suspicious_else_formatting)]
3100                let non_field_children = {
3101                    let mut cursor = node.walk();
3102                    let mut result = ::std::vec::Vec::new();
3103                    if cursor.goto_first_child() {
3104                        loop {
3105                            if cursor.field_name().is_none()
3106                                && cursor.node().is_named()
3107                                && !cursor.node().is_extra()
3108                            {
3109                                result.push(cursor.node());
3110                            }
3111                            if !cursor.goto_next_sibling() {
3112                                break;
3113                            }
3114                        }
3115                    }
3116                    result
3117                };
3118                let mut items = ::std::vec::Vec::new();
3119                for child in non_field_children {
3120                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3121                        <EnsureChildren as ::treesitter_types::FromNode>::from_node(child, src)
3122                    })?);
3123                }
3124                items
3125            },
3126        })
3127    }
3128}
3129impl ::treesitter_types::Spanned for Ensure<'_> {
3130    fn span(&self) -> ::treesitter_types::Span {
3131        self.span
3132    }
3133}
3134#[derive(Debug, Clone, PartialEq, Eq)]
3135pub struct ExceptionVariable<'tree> {
3136    pub span: ::treesitter_types::Span,
3137    pub children: Lhs<'tree>,
3138}
3139impl<'tree> ::treesitter_types::FromNode<'tree> for ExceptionVariable<'tree> {
3140    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3141    fn from_node(
3142        node: ::treesitter_types::tree_sitter::Node<'tree>,
3143        src: &'tree [u8],
3144    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3145        debug_assert_eq!(node.kind(), "exception_variable");
3146        Ok(Self {
3147            span: ::treesitter_types::Span::from(node),
3148            children: {
3149                #[allow(clippy::suspicious_else_formatting)]
3150                let non_field_children = {
3151                    let mut cursor = node.walk();
3152                    let mut result = ::std::vec::Vec::new();
3153                    if cursor.goto_first_child() {
3154                        loop {
3155                            if cursor.field_name().is_none()
3156                                && cursor.node().is_named()
3157                                && !cursor.node().is_extra()
3158                            {
3159                                result.push(cursor.node());
3160                            }
3161                            if !cursor.goto_next_sibling() {
3162                                break;
3163                            }
3164                        }
3165                    }
3166                    result
3167                };
3168                let child = if let Some(&c) = non_field_children.first() {
3169                    c
3170                } else {
3171                    let mut fallback_cursor = node.walk();
3172                    let mut fallback_child = None;
3173                    if fallback_cursor.goto_first_child() {
3174                        loop {
3175                            if fallback_cursor.field_name().is_none()
3176                                && !fallback_cursor.node().is_extra()
3177                            {
3178                                let candidate = fallback_cursor.node();
3179                                #[allow(clippy::needless_question_mark)]
3180                                if (|| -> ::core::result::Result<
3181                                    _,
3182                                    ::treesitter_types::ParseError,
3183                                > {
3184                                    let child = candidate;
3185                                    Ok(
3186                                        ::treesitter_types::runtime::maybe_grow_stack(|| <Lhs as ::treesitter_types::FromNode>::from_node(
3187                                            child,
3188                                            src,
3189                                        ))?,
3190                                    )
3191                                })()
3192                                    .is_ok()
3193                                {
3194                                    fallback_child = Some(candidate);
3195                                    break;
3196                                }
3197                            }
3198                            if !fallback_cursor.goto_next_sibling() {
3199                                break;
3200                            }
3201                        }
3202                    }
3203                    if fallback_child.is_none() {
3204                        let mut cursor2 = node.walk();
3205                        if cursor2.goto_first_child() {
3206                            loop {
3207                                if cursor2.node().is_named() && !cursor2.node().is_extra() {
3208                                    let candidate = cursor2.node();
3209                                    #[allow(clippy::needless_question_mark)]
3210                                    if (|| -> ::core::result::Result<
3211                                        _,
3212                                        ::treesitter_types::ParseError,
3213                                    > {
3214                                        let child = candidate;
3215                                        Ok(
3216                                            ::treesitter_types::runtime::maybe_grow_stack(|| <Lhs as ::treesitter_types::FromNode>::from_node(
3217                                                child,
3218                                                src,
3219                                            ))?,
3220                                        )
3221                                    })()
3222                                        .is_ok()
3223                                    {
3224                                        fallback_child = Some(candidate);
3225                                        break;
3226                                    }
3227                                }
3228                                if !cursor2.goto_next_sibling() {
3229                                    break;
3230                                }
3231                            }
3232                        }
3233                    }
3234                    fallback_child.ok_or_else(|| {
3235                        ::treesitter_types::ParseError::missing_field("children", node)
3236                    })?
3237                };
3238                ::treesitter_types::runtime::maybe_grow_stack(|| {
3239                    <Lhs as ::treesitter_types::FromNode>::from_node(child, src)
3240                })?
3241            },
3242        })
3243    }
3244}
3245impl ::treesitter_types::Spanned for ExceptionVariable<'_> {
3246    fn span(&self) -> ::treesitter_types::Span {
3247        self.span
3248    }
3249}
3250#[derive(Debug, Clone, PartialEq, Eq)]
3251pub struct Exceptions<'tree> {
3252    pub span: ::treesitter_types::Span,
3253    pub children: ::std::vec::Vec<ExceptionsChildren<'tree>>,
3254}
3255impl<'tree> ::treesitter_types::FromNode<'tree> for Exceptions<'tree> {
3256    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3257    fn from_node(
3258        node: ::treesitter_types::tree_sitter::Node<'tree>,
3259        src: &'tree [u8],
3260    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3261        debug_assert_eq!(node.kind(), "exceptions");
3262        Ok(Self {
3263            span: ::treesitter_types::Span::from(node),
3264            children: {
3265                #[allow(clippy::suspicious_else_formatting)]
3266                let non_field_children = {
3267                    let mut cursor = node.walk();
3268                    let mut result = ::std::vec::Vec::new();
3269                    if cursor.goto_first_child() {
3270                        loop {
3271                            if cursor.field_name().is_none()
3272                                && cursor.node().is_named()
3273                                && !cursor.node().is_extra()
3274                            {
3275                                result.push(cursor.node());
3276                            }
3277                            if !cursor.goto_next_sibling() {
3278                                break;
3279                            }
3280                        }
3281                    }
3282                    result
3283                };
3284                let mut items = ::std::vec::Vec::new();
3285                for child in non_field_children {
3286                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3287                        <ExceptionsChildren as ::treesitter_types::FromNode>::from_node(child, src)
3288                    })?);
3289                }
3290                items
3291            },
3292        })
3293    }
3294}
3295impl ::treesitter_types::Spanned for Exceptions<'_> {
3296    fn span(&self) -> ::treesitter_types::Span {
3297        self.span
3298    }
3299}
3300#[derive(Debug, Clone, PartialEq, Eq)]
3301pub struct ExpressionReferencePattern<'tree> {
3302    pub span: ::treesitter_types::Span,
3303    pub value: Expression<'tree>,
3304}
3305impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionReferencePattern<'tree> {
3306    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3307    fn from_node(
3308        node: ::treesitter_types::tree_sitter::Node<'tree>,
3309        src: &'tree [u8],
3310    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3311        debug_assert_eq!(node.kind(), "expression_reference_pattern");
3312        Ok(Self {
3313            span: ::treesitter_types::Span::from(node),
3314            value: {
3315                let child = node
3316                    .child_by_field_name("value")
3317                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3318                ::treesitter_types::runtime::maybe_grow_stack(|| {
3319                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3320                })?
3321            },
3322        })
3323    }
3324}
3325impl ::treesitter_types::Spanned for ExpressionReferencePattern<'_> {
3326    fn span(&self) -> ::treesitter_types::Span {
3327        self.span
3328    }
3329}
3330#[derive(Debug, Clone, PartialEq, Eq)]
3331pub struct FindPattern<'tree> {
3332    pub span: ::treesitter_types::Span,
3333    pub class: ::core::option::Option<PatternConstant<'tree>>,
3334    pub children: ::std::vec::Vec<FindPatternChildren<'tree>>,
3335}
3336impl<'tree> ::treesitter_types::FromNode<'tree> for FindPattern<'tree> {
3337    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3338    fn from_node(
3339        node: ::treesitter_types::tree_sitter::Node<'tree>,
3340        src: &'tree [u8],
3341    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3342        debug_assert_eq!(node.kind(), "find_pattern");
3343        Ok(Self {
3344            span: ::treesitter_types::Span::from(node),
3345            class: match node.child_by_field_name("class") {
3346                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3347                    <PatternConstant as ::treesitter_types::FromNode>::from_node(child, src)
3348                })?),
3349                None => None,
3350            },
3351            children: {
3352                #[allow(clippy::suspicious_else_formatting)]
3353                let non_field_children = {
3354                    let mut cursor = node.walk();
3355                    let mut result = ::std::vec::Vec::new();
3356                    if cursor.goto_first_child() {
3357                        loop {
3358                            if cursor.field_name().is_none()
3359                                && cursor.node().is_named()
3360                                && !cursor.node().is_extra()
3361                            {
3362                                result.push(cursor.node());
3363                            }
3364                            if !cursor.goto_next_sibling() {
3365                                break;
3366                            }
3367                        }
3368                    }
3369                    result
3370                };
3371                let mut items = ::std::vec::Vec::new();
3372                for child in non_field_children {
3373                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3374                        <FindPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
3375                    })?);
3376                }
3377                items
3378            },
3379        })
3380    }
3381}
3382impl ::treesitter_types::Spanned for FindPattern<'_> {
3383    fn span(&self) -> ::treesitter_types::Span {
3384        self.span
3385    }
3386}
3387#[derive(Debug, Clone, PartialEq, Eq)]
3388pub struct For<'tree> {
3389    pub span: ::treesitter_types::Span,
3390    pub body: Do<'tree>,
3391    pub pattern: ForPattern<'tree>,
3392    pub value: In<'tree>,
3393}
3394impl<'tree> ::treesitter_types::FromNode<'tree> for For<'tree> {
3395    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3396    fn from_node(
3397        node: ::treesitter_types::tree_sitter::Node<'tree>,
3398        src: &'tree [u8],
3399    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3400        debug_assert_eq!(node.kind(), "for");
3401        Ok(Self {
3402            span: ::treesitter_types::Span::from(node),
3403            body: {
3404                let child = node
3405                    .child_by_field_name("body")
3406                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3407                ::treesitter_types::runtime::maybe_grow_stack(|| {
3408                    <Do as ::treesitter_types::FromNode>::from_node(child, src)
3409                })?
3410            },
3411            pattern: {
3412                let child = node.child_by_field_name("pattern").ok_or_else(|| {
3413                    ::treesitter_types::ParseError::missing_field("pattern", node)
3414                })?;
3415                ::treesitter_types::runtime::maybe_grow_stack(|| {
3416                    <ForPattern as ::treesitter_types::FromNode>::from_node(child, src)
3417                })?
3418            },
3419            value: {
3420                let child = node
3421                    .child_by_field_name("value")
3422                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3423                ::treesitter_types::runtime::maybe_grow_stack(|| {
3424                    <In as ::treesitter_types::FromNode>::from_node(child, src)
3425                })?
3426            },
3427        })
3428    }
3429}
3430impl ::treesitter_types::Spanned for For<'_> {
3431    fn span(&self) -> ::treesitter_types::Span {
3432        self.span
3433    }
3434}
3435#[derive(Debug, Clone, PartialEq, Eq)]
3436pub struct ForwardArgument<'tree> {
3437    pub span: ::treesitter_types::Span,
3438    text: &'tree str,
3439}
3440impl<'tree> ::treesitter_types::FromNode<'tree> for ForwardArgument<'tree> {
3441    fn from_node(
3442        node: ::treesitter_types::tree_sitter::Node<'tree>,
3443        src: &'tree [u8],
3444    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3445        debug_assert_eq!(node.kind(), "forward_argument");
3446        Ok(Self {
3447            span: ::treesitter_types::Span::from(node),
3448            text: node.utf8_text(src)?,
3449        })
3450    }
3451}
3452impl<'tree> ::treesitter_types::LeafNode<'tree> for ForwardArgument<'tree> {
3453    fn text(&self) -> &'tree str {
3454        self.text
3455    }
3456}
3457impl ::treesitter_types::Spanned for ForwardArgument<'_> {
3458    fn span(&self) -> ::treesitter_types::Span {
3459        self.span
3460    }
3461}
3462#[derive(Debug, Clone, PartialEq, Eq)]
3463pub struct ForwardParameter<'tree> {
3464    pub span: ::treesitter_types::Span,
3465    text: &'tree str,
3466}
3467impl<'tree> ::treesitter_types::FromNode<'tree> for ForwardParameter<'tree> {
3468    fn from_node(
3469        node: ::treesitter_types::tree_sitter::Node<'tree>,
3470        src: &'tree [u8],
3471    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3472        debug_assert_eq!(node.kind(), "forward_parameter");
3473        Ok(Self {
3474            span: ::treesitter_types::Span::from(node),
3475            text: node.utf8_text(src)?,
3476        })
3477    }
3478}
3479impl<'tree> ::treesitter_types::LeafNode<'tree> for ForwardParameter<'tree> {
3480    fn text(&self) -> &'tree str {
3481        self.text
3482    }
3483}
3484impl ::treesitter_types::Spanned for ForwardParameter<'_> {
3485    fn span(&self) -> ::treesitter_types::Span {
3486        self.span
3487    }
3488}
3489#[derive(Debug, Clone, PartialEq, Eq)]
3490pub struct Hash<'tree> {
3491    pub span: ::treesitter_types::Span,
3492    pub children: ::std::vec::Vec<HashChildren<'tree>>,
3493}
3494impl<'tree> ::treesitter_types::FromNode<'tree> for Hash<'tree> {
3495    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3496    fn from_node(
3497        node: ::treesitter_types::tree_sitter::Node<'tree>,
3498        src: &'tree [u8],
3499    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3500        debug_assert_eq!(node.kind(), "hash");
3501        Ok(Self {
3502            span: ::treesitter_types::Span::from(node),
3503            children: {
3504                #[allow(clippy::suspicious_else_formatting)]
3505                let non_field_children = {
3506                    let mut cursor = node.walk();
3507                    let mut result = ::std::vec::Vec::new();
3508                    if cursor.goto_first_child() {
3509                        loop {
3510                            if cursor.field_name().is_none()
3511                                && cursor.node().is_named()
3512                                && !cursor.node().is_extra()
3513                            {
3514                                result.push(cursor.node());
3515                            }
3516                            if !cursor.goto_next_sibling() {
3517                                break;
3518                            }
3519                        }
3520                    }
3521                    result
3522                };
3523                let mut items = ::std::vec::Vec::new();
3524                for child in non_field_children {
3525                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3526                        <HashChildren as ::treesitter_types::FromNode>::from_node(child, src)
3527                    })?);
3528                }
3529                items
3530            },
3531        })
3532    }
3533}
3534impl ::treesitter_types::Spanned for Hash<'_> {
3535    fn span(&self) -> ::treesitter_types::Span {
3536        self.span
3537    }
3538}
3539#[derive(Debug, Clone, PartialEq, Eq)]
3540pub struct HashKeySymbol<'tree> {
3541    pub span: ::treesitter_types::Span,
3542    text: &'tree str,
3543}
3544impl<'tree> ::treesitter_types::FromNode<'tree> for HashKeySymbol<'tree> {
3545    fn from_node(
3546        node: ::treesitter_types::tree_sitter::Node<'tree>,
3547        src: &'tree [u8],
3548    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3549        debug_assert_eq!(node.kind(), "hash_key_symbol");
3550        Ok(Self {
3551            span: ::treesitter_types::Span::from(node),
3552            text: node.utf8_text(src)?,
3553        })
3554    }
3555}
3556impl<'tree> ::treesitter_types::LeafNode<'tree> for HashKeySymbol<'tree> {
3557    fn text(&self) -> &'tree str {
3558        self.text
3559    }
3560}
3561impl ::treesitter_types::Spanned for HashKeySymbol<'_> {
3562    fn span(&self) -> ::treesitter_types::Span {
3563        self.span
3564    }
3565}
3566#[derive(Debug, Clone, PartialEq, Eq)]
3567pub struct HashPattern<'tree> {
3568    pub span: ::treesitter_types::Span,
3569    pub class: ::core::option::Option<PatternConstant<'tree>>,
3570    pub children: ::std::vec::Vec<HashPatternChildren<'tree>>,
3571}
3572impl<'tree> ::treesitter_types::FromNode<'tree> for HashPattern<'tree> {
3573    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3574    fn from_node(
3575        node: ::treesitter_types::tree_sitter::Node<'tree>,
3576        src: &'tree [u8],
3577    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3578        debug_assert_eq!(node.kind(), "hash_pattern");
3579        Ok(Self {
3580            span: ::treesitter_types::Span::from(node),
3581            class: match node.child_by_field_name("class") {
3582                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3583                    <PatternConstant as ::treesitter_types::FromNode>::from_node(child, src)
3584                })?),
3585                None => None,
3586            },
3587            children: {
3588                #[allow(clippy::suspicious_else_formatting)]
3589                let non_field_children = {
3590                    let mut cursor = node.walk();
3591                    let mut result = ::std::vec::Vec::new();
3592                    if cursor.goto_first_child() {
3593                        loop {
3594                            if cursor.field_name().is_none()
3595                                && cursor.node().is_named()
3596                                && !cursor.node().is_extra()
3597                            {
3598                                result.push(cursor.node());
3599                            }
3600                            if !cursor.goto_next_sibling() {
3601                                break;
3602                            }
3603                        }
3604                    }
3605                    result
3606                };
3607                let mut items = ::std::vec::Vec::new();
3608                for child in non_field_children {
3609                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3610                        <HashPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
3611                    })?);
3612                }
3613                items
3614            },
3615        })
3616    }
3617}
3618impl ::treesitter_types::Spanned for HashPattern<'_> {
3619    fn span(&self) -> ::treesitter_types::Span {
3620        self.span
3621    }
3622}
3623#[derive(Debug, Clone, PartialEq, Eq)]
3624pub struct HashSplatArgument<'tree> {
3625    pub span: ::treesitter_types::Span,
3626    pub children: ::core::option::Option<Arg<'tree>>,
3627}
3628impl<'tree> ::treesitter_types::FromNode<'tree> for HashSplatArgument<'tree> {
3629    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3630    fn from_node(
3631        node: ::treesitter_types::tree_sitter::Node<'tree>,
3632        src: &'tree [u8],
3633    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3634        debug_assert_eq!(node.kind(), "hash_splat_argument");
3635        Ok(Self {
3636            span: ::treesitter_types::Span::from(node),
3637            children: {
3638                #[allow(clippy::suspicious_else_formatting)]
3639                let non_field_children = {
3640                    let mut cursor = node.walk();
3641                    let mut result = ::std::vec::Vec::new();
3642                    if cursor.goto_first_child() {
3643                        loop {
3644                            if cursor.field_name().is_none()
3645                                && cursor.node().is_named()
3646                                && !cursor.node().is_extra()
3647                            {
3648                                result.push(cursor.node());
3649                            }
3650                            if !cursor.goto_next_sibling() {
3651                                break;
3652                            }
3653                        }
3654                    }
3655                    result
3656                };
3657                match non_field_children.first() {
3658                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3659                        <Arg as ::treesitter_types::FromNode>::from_node(child, src)
3660                    })?),
3661                    None => None,
3662                }
3663            },
3664        })
3665    }
3666}
3667impl ::treesitter_types::Spanned for HashSplatArgument<'_> {
3668    fn span(&self) -> ::treesitter_types::Span {
3669        self.span
3670    }
3671}
3672#[derive(Debug, Clone, PartialEq, Eq)]
3673pub struct HashSplatNil<'tree> {
3674    pub span: ::treesitter_types::Span,
3675    text: &'tree str,
3676}
3677impl<'tree> ::treesitter_types::FromNode<'tree> for HashSplatNil<'tree> {
3678    fn from_node(
3679        node: ::treesitter_types::tree_sitter::Node<'tree>,
3680        src: &'tree [u8],
3681    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3682        debug_assert_eq!(node.kind(), "hash_splat_nil");
3683        Ok(Self {
3684            span: ::treesitter_types::Span::from(node),
3685            text: node.utf8_text(src)?,
3686        })
3687    }
3688}
3689impl<'tree> ::treesitter_types::LeafNode<'tree> for HashSplatNil<'tree> {
3690    fn text(&self) -> &'tree str {
3691        self.text
3692    }
3693}
3694impl ::treesitter_types::Spanned for HashSplatNil<'_> {
3695    fn span(&self) -> ::treesitter_types::Span {
3696        self.span
3697    }
3698}
3699#[derive(Debug, Clone, PartialEq, Eq)]
3700pub struct HashSplatParameter<'tree> {
3701    pub span: ::treesitter_types::Span,
3702    pub name: ::core::option::Option<Identifier<'tree>>,
3703}
3704impl<'tree> ::treesitter_types::FromNode<'tree> for HashSplatParameter<'tree> {
3705    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3706    fn from_node(
3707        node: ::treesitter_types::tree_sitter::Node<'tree>,
3708        src: &'tree [u8],
3709    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3710        debug_assert_eq!(node.kind(), "hash_splat_parameter");
3711        Ok(Self {
3712            span: ::treesitter_types::Span::from(node),
3713            name: match node.child_by_field_name("name") {
3714                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3715                    <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3716                })?),
3717                None => None,
3718            },
3719        })
3720    }
3721}
3722impl ::treesitter_types::Spanned for HashSplatParameter<'_> {
3723    fn span(&self) -> ::treesitter_types::Span {
3724        self.span
3725    }
3726}
3727#[derive(Debug, Clone, PartialEq, Eq)]
3728pub struct HeredocBody<'tree> {
3729    pub span: ::treesitter_types::Span,
3730    pub children: ::std::vec::Vec<HeredocBodyChildren<'tree>>,
3731}
3732impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBody<'tree> {
3733    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3734    fn from_node(
3735        node: ::treesitter_types::tree_sitter::Node<'tree>,
3736        src: &'tree [u8],
3737    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3738        debug_assert_eq!(node.kind(), "heredoc_body");
3739        Ok(Self {
3740            span: ::treesitter_types::Span::from(node),
3741            children: {
3742                #[allow(clippy::suspicious_else_formatting)]
3743                let non_field_children = {
3744                    let mut cursor = node.walk();
3745                    let mut result = ::std::vec::Vec::new();
3746                    if cursor.goto_first_child() {
3747                        loop {
3748                            if cursor.field_name().is_none()
3749                                && cursor.node().is_named()
3750                                && !cursor.node().is_extra()
3751                            {
3752                                result.push(cursor.node());
3753                            }
3754                            if !cursor.goto_next_sibling() {
3755                                break;
3756                            }
3757                        }
3758                    }
3759                    result
3760                };
3761                let mut items = ::std::vec::Vec::new();
3762                for child in non_field_children {
3763                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3764                        <HeredocBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)
3765                    })?);
3766                }
3767                items
3768            },
3769        })
3770    }
3771}
3772impl ::treesitter_types::Spanned for HeredocBody<'_> {
3773    fn span(&self) -> ::treesitter_types::Span {
3774        self.span
3775    }
3776}
3777#[derive(Debug, Clone, PartialEq, Eq)]
3778pub struct Identifier<'tree> {
3779    pub span: ::treesitter_types::Span,
3780    text: &'tree str,
3781}
3782impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
3783    fn from_node(
3784        node: ::treesitter_types::tree_sitter::Node<'tree>,
3785        src: &'tree [u8],
3786    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3787        debug_assert_eq!(node.kind(), "identifier");
3788        Ok(Self {
3789            span: ::treesitter_types::Span::from(node),
3790            text: node.utf8_text(src)?,
3791        })
3792    }
3793}
3794impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
3795    fn text(&self) -> &'tree str {
3796        self.text
3797    }
3798}
3799impl ::treesitter_types::Spanned for Identifier<'_> {
3800    fn span(&self) -> ::treesitter_types::Span {
3801        self.span
3802    }
3803}
3804#[derive(Debug, Clone, PartialEq, Eq)]
3805pub struct If<'tree> {
3806    pub span: ::treesitter_types::Span,
3807    pub alternative: ::core::option::Option<IfAlternative<'tree>>,
3808    pub condition: Statement<'tree>,
3809    pub consequence: ::core::option::Option<Then<'tree>>,
3810}
3811impl<'tree> ::treesitter_types::FromNode<'tree> for If<'tree> {
3812    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3813    fn from_node(
3814        node: ::treesitter_types::tree_sitter::Node<'tree>,
3815        src: &'tree [u8],
3816    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3817        debug_assert_eq!(node.kind(), "if");
3818        Ok(Self {
3819            span: ::treesitter_types::Span::from(node),
3820            alternative: match node.child_by_field_name("alternative") {
3821                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3822                    <IfAlternative as ::treesitter_types::FromNode>::from_node(child, src)
3823                })?),
3824                None => None,
3825            },
3826            condition: {
3827                let child = node.child_by_field_name("condition").ok_or_else(|| {
3828                    ::treesitter_types::ParseError::missing_field("condition", node)
3829                })?;
3830                ::treesitter_types::runtime::maybe_grow_stack(|| {
3831                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3832                })?
3833            },
3834            consequence: match node.child_by_field_name("consequence") {
3835                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3836                    <Then as ::treesitter_types::FromNode>::from_node(child, src)
3837                })?),
3838                None => None,
3839            },
3840        })
3841    }
3842}
3843impl ::treesitter_types::Spanned for If<'_> {
3844    fn span(&self) -> ::treesitter_types::Span {
3845        self.span
3846    }
3847}
3848#[derive(Debug, Clone, PartialEq, Eq)]
3849pub struct IfGuard<'tree> {
3850    pub span: ::treesitter_types::Span,
3851    pub condition: Expression<'tree>,
3852}
3853impl<'tree> ::treesitter_types::FromNode<'tree> for IfGuard<'tree> {
3854    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3855    fn from_node(
3856        node: ::treesitter_types::tree_sitter::Node<'tree>,
3857        src: &'tree [u8],
3858    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3859        debug_assert_eq!(node.kind(), "if_guard");
3860        Ok(Self {
3861            span: ::treesitter_types::Span::from(node),
3862            condition: {
3863                let child = node.child_by_field_name("condition").ok_or_else(|| {
3864                    ::treesitter_types::ParseError::missing_field("condition", node)
3865                })?;
3866                ::treesitter_types::runtime::maybe_grow_stack(|| {
3867                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3868                })?
3869            },
3870        })
3871    }
3872}
3873impl ::treesitter_types::Spanned for IfGuard<'_> {
3874    fn span(&self) -> ::treesitter_types::Span {
3875        self.span
3876    }
3877}
3878#[derive(Debug, Clone, PartialEq, Eq)]
3879pub struct IfModifier<'tree> {
3880    pub span: ::treesitter_types::Span,
3881    pub body: Statement<'tree>,
3882    pub condition: Expression<'tree>,
3883}
3884impl<'tree> ::treesitter_types::FromNode<'tree> for IfModifier<'tree> {
3885    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3886    fn from_node(
3887        node: ::treesitter_types::tree_sitter::Node<'tree>,
3888        src: &'tree [u8],
3889    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3890        debug_assert_eq!(node.kind(), "if_modifier");
3891        Ok(Self {
3892            span: ::treesitter_types::Span::from(node),
3893            body: {
3894                let child = node
3895                    .child_by_field_name("body")
3896                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3897                ::treesitter_types::runtime::maybe_grow_stack(|| {
3898                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3899                })?
3900            },
3901            condition: {
3902                let child = node.child_by_field_name("condition").ok_or_else(|| {
3903                    ::treesitter_types::ParseError::missing_field("condition", node)
3904                })?;
3905                ::treesitter_types::runtime::maybe_grow_stack(|| {
3906                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3907                })?
3908            },
3909        })
3910    }
3911}
3912impl ::treesitter_types::Spanned for IfModifier<'_> {
3913    fn span(&self) -> ::treesitter_types::Span {
3914        self.span
3915    }
3916}
3917#[derive(Debug, Clone, PartialEq, Eq)]
3918pub struct In<'tree> {
3919    pub span: ::treesitter_types::Span,
3920    pub children: Arg<'tree>,
3921}
3922impl<'tree> ::treesitter_types::FromNode<'tree> for In<'tree> {
3923    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3924    fn from_node(
3925        node: ::treesitter_types::tree_sitter::Node<'tree>,
3926        src: &'tree [u8],
3927    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3928        debug_assert_eq!(node.kind(), "in");
3929        Ok(Self {
3930            span: ::treesitter_types::Span::from(node),
3931            children: {
3932                #[allow(clippy::suspicious_else_formatting)]
3933                let non_field_children = {
3934                    let mut cursor = node.walk();
3935                    let mut result = ::std::vec::Vec::new();
3936                    if cursor.goto_first_child() {
3937                        loop {
3938                            if cursor.field_name().is_none()
3939                                && cursor.node().is_named()
3940                                && !cursor.node().is_extra()
3941                            {
3942                                result.push(cursor.node());
3943                            }
3944                            if !cursor.goto_next_sibling() {
3945                                break;
3946                            }
3947                        }
3948                    }
3949                    result
3950                };
3951                let child = if let Some(&c) = non_field_children.first() {
3952                    c
3953                } else {
3954                    let mut fallback_cursor = node.walk();
3955                    let mut fallback_child = None;
3956                    if fallback_cursor.goto_first_child() {
3957                        loop {
3958                            if fallback_cursor.field_name().is_none()
3959                                && !fallback_cursor.node().is_extra()
3960                            {
3961                                let candidate = fallback_cursor.node();
3962                                #[allow(clippy::needless_question_mark)]
3963                                if (|| -> ::core::result::Result<
3964                                    _,
3965                                    ::treesitter_types::ParseError,
3966                                > {
3967                                    let child = candidate;
3968                                    Ok(
3969                                        ::treesitter_types::runtime::maybe_grow_stack(|| <Arg as ::treesitter_types::FromNode>::from_node(
3970                                            child,
3971                                            src,
3972                                        ))?,
3973                                    )
3974                                })()
3975                                    .is_ok()
3976                                {
3977                                    fallback_child = Some(candidate);
3978                                    break;
3979                                }
3980                            }
3981                            if !fallback_cursor.goto_next_sibling() {
3982                                break;
3983                            }
3984                        }
3985                    }
3986                    if fallback_child.is_none() {
3987                        let mut cursor2 = node.walk();
3988                        if cursor2.goto_first_child() {
3989                            loop {
3990                                if cursor2.node().is_named() && !cursor2.node().is_extra() {
3991                                    let candidate = cursor2.node();
3992                                    #[allow(clippy::needless_question_mark)]
3993                                    if (|| -> ::core::result::Result<
3994                                        _,
3995                                        ::treesitter_types::ParseError,
3996                                    > {
3997                                        let child = candidate;
3998                                        Ok(
3999                                            ::treesitter_types::runtime::maybe_grow_stack(|| <Arg as ::treesitter_types::FromNode>::from_node(
4000                                                child,
4001                                                src,
4002                                            ))?,
4003                                        )
4004                                    })()
4005                                        .is_ok()
4006                                    {
4007                                        fallback_child = Some(candidate);
4008                                        break;
4009                                    }
4010                                }
4011                                if !cursor2.goto_next_sibling() {
4012                                    break;
4013                                }
4014                            }
4015                        }
4016                    }
4017                    fallback_child.ok_or_else(|| {
4018                        ::treesitter_types::ParseError::missing_field("children", node)
4019                    })?
4020                };
4021                ::treesitter_types::runtime::maybe_grow_stack(|| {
4022                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
4023                })?
4024            },
4025        })
4026    }
4027}
4028impl ::treesitter_types::Spanned for In<'_> {
4029    fn span(&self) -> ::treesitter_types::Span {
4030        self.span
4031    }
4032}
4033#[derive(Debug, Clone, PartialEq, Eq)]
4034pub struct InClause<'tree> {
4035    pub span: ::treesitter_types::Span,
4036    pub body: ::core::option::Option<Then<'tree>>,
4037    pub guard: ::core::option::Option<InClauseGuard<'tree>>,
4038    pub pattern: PatternTopExprBody<'tree>,
4039}
4040impl<'tree> ::treesitter_types::FromNode<'tree> for InClause<'tree> {
4041    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4042    fn from_node(
4043        node: ::treesitter_types::tree_sitter::Node<'tree>,
4044        src: &'tree [u8],
4045    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4046        debug_assert_eq!(node.kind(), "in_clause");
4047        Ok(Self {
4048            span: ::treesitter_types::Span::from(node),
4049            body: match node.child_by_field_name("body") {
4050                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4051                    <Then as ::treesitter_types::FromNode>::from_node(child, src)
4052                })?),
4053                None => None,
4054            },
4055            guard: match node.child_by_field_name("guard") {
4056                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4057                    <InClauseGuard as ::treesitter_types::FromNode>::from_node(child, src)
4058                })?),
4059                None => None,
4060            },
4061            pattern: {
4062                let child = node.child_by_field_name("pattern").ok_or_else(|| {
4063                    ::treesitter_types::ParseError::missing_field("pattern", node)
4064                })?;
4065                ::treesitter_types::runtime::maybe_grow_stack(|| {
4066                    <PatternTopExprBody as ::treesitter_types::FromNode>::from_node(child, src)
4067                })?
4068            },
4069        })
4070    }
4071}
4072impl ::treesitter_types::Spanned for InClause<'_> {
4073    fn span(&self) -> ::treesitter_types::Span {
4074        self.span
4075    }
4076}
4077#[derive(Debug, Clone, PartialEq, Eq)]
4078pub struct Interpolation<'tree> {
4079    pub span: ::treesitter_types::Span,
4080    pub children: ::std::vec::Vec<InterpolationChildren<'tree>>,
4081}
4082impl<'tree> ::treesitter_types::FromNode<'tree> for Interpolation<'tree> {
4083    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4084    fn from_node(
4085        node: ::treesitter_types::tree_sitter::Node<'tree>,
4086        src: &'tree [u8],
4087    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4088        debug_assert_eq!(node.kind(), "interpolation");
4089        Ok(Self {
4090            span: ::treesitter_types::Span::from(node),
4091            children: {
4092                #[allow(clippy::suspicious_else_formatting)]
4093                let non_field_children = {
4094                    let mut cursor = node.walk();
4095                    let mut result = ::std::vec::Vec::new();
4096                    if cursor.goto_first_child() {
4097                        loop {
4098                            if cursor.field_name().is_none()
4099                                && cursor.node().is_named()
4100                                && !cursor.node().is_extra()
4101                            {
4102                                result.push(cursor.node());
4103                            }
4104                            if !cursor.goto_next_sibling() {
4105                                break;
4106                            }
4107                        }
4108                    }
4109                    result
4110                };
4111                let mut items = ::std::vec::Vec::new();
4112                for child in non_field_children {
4113                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4114                        <InterpolationChildren as ::treesitter_types::FromNode>::from_node(
4115                            child, src,
4116                        )
4117                    })?);
4118                }
4119                items
4120            },
4121        })
4122    }
4123}
4124impl ::treesitter_types::Spanned for Interpolation<'_> {
4125    fn span(&self) -> ::treesitter_types::Span {
4126        self.span
4127    }
4128}
4129#[derive(Debug, Clone, PartialEq, Eq)]
4130pub struct KeywordParameter<'tree> {
4131    pub span: ::treesitter_types::Span,
4132    pub name: Identifier<'tree>,
4133    pub value: ::core::option::Option<Arg<'tree>>,
4134}
4135impl<'tree> ::treesitter_types::FromNode<'tree> for KeywordParameter<'tree> {
4136    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4137    fn from_node(
4138        node: ::treesitter_types::tree_sitter::Node<'tree>,
4139        src: &'tree [u8],
4140    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4141        debug_assert_eq!(node.kind(), "keyword_parameter");
4142        Ok(Self {
4143            span: ::treesitter_types::Span::from(node),
4144            name: {
4145                let child = node
4146                    .child_by_field_name("name")
4147                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4148                ::treesitter_types::runtime::maybe_grow_stack(|| {
4149                    <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4150                })?
4151            },
4152            value: match node.child_by_field_name("value") {
4153                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4154                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
4155                })?),
4156                None => None,
4157            },
4158        })
4159    }
4160}
4161impl ::treesitter_types::Spanned for KeywordParameter<'_> {
4162    fn span(&self) -> ::treesitter_types::Span {
4163        self.span
4164    }
4165}
4166#[derive(Debug, Clone, PartialEq, Eq)]
4167pub struct KeywordPattern<'tree> {
4168    pub span: ::treesitter_types::Span,
4169    pub key: KeywordPatternKey<'tree>,
4170    pub value: ::core::option::Option<PatternExpr<'tree>>,
4171}
4172impl<'tree> ::treesitter_types::FromNode<'tree> for KeywordPattern<'tree> {
4173    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4174    fn from_node(
4175        node: ::treesitter_types::tree_sitter::Node<'tree>,
4176        src: &'tree [u8],
4177    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4178        debug_assert_eq!(node.kind(), "keyword_pattern");
4179        Ok(Self {
4180            span: ::treesitter_types::Span::from(node),
4181            key: {
4182                let child = node
4183                    .child_by_field_name("key")
4184                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
4185                ::treesitter_types::runtime::maybe_grow_stack(|| {
4186                    <KeywordPatternKey as ::treesitter_types::FromNode>::from_node(child, src)
4187                })?
4188            },
4189            value: match node.child_by_field_name("value") {
4190                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4191                    <PatternExpr as ::treesitter_types::FromNode>::from_node(child, src)
4192                })?),
4193                None => None,
4194            },
4195        })
4196    }
4197}
4198impl ::treesitter_types::Spanned for KeywordPattern<'_> {
4199    fn span(&self) -> ::treesitter_types::Span {
4200        self.span
4201    }
4202}
4203#[derive(Debug, Clone, PartialEq, Eq)]
4204pub struct Lambda<'tree> {
4205    pub span: ::treesitter_types::Span,
4206    pub body: LambdaBody<'tree>,
4207    pub parameters: ::core::option::Option<LambdaParameters<'tree>>,
4208}
4209impl<'tree> ::treesitter_types::FromNode<'tree> for Lambda<'tree> {
4210    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4211    fn from_node(
4212        node: ::treesitter_types::tree_sitter::Node<'tree>,
4213        src: &'tree [u8],
4214    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4215        debug_assert_eq!(node.kind(), "lambda");
4216        Ok(Self {
4217            span: ::treesitter_types::Span::from(node),
4218            body: {
4219                let child = node
4220                    .child_by_field_name("body")
4221                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4222                ::treesitter_types::runtime::maybe_grow_stack(|| {
4223                    <LambdaBody as ::treesitter_types::FromNode>::from_node(child, src)
4224                })?
4225            },
4226            parameters: match node.child_by_field_name("parameters") {
4227                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4228                    <LambdaParameters as ::treesitter_types::FromNode>::from_node(child, src)
4229                })?),
4230                None => None,
4231            },
4232        })
4233    }
4234}
4235impl ::treesitter_types::Spanned for Lambda<'_> {
4236    fn span(&self) -> ::treesitter_types::Span {
4237        self.span
4238    }
4239}
4240#[derive(Debug, Clone, PartialEq, Eq)]
4241pub struct LambdaParameters<'tree> {
4242    pub span: ::treesitter_types::Span,
4243    pub children: ::std::vec::Vec<LambdaParametersChildren<'tree>>,
4244}
4245impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaParameters<'tree> {
4246    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4247    fn from_node(
4248        node: ::treesitter_types::tree_sitter::Node<'tree>,
4249        src: &'tree [u8],
4250    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4251        debug_assert_eq!(node.kind(), "lambda_parameters");
4252        Ok(Self {
4253            span: ::treesitter_types::Span::from(node),
4254            children: {
4255                #[allow(clippy::suspicious_else_formatting)]
4256                let non_field_children = {
4257                    let mut cursor = node.walk();
4258                    let mut result = ::std::vec::Vec::new();
4259                    if cursor.goto_first_child() {
4260                        loop {
4261                            if cursor.field_name().is_none()
4262                                && cursor.node().is_named()
4263                                && !cursor.node().is_extra()
4264                            {
4265                                result.push(cursor.node());
4266                            }
4267                            if !cursor.goto_next_sibling() {
4268                                break;
4269                            }
4270                        }
4271                    }
4272                    result
4273                };
4274                let mut items = ::std::vec::Vec::new();
4275                for child in non_field_children {
4276                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4277                        <LambdaParametersChildren as ::treesitter_types::FromNode>::from_node(
4278                            child, src,
4279                        )
4280                    })?);
4281                }
4282                items
4283            },
4284        })
4285    }
4286}
4287impl ::treesitter_types::Spanned for LambdaParameters<'_> {
4288    fn span(&self) -> ::treesitter_types::Span {
4289        self.span
4290    }
4291}
4292#[derive(Debug, Clone, PartialEq, Eq)]
4293pub struct LeftAssignmentList<'tree> {
4294    pub span: ::treesitter_types::Span,
4295    pub children: ::std::vec::Vec<LeftAssignmentListChildren<'tree>>,
4296}
4297impl<'tree> ::treesitter_types::FromNode<'tree> for LeftAssignmentList<'tree> {
4298    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4299    fn from_node(
4300        node: ::treesitter_types::tree_sitter::Node<'tree>,
4301        src: &'tree [u8],
4302    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4303        debug_assert_eq!(node.kind(), "left_assignment_list");
4304        Ok(Self {
4305            span: ::treesitter_types::Span::from(node),
4306            children: {
4307                #[allow(clippy::suspicious_else_formatting)]
4308                let non_field_children = {
4309                    let mut cursor = node.walk();
4310                    let mut result = ::std::vec::Vec::new();
4311                    if cursor.goto_first_child() {
4312                        loop {
4313                            if cursor.field_name().is_none()
4314                                && cursor.node().is_named()
4315                                && !cursor.node().is_extra()
4316                            {
4317                                result.push(cursor.node());
4318                            }
4319                            if !cursor.goto_next_sibling() {
4320                                break;
4321                            }
4322                        }
4323                    }
4324                    result
4325                };
4326                let mut items = ::std::vec::Vec::new();
4327                for child in non_field_children {
4328                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4329                        <LeftAssignmentListChildren as ::treesitter_types::FromNode>::from_node(
4330                            child, src,
4331                        )
4332                    })?);
4333                }
4334                items
4335            },
4336        })
4337    }
4338}
4339impl ::treesitter_types::Spanned for LeftAssignmentList<'_> {
4340    fn span(&self) -> ::treesitter_types::Span {
4341        self.span
4342    }
4343}
4344#[derive(Debug, Clone, PartialEq, Eq)]
4345pub struct MatchPattern<'tree> {
4346    pub span: ::treesitter_types::Span,
4347    pub pattern: PatternTopExprBody<'tree>,
4348    pub value: Arg<'tree>,
4349}
4350impl<'tree> ::treesitter_types::FromNode<'tree> for MatchPattern<'tree> {
4351    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4352    fn from_node(
4353        node: ::treesitter_types::tree_sitter::Node<'tree>,
4354        src: &'tree [u8],
4355    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4356        debug_assert_eq!(node.kind(), "match_pattern");
4357        Ok(Self {
4358            span: ::treesitter_types::Span::from(node),
4359            pattern: {
4360                let child = node.child_by_field_name("pattern").ok_or_else(|| {
4361                    ::treesitter_types::ParseError::missing_field("pattern", node)
4362                })?;
4363                ::treesitter_types::runtime::maybe_grow_stack(|| {
4364                    <PatternTopExprBody as ::treesitter_types::FromNode>::from_node(child, src)
4365                })?
4366            },
4367            value: {
4368                let child = node
4369                    .child_by_field_name("value")
4370                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4371                ::treesitter_types::runtime::maybe_grow_stack(|| {
4372                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
4373                })?
4374            },
4375        })
4376    }
4377}
4378impl ::treesitter_types::Spanned for MatchPattern<'_> {
4379    fn span(&self) -> ::treesitter_types::Span {
4380        self.span
4381    }
4382}
4383#[derive(Debug, Clone, PartialEq, Eq)]
4384pub struct Method<'tree> {
4385    pub span: ::treesitter_types::Span,
4386    pub body: ::core::option::Option<MethodBody<'tree>>,
4387    pub name: MethodName<'tree>,
4388    pub parameters: ::core::option::Option<MethodParameters<'tree>>,
4389}
4390impl<'tree> ::treesitter_types::FromNode<'tree> for Method<'tree> {
4391    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4392    fn from_node(
4393        node: ::treesitter_types::tree_sitter::Node<'tree>,
4394        src: &'tree [u8],
4395    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4396        debug_assert_eq!(node.kind(), "method");
4397        Ok(Self {
4398            span: ::treesitter_types::Span::from(node),
4399            body: match node.child_by_field_name("body") {
4400                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4401                    <MethodBody as ::treesitter_types::FromNode>::from_node(child, src)
4402                })?),
4403                None => None,
4404            },
4405            name: {
4406                let child = node
4407                    .child_by_field_name("name")
4408                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4409                ::treesitter_types::runtime::maybe_grow_stack(|| {
4410                    <MethodName as ::treesitter_types::FromNode>::from_node(child, src)
4411                })?
4412            },
4413            parameters: match node.child_by_field_name("parameters") {
4414                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4415                    <MethodParameters as ::treesitter_types::FromNode>::from_node(child, src)
4416                })?),
4417                None => None,
4418            },
4419        })
4420    }
4421}
4422impl ::treesitter_types::Spanned for Method<'_> {
4423    fn span(&self) -> ::treesitter_types::Span {
4424        self.span
4425    }
4426}
4427#[derive(Debug, Clone, PartialEq, Eq)]
4428pub struct MethodParameters<'tree> {
4429    pub span: ::treesitter_types::Span,
4430    pub children: ::std::vec::Vec<MethodParametersChildren<'tree>>,
4431}
4432impl<'tree> ::treesitter_types::FromNode<'tree> for MethodParameters<'tree> {
4433    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4434    fn from_node(
4435        node: ::treesitter_types::tree_sitter::Node<'tree>,
4436        src: &'tree [u8],
4437    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4438        debug_assert_eq!(node.kind(), "method_parameters");
4439        Ok(Self {
4440            span: ::treesitter_types::Span::from(node),
4441            children: {
4442                #[allow(clippy::suspicious_else_formatting)]
4443                let non_field_children = {
4444                    let mut cursor = node.walk();
4445                    let mut result = ::std::vec::Vec::new();
4446                    if cursor.goto_first_child() {
4447                        loop {
4448                            if cursor.field_name().is_none()
4449                                && cursor.node().is_named()
4450                                && !cursor.node().is_extra()
4451                            {
4452                                result.push(cursor.node());
4453                            }
4454                            if !cursor.goto_next_sibling() {
4455                                break;
4456                            }
4457                        }
4458                    }
4459                    result
4460                };
4461                let mut items = ::std::vec::Vec::new();
4462                for child in non_field_children {
4463                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4464                        <MethodParametersChildren as ::treesitter_types::FromNode>::from_node(
4465                            child, src,
4466                        )
4467                    })?);
4468                }
4469                items
4470            },
4471        })
4472    }
4473}
4474impl ::treesitter_types::Spanned for MethodParameters<'_> {
4475    fn span(&self) -> ::treesitter_types::Span {
4476        self.span
4477    }
4478}
4479#[derive(Debug, Clone, PartialEq, Eq)]
4480pub struct Module<'tree> {
4481    pub span: ::treesitter_types::Span,
4482    pub body: ::core::option::Option<BodyStatement<'tree>>,
4483    pub name: ModuleName<'tree>,
4484}
4485impl<'tree> ::treesitter_types::FromNode<'tree> for Module<'tree> {
4486    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4487    fn from_node(
4488        node: ::treesitter_types::tree_sitter::Node<'tree>,
4489        src: &'tree [u8],
4490    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4491        debug_assert_eq!(node.kind(), "module");
4492        Ok(Self {
4493            span: ::treesitter_types::Span::from(node),
4494            body: match node.child_by_field_name("body") {
4495                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4496                    <BodyStatement as ::treesitter_types::FromNode>::from_node(child, src)
4497                })?),
4498                None => None,
4499            },
4500            name: {
4501                let child = node
4502                    .child_by_field_name("name")
4503                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4504                ::treesitter_types::runtime::maybe_grow_stack(|| {
4505                    <ModuleName as ::treesitter_types::FromNode>::from_node(child, src)
4506                })?
4507            },
4508        })
4509    }
4510}
4511impl ::treesitter_types::Spanned for Module<'_> {
4512    fn span(&self) -> ::treesitter_types::Span {
4513        self.span
4514    }
4515}
4516#[derive(Debug, Clone, PartialEq, Eq)]
4517pub struct Next<'tree> {
4518    pub span: ::treesitter_types::Span,
4519    pub children: ::core::option::Option<ArgumentList<'tree>>,
4520}
4521impl<'tree> ::treesitter_types::FromNode<'tree> for Next<'tree> {
4522    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4523    fn from_node(
4524        node: ::treesitter_types::tree_sitter::Node<'tree>,
4525        src: &'tree [u8],
4526    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4527        debug_assert_eq!(node.kind(), "next");
4528        Ok(Self {
4529            span: ::treesitter_types::Span::from(node),
4530            children: {
4531                #[allow(clippy::suspicious_else_formatting)]
4532                let non_field_children = {
4533                    let mut cursor = node.walk();
4534                    let mut result = ::std::vec::Vec::new();
4535                    if cursor.goto_first_child() {
4536                        loop {
4537                            if cursor.field_name().is_none()
4538                                && cursor.node().is_named()
4539                                && !cursor.node().is_extra()
4540                            {
4541                                result.push(cursor.node());
4542                            }
4543                            if !cursor.goto_next_sibling() {
4544                                break;
4545                            }
4546                        }
4547                    }
4548                    result
4549                };
4550                match non_field_children.first() {
4551                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4552                        <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
4553                    })?),
4554                    None => None,
4555                }
4556            },
4557        })
4558    }
4559}
4560impl ::treesitter_types::Spanned for Next<'_> {
4561    fn span(&self) -> ::treesitter_types::Span {
4562        self.span
4563    }
4564}
4565#[derive(Debug, Clone, PartialEq, Eq)]
4566pub struct Nil<'tree> {
4567    pub span: ::treesitter_types::Span,
4568    text: &'tree str,
4569}
4570impl<'tree> ::treesitter_types::FromNode<'tree> for Nil<'tree> {
4571    fn from_node(
4572        node: ::treesitter_types::tree_sitter::Node<'tree>,
4573        src: &'tree [u8],
4574    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4575        debug_assert_eq!(node.kind(), "nil");
4576        Ok(Self {
4577            span: ::treesitter_types::Span::from(node),
4578            text: node.utf8_text(src)?,
4579        })
4580    }
4581}
4582impl<'tree> ::treesitter_types::LeafNode<'tree> for Nil<'tree> {
4583    fn text(&self) -> &'tree str {
4584        self.text
4585    }
4586}
4587impl ::treesitter_types::Spanned for Nil<'_> {
4588    fn span(&self) -> ::treesitter_types::Span {
4589        self.span
4590    }
4591}
4592#[derive(Debug, Clone, PartialEq, Eq)]
4593pub struct Operator<'tree> {
4594    pub span: ::treesitter_types::Span,
4595    text: &'tree str,
4596}
4597impl<'tree> ::treesitter_types::FromNode<'tree> for Operator<'tree> {
4598    fn from_node(
4599        node: ::treesitter_types::tree_sitter::Node<'tree>,
4600        src: &'tree [u8],
4601    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4602        debug_assert_eq!(node.kind(), "operator");
4603        Ok(Self {
4604            span: ::treesitter_types::Span::from(node),
4605            text: node.utf8_text(src)?,
4606        })
4607    }
4608}
4609impl<'tree> ::treesitter_types::LeafNode<'tree> for Operator<'tree> {
4610    fn text(&self) -> &'tree str {
4611        self.text
4612    }
4613}
4614impl ::treesitter_types::Spanned for Operator<'_> {
4615    fn span(&self) -> ::treesitter_types::Span {
4616        self.span
4617    }
4618}
4619#[derive(Debug, Clone, PartialEq, Eq)]
4620pub struct OperatorAssignment<'tree> {
4621    pub span: ::treesitter_types::Span,
4622    pub left: Lhs<'tree>,
4623    pub operator: OperatorAssignmentOperator,
4624    pub right: OperatorAssignmentRight<'tree>,
4625}
4626impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorAssignment<'tree> {
4627    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4628    fn from_node(
4629        node: ::treesitter_types::tree_sitter::Node<'tree>,
4630        src: &'tree [u8],
4631    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4632        debug_assert_eq!(node.kind(), "operator_assignment");
4633        Ok(Self {
4634            span: ::treesitter_types::Span::from(node),
4635            left: {
4636                let child = node
4637                    .child_by_field_name("left")
4638                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
4639                ::treesitter_types::runtime::maybe_grow_stack(|| {
4640                    <Lhs as ::treesitter_types::FromNode>::from_node(child, src)
4641                })?
4642            },
4643            operator: {
4644                let child = node.child_by_field_name("operator").ok_or_else(|| {
4645                    ::treesitter_types::ParseError::missing_field("operator", node)
4646                })?;
4647                ::treesitter_types::runtime::maybe_grow_stack(|| {
4648                    <OperatorAssignmentOperator as ::treesitter_types::FromNode>::from_node(
4649                        child, src,
4650                    )
4651                })?
4652            },
4653            right: {
4654                let child = node
4655                    .child_by_field_name("right")
4656                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
4657                ::treesitter_types::runtime::maybe_grow_stack(|| {
4658                    <OperatorAssignmentRight as ::treesitter_types::FromNode>::from_node(child, src)
4659                })?
4660            },
4661        })
4662    }
4663}
4664impl ::treesitter_types::Spanned for OperatorAssignment<'_> {
4665    fn span(&self) -> ::treesitter_types::Span {
4666        self.span
4667    }
4668}
4669#[derive(Debug, Clone, PartialEq, Eq)]
4670pub struct OptionalParameter<'tree> {
4671    pub span: ::treesitter_types::Span,
4672    pub name: Identifier<'tree>,
4673    pub value: Arg<'tree>,
4674}
4675impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameter<'tree> {
4676    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4677    fn from_node(
4678        node: ::treesitter_types::tree_sitter::Node<'tree>,
4679        src: &'tree [u8],
4680    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4681        debug_assert_eq!(node.kind(), "optional_parameter");
4682        Ok(Self {
4683            span: ::treesitter_types::Span::from(node),
4684            name: {
4685                let child = node
4686                    .child_by_field_name("name")
4687                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4688                ::treesitter_types::runtime::maybe_grow_stack(|| {
4689                    <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4690                })?
4691            },
4692            value: {
4693                let child = node
4694                    .child_by_field_name("value")
4695                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4696                ::treesitter_types::runtime::maybe_grow_stack(|| {
4697                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
4698                })?
4699            },
4700        })
4701    }
4702}
4703impl ::treesitter_types::Spanned for OptionalParameter<'_> {
4704    fn span(&self) -> ::treesitter_types::Span {
4705        self.span
4706    }
4707}
4708#[derive(Debug, Clone, PartialEq, Eq)]
4709pub struct Pair<'tree> {
4710    pub span: ::treesitter_types::Span,
4711    pub key: PairKey<'tree>,
4712    pub value: ::core::option::Option<Arg<'tree>>,
4713}
4714impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
4715    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4716    fn from_node(
4717        node: ::treesitter_types::tree_sitter::Node<'tree>,
4718        src: &'tree [u8],
4719    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4720        debug_assert_eq!(node.kind(), "pair");
4721        Ok(Self {
4722            span: ::treesitter_types::Span::from(node),
4723            key: {
4724                let child = node
4725                    .child_by_field_name("key")
4726                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
4727                ::treesitter_types::runtime::maybe_grow_stack(|| {
4728                    <PairKey as ::treesitter_types::FromNode>::from_node(child, src)
4729                })?
4730            },
4731            value: match node.child_by_field_name("value") {
4732                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4733                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
4734                })?),
4735                None => None,
4736            },
4737        })
4738    }
4739}
4740impl ::treesitter_types::Spanned for Pair<'_> {
4741    fn span(&self) -> ::treesitter_types::Span {
4742        self.span
4743    }
4744}
4745#[derive(Debug, Clone, PartialEq, Eq)]
4746pub struct ParenthesizedPattern<'tree> {
4747    pub span: ::treesitter_types::Span,
4748    pub children: PatternExpr<'tree>,
4749}
4750impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedPattern<'tree> {
4751    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4752    fn from_node(
4753        node: ::treesitter_types::tree_sitter::Node<'tree>,
4754        src: &'tree [u8],
4755    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4756        debug_assert_eq!(node.kind(), "parenthesized_pattern");
4757        Ok(Self {
4758            span: ::treesitter_types::Span::from(node),
4759            children: {
4760                #[allow(clippy::suspicious_else_formatting)]
4761                let non_field_children = {
4762                    let mut cursor = node.walk();
4763                    let mut result = ::std::vec::Vec::new();
4764                    if cursor.goto_first_child() {
4765                        loop {
4766                            if cursor.field_name().is_none()
4767                                && cursor.node().is_named()
4768                                && !cursor.node().is_extra()
4769                            {
4770                                result.push(cursor.node());
4771                            }
4772                            if !cursor.goto_next_sibling() {
4773                                break;
4774                            }
4775                        }
4776                    }
4777                    result
4778                };
4779                let child = if let Some(&c) = non_field_children.first() {
4780                    c
4781                } else {
4782                    let mut fallback_cursor = node.walk();
4783                    let mut fallback_child = None;
4784                    if fallback_cursor.goto_first_child() {
4785                        loop {
4786                            if fallback_cursor.field_name().is_none()
4787                                && !fallback_cursor.node().is_extra()
4788                            {
4789                                let candidate = fallback_cursor.node();
4790                                #[allow(clippy::needless_question_mark)]
4791                                if (|| -> ::core::result::Result<
4792                                    _,
4793                                    ::treesitter_types::ParseError,
4794                                > {
4795                                    let child = candidate;
4796                                    Ok(
4797                                        ::treesitter_types::runtime::maybe_grow_stack(|| <PatternExpr as ::treesitter_types::FromNode>::from_node(
4798                                            child,
4799                                            src,
4800                                        ))?,
4801                                    )
4802                                })()
4803                                    .is_ok()
4804                                {
4805                                    fallback_child = Some(candidate);
4806                                    break;
4807                                }
4808                            }
4809                            if !fallback_cursor.goto_next_sibling() {
4810                                break;
4811                            }
4812                        }
4813                    }
4814                    if fallback_child.is_none() {
4815                        let mut cursor2 = node.walk();
4816                        if cursor2.goto_first_child() {
4817                            loop {
4818                                if cursor2.node().is_named() && !cursor2.node().is_extra() {
4819                                    let candidate = cursor2.node();
4820                                    #[allow(clippy::needless_question_mark)]
4821                                    if (|| -> ::core::result::Result<
4822                                        _,
4823                                        ::treesitter_types::ParseError,
4824                                    > {
4825                                        let child = candidate;
4826                                        Ok(
4827                                            ::treesitter_types::runtime::maybe_grow_stack(|| <PatternExpr as ::treesitter_types::FromNode>::from_node(
4828                                                child,
4829                                                src,
4830                                            ))?,
4831                                        )
4832                                    })()
4833                                        .is_ok()
4834                                    {
4835                                        fallback_child = Some(candidate);
4836                                        break;
4837                                    }
4838                                }
4839                                if !cursor2.goto_next_sibling() {
4840                                    break;
4841                                }
4842                            }
4843                        }
4844                    }
4845                    fallback_child.ok_or_else(|| {
4846                        ::treesitter_types::ParseError::missing_field("children", node)
4847                    })?
4848                };
4849                ::treesitter_types::runtime::maybe_grow_stack(|| {
4850                    <PatternExpr as ::treesitter_types::FromNode>::from_node(child, src)
4851                })?
4852            },
4853        })
4854    }
4855}
4856impl ::treesitter_types::Spanned for ParenthesizedPattern<'_> {
4857    fn span(&self) -> ::treesitter_types::Span {
4858        self.span
4859    }
4860}
4861#[derive(Debug, Clone, PartialEq, Eq)]
4862pub struct ParenthesizedStatements<'tree> {
4863    pub span: ::treesitter_types::Span,
4864    pub children: ::std::vec::Vec<ParenthesizedStatementsChildren<'tree>>,
4865}
4866impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedStatements<'tree> {
4867    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4868    fn from_node(
4869        node: ::treesitter_types::tree_sitter::Node<'tree>,
4870        src: &'tree [u8],
4871    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4872        debug_assert_eq!(node.kind(), "parenthesized_statements");
4873        Ok(Self {
4874            span: ::treesitter_types::Span::from(node),
4875            children: {
4876                #[allow(clippy::suspicious_else_formatting)]
4877                let non_field_children = {
4878                    let mut cursor = node.walk();
4879                    let mut result = ::std::vec::Vec::new();
4880                    if cursor.goto_first_child() {
4881                        loop {
4882                            if cursor.field_name().is_none()
4883                                && cursor.node().is_named()
4884                                && !cursor.node().is_extra()
4885                            {
4886                                result.push(cursor.node());
4887                            }
4888                            if !cursor.goto_next_sibling() {
4889                                break;
4890                            }
4891                        }
4892                    }
4893                    result
4894                };
4895                let mut items = ::std::vec::Vec::new();
4896                for child in non_field_children {
4897                    items
4898                        .push(
4899                            ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedStatementsChildren as ::treesitter_types::FromNode>::from_node(
4900                                child,
4901                                src,
4902                            ))?,
4903                        );
4904                }
4905                items
4906            },
4907        })
4908    }
4909}
4910impl ::treesitter_types::Spanned for ParenthesizedStatements<'_> {
4911    fn span(&self) -> ::treesitter_types::Span {
4912        self.span
4913    }
4914}
4915#[derive(Debug, Clone, PartialEq, Eq)]
4916pub struct Pattern<'tree> {
4917    pub span: ::treesitter_types::Span,
4918    pub children: PatternChildren<'tree>,
4919}
4920impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
4921    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4922    fn from_node(
4923        node: ::treesitter_types::tree_sitter::Node<'tree>,
4924        src: &'tree [u8],
4925    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4926        debug_assert_eq!(node.kind(), "pattern");
4927        Ok(Self {
4928            span: ::treesitter_types::Span::from(node),
4929            children: {
4930                #[allow(clippy::suspicious_else_formatting)]
4931                let non_field_children = {
4932                    let mut cursor = node.walk();
4933                    let mut result = ::std::vec::Vec::new();
4934                    if cursor.goto_first_child() {
4935                        loop {
4936                            if cursor.field_name().is_none()
4937                                && cursor.node().is_named()
4938                                && !cursor.node().is_extra()
4939                            {
4940                                result.push(cursor.node());
4941                            }
4942                            if !cursor.goto_next_sibling() {
4943                                break;
4944                            }
4945                        }
4946                    }
4947                    result
4948                };
4949                let child = if let Some(&c) = non_field_children.first() {
4950                    c
4951                } else {
4952                    let mut fallback_cursor = node.walk();
4953                    let mut fallback_child = None;
4954                    if fallback_cursor.goto_first_child() {
4955                        loop {
4956                            if fallback_cursor.field_name().is_none()
4957                                && !fallback_cursor.node().is_extra()
4958                            {
4959                                let candidate = fallback_cursor.node();
4960                                #[allow(clippy::needless_question_mark)]
4961                                if (|| -> ::core::result::Result<
4962                                    _,
4963                                    ::treesitter_types::ParseError,
4964                                > {
4965                                    let child = candidate;
4966                                    Ok(
4967                                        ::treesitter_types::runtime::maybe_grow_stack(|| <PatternChildren as ::treesitter_types::FromNode>::from_node(
4968                                            child,
4969                                            src,
4970                                        ))?,
4971                                    )
4972                                })()
4973                                    .is_ok()
4974                                {
4975                                    fallback_child = Some(candidate);
4976                                    break;
4977                                }
4978                            }
4979                            if !fallback_cursor.goto_next_sibling() {
4980                                break;
4981                            }
4982                        }
4983                    }
4984                    if fallback_child.is_none() {
4985                        let mut cursor2 = node.walk();
4986                        if cursor2.goto_first_child() {
4987                            loop {
4988                                if cursor2.node().is_named() && !cursor2.node().is_extra() {
4989                                    let candidate = cursor2.node();
4990                                    #[allow(clippy::needless_question_mark)]
4991                                    if (|| -> ::core::result::Result<
4992                                        _,
4993                                        ::treesitter_types::ParseError,
4994                                    > {
4995                                        let child = candidate;
4996                                        Ok(
4997                                            ::treesitter_types::runtime::maybe_grow_stack(|| <PatternChildren as ::treesitter_types::FromNode>::from_node(
4998                                                child,
4999                                                src,
5000                                            ))?,
5001                                        )
5002                                    })()
5003                                        .is_ok()
5004                                    {
5005                                        fallback_child = Some(candidate);
5006                                        break;
5007                                    }
5008                                }
5009                                if !cursor2.goto_next_sibling() {
5010                                    break;
5011                                }
5012                            }
5013                        }
5014                    }
5015                    fallback_child.ok_or_else(|| {
5016                        ::treesitter_types::ParseError::missing_field("children", node)
5017                    })?
5018                };
5019                ::treesitter_types::runtime::maybe_grow_stack(|| {
5020                    <PatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
5021                })?
5022            },
5023        })
5024    }
5025}
5026impl ::treesitter_types::Spanned for Pattern<'_> {
5027    fn span(&self) -> ::treesitter_types::Span {
5028        self.span
5029    }
5030}
5031#[derive(Debug, Clone, PartialEq, Eq)]
5032pub struct Program<'tree> {
5033    pub span: ::treesitter_types::Span,
5034    pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
5035}
5036impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
5037    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5038    fn from_node(
5039        node: ::treesitter_types::tree_sitter::Node<'tree>,
5040        src: &'tree [u8],
5041    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5042        debug_assert_eq!(node.kind(), "program");
5043        Ok(Self {
5044            span: ::treesitter_types::Span::from(node),
5045            children: {
5046                #[allow(clippy::suspicious_else_formatting)]
5047                let non_field_children = {
5048                    let mut cursor = node.walk();
5049                    let mut result = ::std::vec::Vec::new();
5050                    if cursor.goto_first_child() {
5051                        loop {
5052                            if cursor.field_name().is_none()
5053                                && cursor.node().is_named()
5054                                && !cursor.node().is_extra()
5055                            {
5056                                result.push(cursor.node());
5057                            }
5058                            if !cursor.goto_next_sibling() {
5059                                break;
5060                            }
5061                        }
5062                    }
5063                    result
5064                };
5065                let mut items = ::std::vec::Vec::new();
5066                for child in non_field_children {
5067                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5068                        <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)
5069                    })?);
5070                }
5071                items
5072            },
5073        })
5074    }
5075}
5076impl ::treesitter_types::Spanned for Program<'_> {
5077    fn span(&self) -> ::treesitter_types::Span {
5078        self.span
5079    }
5080}
5081#[derive(Debug, Clone, PartialEq, Eq)]
5082pub struct Range<'tree> {
5083    pub span: ::treesitter_types::Span,
5084    pub begin: ::core::option::Option<RangeBegin<'tree>>,
5085    pub end: ::core::option::Option<RangeEnd<'tree>>,
5086    pub operator: RangeOperator,
5087}
5088impl<'tree> ::treesitter_types::FromNode<'tree> for Range<'tree> {
5089    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5090    fn from_node(
5091        node: ::treesitter_types::tree_sitter::Node<'tree>,
5092        src: &'tree [u8],
5093    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5094        debug_assert_eq!(node.kind(), "range");
5095        Ok(Self {
5096            span: ::treesitter_types::Span::from(node),
5097            begin: match node.child_by_field_name("begin") {
5098                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5099                    <RangeBegin as ::treesitter_types::FromNode>::from_node(child, src)
5100                })?),
5101                None => None,
5102            },
5103            end: match node.child_by_field_name("end") {
5104                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5105                    <RangeEnd as ::treesitter_types::FromNode>::from_node(child, src)
5106                })?),
5107                None => None,
5108            },
5109            operator: {
5110                let child = node.child_by_field_name("operator").ok_or_else(|| {
5111                    ::treesitter_types::ParseError::missing_field("operator", node)
5112                })?;
5113                ::treesitter_types::runtime::maybe_grow_stack(|| {
5114                    <RangeOperator as ::treesitter_types::FromNode>::from_node(child, src)
5115                })?
5116            },
5117        })
5118    }
5119}
5120impl ::treesitter_types::Spanned for Range<'_> {
5121    fn span(&self) -> ::treesitter_types::Span {
5122        self.span
5123    }
5124}
5125#[derive(Debug, Clone, PartialEq, Eq)]
5126pub struct Rational<'tree> {
5127    pub span: ::treesitter_types::Span,
5128    pub children: RationalChildren<'tree>,
5129}
5130impl<'tree> ::treesitter_types::FromNode<'tree> for Rational<'tree> {
5131    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5132    fn from_node(
5133        node: ::treesitter_types::tree_sitter::Node<'tree>,
5134        src: &'tree [u8],
5135    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5136        debug_assert_eq!(node.kind(), "rational");
5137        Ok(Self {
5138            span: ::treesitter_types::Span::from(node),
5139            children: {
5140                #[allow(clippy::suspicious_else_formatting)]
5141                let non_field_children = {
5142                    let mut cursor = node.walk();
5143                    let mut result = ::std::vec::Vec::new();
5144                    if cursor.goto_first_child() {
5145                        loop {
5146                            if cursor.field_name().is_none()
5147                                && cursor.node().is_named()
5148                                && !cursor.node().is_extra()
5149                            {
5150                                result.push(cursor.node());
5151                            }
5152                            if !cursor.goto_next_sibling() {
5153                                break;
5154                            }
5155                        }
5156                    }
5157                    result
5158                };
5159                let child = if let Some(&c) = non_field_children.first() {
5160                    c
5161                } else {
5162                    let mut fallback_cursor = node.walk();
5163                    let mut fallback_child = None;
5164                    if fallback_cursor.goto_first_child() {
5165                        loop {
5166                            if fallback_cursor.field_name().is_none()
5167                                && !fallback_cursor.node().is_extra()
5168                            {
5169                                let candidate = fallback_cursor.node();
5170                                #[allow(clippy::needless_question_mark)]
5171                                if (|| -> ::core::result::Result<
5172                                    _,
5173                                    ::treesitter_types::ParseError,
5174                                > {
5175                                    let child = candidate;
5176                                    Ok(
5177                                        ::treesitter_types::runtime::maybe_grow_stack(|| <RationalChildren as ::treesitter_types::FromNode>::from_node(
5178                                            child,
5179                                            src,
5180                                        ))?,
5181                                    )
5182                                })()
5183                                    .is_ok()
5184                                {
5185                                    fallback_child = Some(candidate);
5186                                    break;
5187                                }
5188                            }
5189                            if !fallback_cursor.goto_next_sibling() {
5190                                break;
5191                            }
5192                        }
5193                    }
5194                    if fallback_child.is_none() {
5195                        let mut cursor2 = node.walk();
5196                        if cursor2.goto_first_child() {
5197                            loop {
5198                                if cursor2.node().is_named() && !cursor2.node().is_extra() {
5199                                    let candidate = cursor2.node();
5200                                    #[allow(clippy::needless_question_mark)]
5201                                    if (|| -> ::core::result::Result<
5202                                        _,
5203                                        ::treesitter_types::ParseError,
5204                                    > {
5205                                        let child = candidate;
5206                                        Ok(
5207                                            ::treesitter_types::runtime::maybe_grow_stack(|| <RationalChildren as ::treesitter_types::FromNode>::from_node(
5208                                                child,
5209                                                src,
5210                                            ))?,
5211                                        )
5212                                    })()
5213                                        .is_ok()
5214                                    {
5215                                        fallback_child = Some(candidate);
5216                                        break;
5217                                    }
5218                                }
5219                                if !cursor2.goto_next_sibling() {
5220                                    break;
5221                                }
5222                            }
5223                        }
5224                    }
5225                    fallback_child.ok_or_else(|| {
5226                        ::treesitter_types::ParseError::missing_field("children", node)
5227                    })?
5228                };
5229                ::treesitter_types::runtime::maybe_grow_stack(|| {
5230                    <RationalChildren as ::treesitter_types::FromNode>::from_node(child, src)
5231                })?
5232            },
5233        })
5234    }
5235}
5236impl ::treesitter_types::Spanned for Rational<'_> {
5237    fn span(&self) -> ::treesitter_types::Span {
5238        self.span
5239    }
5240}
5241#[derive(Debug, Clone, PartialEq, Eq)]
5242pub struct Redo<'tree> {
5243    pub span: ::treesitter_types::Span,
5244    pub children: ::core::option::Option<ArgumentList<'tree>>,
5245}
5246impl<'tree> ::treesitter_types::FromNode<'tree> for Redo<'tree> {
5247    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5248    fn from_node(
5249        node: ::treesitter_types::tree_sitter::Node<'tree>,
5250        src: &'tree [u8],
5251    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5252        debug_assert_eq!(node.kind(), "redo");
5253        Ok(Self {
5254            span: ::treesitter_types::Span::from(node),
5255            children: {
5256                #[allow(clippy::suspicious_else_formatting)]
5257                let non_field_children = {
5258                    let mut cursor = node.walk();
5259                    let mut result = ::std::vec::Vec::new();
5260                    if cursor.goto_first_child() {
5261                        loop {
5262                            if cursor.field_name().is_none()
5263                                && cursor.node().is_named()
5264                                && !cursor.node().is_extra()
5265                            {
5266                                result.push(cursor.node());
5267                            }
5268                            if !cursor.goto_next_sibling() {
5269                                break;
5270                            }
5271                        }
5272                    }
5273                    result
5274                };
5275                match non_field_children.first() {
5276                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5277                        <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
5278                    })?),
5279                    None => None,
5280                }
5281            },
5282        })
5283    }
5284}
5285impl ::treesitter_types::Spanned for Redo<'_> {
5286    fn span(&self) -> ::treesitter_types::Span {
5287        self.span
5288    }
5289}
5290#[derive(Debug, Clone, PartialEq, Eq)]
5291pub struct Regex<'tree> {
5292    pub span: ::treesitter_types::Span,
5293    pub children: ::std::vec::Vec<RegexChildren<'tree>>,
5294}
5295impl<'tree> ::treesitter_types::FromNode<'tree> for Regex<'tree> {
5296    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5297    fn from_node(
5298        node: ::treesitter_types::tree_sitter::Node<'tree>,
5299        src: &'tree [u8],
5300    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5301        debug_assert_eq!(node.kind(), "regex");
5302        Ok(Self {
5303            span: ::treesitter_types::Span::from(node),
5304            children: {
5305                #[allow(clippy::suspicious_else_formatting)]
5306                let non_field_children = {
5307                    let mut cursor = node.walk();
5308                    let mut result = ::std::vec::Vec::new();
5309                    if cursor.goto_first_child() {
5310                        loop {
5311                            if cursor.field_name().is_none()
5312                                && cursor.node().is_named()
5313                                && !cursor.node().is_extra()
5314                            {
5315                                result.push(cursor.node());
5316                            }
5317                            if !cursor.goto_next_sibling() {
5318                                break;
5319                            }
5320                        }
5321                    }
5322                    result
5323                };
5324                let mut items = ::std::vec::Vec::new();
5325                for child in non_field_children {
5326                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5327                        <RegexChildren as ::treesitter_types::FromNode>::from_node(child, src)
5328                    })?);
5329                }
5330                items
5331            },
5332        })
5333    }
5334}
5335impl ::treesitter_types::Spanned for Regex<'_> {
5336    fn span(&self) -> ::treesitter_types::Span {
5337        self.span
5338    }
5339}
5340#[derive(Debug, Clone, PartialEq, Eq)]
5341pub struct Rescue<'tree> {
5342    pub span: ::treesitter_types::Span,
5343    pub body: ::core::option::Option<Then<'tree>>,
5344    pub exceptions: ::core::option::Option<Exceptions<'tree>>,
5345    pub variable: ::core::option::Option<ExceptionVariable<'tree>>,
5346}
5347impl<'tree> ::treesitter_types::FromNode<'tree> for Rescue<'tree> {
5348    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5349    fn from_node(
5350        node: ::treesitter_types::tree_sitter::Node<'tree>,
5351        src: &'tree [u8],
5352    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5353        debug_assert_eq!(node.kind(), "rescue");
5354        Ok(Self {
5355            span: ::treesitter_types::Span::from(node),
5356            body: match node.child_by_field_name("body") {
5357                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5358                    <Then as ::treesitter_types::FromNode>::from_node(child, src)
5359                })?),
5360                None => None,
5361            },
5362            exceptions: match node.child_by_field_name("exceptions") {
5363                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5364                    <Exceptions as ::treesitter_types::FromNode>::from_node(child, src)
5365                })?),
5366                None => None,
5367            },
5368            variable: match node.child_by_field_name("variable") {
5369                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5370                    <ExceptionVariable as ::treesitter_types::FromNode>::from_node(child, src)
5371                })?),
5372                None => None,
5373            },
5374        })
5375    }
5376}
5377impl ::treesitter_types::Spanned for Rescue<'_> {
5378    fn span(&self) -> ::treesitter_types::Span {
5379        self.span
5380    }
5381}
5382#[derive(Debug, Clone, PartialEq, Eq)]
5383pub struct RescueModifier<'tree> {
5384    pub span: ::treesitter_types::Span,
5385    pub body: RescueModifierBody<'tree>,
5386    pub handler: Expression<'tree>,
5387}
5388impl<'tree> ::treesitter_types::FromNode<'tree> for RescueModifier<'tree> {
5389    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5390    fn from_node(
5391        node: ::treesitter_types::tree_sitter::Node<'tree>,
5392        src: &'tree [u8],
5393    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5394        debug_assert_eq!(node.kind(), "rescue_modifier");
5395        Ok(Self {
5396            span: ::treesitter_types::Span::from(node),
5397            body: {
5398                let child = node
5399                    .child_by_field_name("body")
5400                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5401                ::treesitter_types::runtime::maybe_grow_stack(|| {
5402                    <RescueModifierBody as ::treesitter_types::FromNode>::from_node(child, src)
5403                })?
5404            },
5405            handler: {
5406                let child = node.child_by_field_name("handler").ok_or_else(|| {
5407                    ::treesitter_types::ParseError::missing_field("handler", node)
5408                })?;
5409                ::treesitter_types::runtime::maybe_grow_stack(|| {
5410                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5411                })?
5412            },
5413        })
5414    }
5415}
5416impl ::treesitter_types::Spanned for RescueModifier<'_> {
5417    fn span(&self) -> ::treesitter_types::Span {
5418        self.span
5419    }
5420}
5421#[derive(Debug, Clone, PartialEq, Eq)]
5422pub struct RestAssignment<'tree> {
5423    pub span: ::treesitter_types::Span,
5424    pub children: ::core::option::Option<Lhs<'tree>>,
5425}
5426impl<'tree> ::treesitter_types::FromNode<'tree> for RestAssignment<'tree> {
5427    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5428    fn from_node(
5429        node: ::treesitter_types::tree_sitter::Node<'tree>,
5430        src: &'tree [u8],
5431    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5432        debug_assert_eq!(node.kind(), "rest_assignment");
5433        Ok(Self {
5434            span: ::treesitter_types::Span::from(node),
5435            children: {
5436                #[allow(clippy::suspicious_else_formatting)]
5437                let non_field_children = {
5438                    let mut cursor = node.walk();
5439                    let mut result = ::std::vec::Vec::new();
5440                    if cursor.goto_first_child() {
5441                        loop {
5442                            if cursor.field_name().is_none()
5443                                && cursor.node().is_named()
5444                                && !cursor.node().is_extra()
5445                            {
5446                                result.push(cursor.node());
5447                            }
5448                            if !cursor.goto_next_sibling() {
5449                                break;
5450                            }
5451                        }
5452                    }
5453                    result
5454                };
5455                match non_field_children.first() {
5456                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5457                        <Lhs as ::treesitter_types::FromNode>::from_node(child, src)
5458                    })?),
5459                    None => None,
5460                }
5461            },
5462        })
5463    }
5464}
5465impl ::treesitter_types::Spanned for RestAssignment<'_> {
5466    fn span(&self) -> ::treesitter_types::Span {
5467        self.span
5468    }
5469}
5470#[derive(Debug, Clone, PartialEq, Eq)]
5471pub struct Retry<'tree> {
5472    pub span: ::treesitter_types::Span,
5473    pub children: ::core::option::Option<ArgumentList<'tree>>,
5474}
5475impl<'tree> ::treesitter_types::FromNode<'tree> for Retry<'tree> {
5476    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5477    fn from_node(
5478        node: ::treesitter_types::tree_sitter::Node<'tree>,
5479        src: &'tree [u8],
5480    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5481        debug_assert_eq!(node.kind(), "retry");
5482        Ok(Self {
5483            span: ::treesitter_types::Span::from(node),
5484            children: {
5485                #[allow(clippy::suspicious_else_formatting)]
5486                let non_field_children = {
5487                    let mut cursor = node.walk();
5488                    let mut result = ::std::vec::Vec::new();
5489                    if cursor.goto_first_child() {
5490                        loop {
5491                            if cursor.field_name().is_none()
5492                                && cursor.node().is_named()
5493                                && !cursor.node().is_extra()
5494                            {
5495                                result.push(cursor.node());
5496                            }
5497                            if !cursor.goto_next_sibling() {
5498                                break;
5499                            }
5500                        }
5501                    }
5502                    result
5503                };
5504                match non_field_children.first() {
5505                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5506                        <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
5507                    })?),
5508                    None => None,
5509                }
5510            },
5511        })
5512    }
5513}
5514impl ::treesitter_types::Spanned for Retry<'_> {
5515    fn span(&self) -> ::treesitter_types::Span {
5516        self.span
5517    }
5518}
5519#[derive(Debug, Clone, PartialEq, Eq)]
5520pub struct Return<'tree> {
5521    pub span: ::treesitter_types::Span,
5522    pub children: ::core::option::Option<ArgumentList<'tree>>,
5523}
5524impl<'tree> ::treesitter_types::FromNode<'tree> for Return<'tree> {
5525    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5526    fn from_node(
5527        node: ::treesitter_types::tree_sitter::Node<'tree>,
5528        src: &'tree [u8],
5529    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5530        debug_assert_eq!(node.kind(), "return");
5531        Ok(Self {
5532            span: ::treesitter_types::Span::from(node),
5533            children: {
5534                #[allow(clippy::suspicious_else_formatting)]
5535                let non_field_children = {
5536                    let mut cursor = node.walk();
5537                    let mut result = ::std::vec::Vec::new();
5538                    if cursor.goto_first_child() {
5539                        loop {
5540                            if cursor.field_name().is_none()
5541                                && cursor.node().is_named()
5542                                && !cursor.node().is_extra()
5543                            {
5544                                result.push(cursor.node());
5545                            }
5546                            if !cursor.goto_next_sibling() {
5547                                break;
5548                            }
5549                        }
5550                    }
5551                    result
5552                };
5553                match non_field_children.first() {
5554                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5555                        <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
5556                    })?),
5557                    None => None,
5558                }
5559            },
5560        })
5561    }
5562}
5563impl ::treesitter_types::Spanned for Return<'_> {
5564    fn span(&self) -> ::treesitter_types::Span {
5565        self.span
5566    }
5567}
5568#[derive(Debug, Clone, PartialEq, Eq)]
5569pub struct RightAssignmentList<'tree> {
5570    pub span: ::treesitter_types::Span,
5571    pub children: ::std::vec::Vec<RightAssignmentListChildren<'tree>>,
5572}
5573impl<'tree> ::treesitter_types::FromNode<'tree> for RightAssignmentList<'tree> {
5574    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5575    fn from_node(
5576        node: ::treesitter_types::tree_sitter::Node<'tree>,
5577        src: &'tree [u8],
5578    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5579        debug_assert_eq!(node.kind(), "right_assignment_list");
5580        Ok(Self {
5581            span: ::treesitter_types::Span::from(node),
5582            children: {
5583                #[allow(clippy::suspicious_else_formatting)]
5584                let non_field_children = {
5585                    let mut cursor = node.walk();
5586                    let mut result = ::std::vec::Vec::new();
5587                    if cursor.goto_first_child() {
5588                        loop {
5589                            if cursor.field_name().is_none()
5590                                && cursor.node().is_named()
5591                                && !cursor.node().is_extra()
5592                            {
5593                                result.push(cursor.node());
5594                            }
5595                            if !cursor.goto_next_sibling() {
5596                                break;
5597                            }
5598                        }
5599                    }
5600                    result
5601                };
5602                let mut items = ::std::vec::Vec::new();
5603                for child in non_field_children {
5604                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5605                        <RightAssignmentListChildren as ::treesitter_types::FromNode>::from_node(
5606                            child, src,
5607                        )
5608                    })?);
5609                }
5610                items
5611            },
5612        })
5613    }
5614}
5615impl ::treesitter_types::Spanned for RightAssignmentList<'_> {
5616    fn span(&self) -> ::treesitter_types::Span {
5617        self.span
5618    }
5619}
5620#[derive(Debug, Clone, PartialEq, Eq)]
5621pub struct ScopeResolution<'tree> {
5622    pub span: ::treesitter_types::Span,
5623    pub name: Constant<'tree>,
5624    pub scope: ::core::option::Option<ScopeResolutionScope<'tree>>,
5625}
5626impl<'tree> ::treesitter_types::FromNode<'tree> for ScopeResolution<'tree> {
5627    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5628    fn from_node(
5629        node: ::treesitter_types::tree_sitter::Node<'tree>,
5630        src: &'tree [u8],
5631    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5632        debug_assert_eq!(node.kind(), "scope_resolution");
5633        Ok(Self {
5634            span: ::treesitter_types::Span::from(node),
5635            name: {
5636                let child = node
5637                    .child_by_field_name("name")
5638                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5639                ::treesitter_types::runtime::maybe_grow_stack(|| {
5640                    <Constant as ::treesitter_types::FromNode>::from_node(child, src)
5641                })?
5642            },
5643            scope: match node.child_by_field_name("scope") {
5644                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5645                    <ScopeResolutionScope as ::treesitter_types::FromNode>::from_node(child, src)
5646                })?),
5647                None => None,
5648            },
5649        })
5650    }
5651}
5652impl ::treesitter_types::Spanned for ScopeResolution<'_> {
5653    fn span(&self) -> ::treesitter_types::Span {
5654        self.span
5655    }
5656}
5657#[derive(Debug, Clone, PartialEq, Eq)]
5658pub struct Setter<'tree> {
5659    pub span: ::treesitter_types::Span,
5660    pub name: Identifier<'tree>,
5661}
5662impl<'tree> ::treesitter_types::FromNode<'tree> for Setter<'tree> {
5663    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5664    fn from_node(
5665        node: ::treesitter_types::tree_sitter::Node<'tree>,
5666        src: &'tree [u8],
5667    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5668        debug_assert_eq!(node.kind(), "setter");
5669        Ok(Self {
5670            span: ::treesitter_types::Span::from(node),
5671            name: {
5672                let child = node
5673                    .child_by_field_name("name")
5674                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5675                ::treesitter_types::runtime::maybe_grow_stack(|| {
5676                    <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5677                })?
5678            },
5679        })
5680    }
5681}
5682impl ::treesitter_types::Spanned for Setter<'_> {
5683    fn span(&self) -> ::treesitter_types::Span {
5684        self.span
5685    }
5686}
5687#[derive(Debug, Clone, PartialEq, Eq)]
5688pub struct SingletonClass<'tree> {
5689    pub span: ::treesitter_types::Span,
5690    pub body: ::core::option::Option<BodyStatement<'tree>>,
5691    pub value: Arg<'tree>,
5692}
5693impl<'tree> ::treesitter_types::FromNode<'tree> for SingletonClass<'tree> {
5694    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5695    fn from_node(
5696        node: ::treesitter_types::tree_sitter::Node<'tree>,
5697        src: &'tree [u8],
5698    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5699        debug_assert_eq!(node.kind(), "singleton_class");
5700        Ok(Self {
5701            span: ::treesitter_types::Span::from(node),
5702            body: match node.child_by_field_name("body") {
5703                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5704                    <BodyStatement as ::treesitter_types::FromNode>::from_node(child, src)
5705                })?),
5706                None => None,
5707            },
5708            value: {
5709                let child = node
5710                    .child_by_field_name("value")
5711                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5712                ::treesitter_types::runtime::maybe_grow_stack(|| {
5713                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
5714                })?
5715            },
5716        })
5717    }
5718}
5719impl ::treesitter_types::Spanned for SingletonClass<'_> {
5720    fn span(&self) -> ::treesitter_types::Span {
5721        self.span
5722    }
5723}
5724#[derive(Debug, Clone, PartialEq, Eq)]
5725pub struct SingletonMethod<'tree> {
5726    pub span: ::treesitter_types::Span,
5727    pub body: ::core::option::Option<SingletonMethodBody<'tree>>,
5728    pub name: MethodName<'tree>,
5729    pub object: SingletonMethodObject<'tree>,
5730    pub parameters: ::core::option::Option<MethodParameters<'tree>>,
5731}
5732impl<'tree> ::treesitter_types::FromNode<'tree> for SingletonMethod<'tree> {
5733    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5734    fn from_node(
5735        node: ::treesitter_types::tree_sitter::Node<'tree>,
5736        src: &'tree [u8],
5737    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5738        debug_assert_eq!(node.kind(), "singleton_method");
5739        Ok(Self {
5740            span: ::treesitter_types::Span::from(node),
5741            body: match node.child_by_field_name("body") {
5742                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5743                    <SingletonMethodBody as ::treesitter_types::FromNode>::from_node(child, src)
5744                })?),
5745                None => None,
5746            },
5747            name: {
5748                let child = node
5749                    .child_by_field_name("name")
5750                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5751                ::treesitter_types::runtime::maybe_grow_stack(|| {
5752                    <MethodName as ::treesitter_types::FromNode>::from_node(child, src)
5753                })?
5754            },
5755            object: {
5756                let child = node
5757                    .child_by_field_name("object")
5758                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5759                ::treesitter_types::runtime::maybe_grow_stack(|| {
5760                    <SingletonMethodObject as ::treesitter_types::FromNode>::from_node(child, src)
5761                })?
5762            },
5763            parameters: match node.child_by_field_name("parameters") {
5764                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5765                    <MethodParameters as ::treesitter_types::FromNode>::from_node(child, src)
5766                })?),
5767                None => None,
5768            },
5769        })
5770    }
5771}
5772impl ::treesitter_types::Spanned for SingletonMethod<'_> {
5773    fn span(&self) -> ::treesitter_types::Span {
5774        self.span
5775    }
5776}
5777#[derive(Debug, Clone, PartialEq, Eq)]
5778pub struct SplatArgument<'tree> {
5779    pub span: ::treesitter_types::Span,
5780    pub children: ::core::option::Option<Arg<'tree>>,
5781}
5782impl<'tree> ::treesitter_types::FromNode<'tree> for SplatArgument<'tree> {
5783    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5784    fn from_node(
5785        node: ::treesitter_types::tree_sitter::Node<'tree>,
5786        src: &'tree [u8],
5787    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5788        debug_assert_eq!(node.kind(), "splat_argument");
5789        Ok(Self {
5790            span: ::treesitter_types::Span::from(node),
5791            children: {
5792                #[allow(clippy::suspicious_else_formatting)]
5793                let non_field_children = {
5794                    let mut cursor = node.walk();
5795                    let mut result = ::std::vec::Vec::new();
5796                    if cursor.goto_first_child() {
5797                        loop {
5798                            if cursor.field_name().is_none()
5799                                && cursor.node().is_named()
5800                                && !cursor.node().is_extra()
5801                            {
5802                                result.push(cursor.node());
5803                            }
5804                            if !cursor.goto_next_sibling() {
5805                                break;
5806                            }
5807                        }
5808                    }
5809                    result
5810                };
5811                match non_field_children.first() {
5812                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5813                        <Arg as ::treesitter_types::FromNode>::from_node(child, src)
5814                    })?),
5815                    None => None,
5816                }
5817            },
5818        })
5819    }
5820}
5821impl ::treesitter_types::Spanned for SplatArgument<'_> {
5822    fn span(&self) -> ::treesitter_types::Span {
5823        self.span
5824    }
5825}
5826#[derive(Debug, Clone, PartialEq, Eq)]
5827pub struct SplatParameter<'tree> {
5828    pub span: ::treesitter_types::Span,
5829    pub name: ::core::option::Option<Identifier<'tree>>,
5830}
5831impl<'tree> ::treesitter_types::FromNode<'tree> for SplatParameter<'tree> {
5832    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5833    fn from_node(
5834        node: ::treesitter_types::tree_sitter::Node<'tree>,
5835        src: &'tree [u8],
5836    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5837        debug_assert_eq!(node.kind(), "splat_parameter");
5838        Ok(Self {
5839            span: ::treesitter_types::Span::from(node),
5840            name: match node.child_by_field_name("name") {
5841                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5842                    <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5843                })?),
5844                None => None,
5845            },
5846        })
5847    }
5848}
5849impl ::treesitter_types::Spanned for SplatParameter<'_> {
5850    fn span(&self) -> ::treesitter_types::Span {
5851        self.span
5852    }
5853}
5854#[derive(Debug, Clone, PartialEq, Eq)]
5855pub struct String<'tree> {
5856    pub span: ::treesitter_types::Span,
5857    pub children: ::std::vec::Vec<StringChildren<'tree>>,
5858}
5859impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
5860    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5861    fn from_node(
5862        node: ::treesitter_types::tree_sitter::Node<'tree>,
5863        src: &'tree [u8],
5864    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5865        debug_assert_eq!(node.kind(), "string");
5866        Ok(Self {
5867            span: ::treesitter_types::Span::from(node),
5868            children: {
5869                #[allow(clippy::suspicious_else_formatting)]
5870                let non_field_children = {
5871                    let mut cursor = node.walk();
5872                    let mut result = ::std::vec::Vec::new();
5873                    if cursor.goto_first_child() {
5874                        loop {
5875                            if cursor.field_name().is_none()
5876                                && cursor.node().is_named()
5877                                && !cursor.node().is_extra()
5878                            {
5879                                result.push(cursor.node());
5880                            }
5881                            if !cursor.goto_next_sibling() {
5882                                break;
5883                            }
5884                        }
5885                    }
5886                    result
5887                };
5888                let mut items = ::std::vec::Vec::new();
5889                for child in non_field_children {
5890                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5891                        <StringChildren as ::treesitter_types::FromNode>::from_node(child, src)
5892                    })?);
5893                }
5894                items
5895            },
5896        })
5897    }
5898}
5899impl ::treesitter_types::Spanned for String<'_> {
5900    fn span(&self) -> ::treesitter_types::Span {
5901        self.span
5902    }
5903}
5904#[derive(Debug, Clone, PartialEq, Eq)]
5905pub struct StringArray<'tree> {
5906    pub span: ::treesitter_types::Span,
5907    pub children: ::std::vec::Vec<BareString<'tree>>,
5908}
5909impl<'tree> ::treesitter_types::FromNode<'tree> for StringArray<'tree> {
5910    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5911    fn from_node(
5912        node: ::treesitter_types::tree_sitter::Node<'tree>,
5913        src: &'tree [u8],
5914    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5915        debug_assert_eq!(node.kind(), "string_array");
5916        Ok(Self {
5917            span: ::treesitter_types::Span::from(node),
5918            children: {
5919                #[allow(clippy::suspicious_else_formatting)]
5920                let non_field_children = {
5921                    let mut cursor = node.walk();
5922                    let mut result = ::std::vec::Vec::new();
5923                    if cursor.goto_first_child() {
5924                        loop {
5925                            if cursor.field_name().is_none()
5926                                && cursor.node().is_named()
5927                                && !cursor.node().is_extra()
5928                            {
5929                                result.push(cursor.node());
5930                            }
5931                            if !cursor.goto_next_sibling() {
5932                                break;
5933                            }
5934                        }
5935                    }
5936                    result
5937                };
5938                let mut items = ::std::vec::Vec::new();
5939                for child in non_field_children {
5940                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5941                        <BareString as ::treesitter_types::FromNode>::from_node(child, src)
5942                    })?);
5943                }
5944                items
5945            },
5946        })
5947    }
5948}
5949impl ::treesitter_types::Spanned for StringArray<'_> {
5950    fn span(&self) -> ::treesitter_types::Span {
5951        self.span
5952    }
5953}
5954#[derive(Debug, Clone, PartialEq, Eq)]
5955pub struct Subshell<'tree> {
5956    pub span: ::treesitter_types::Span,
5957    pub children: ::std::vec::Vec<SubshellChildren<'tree>>,
5958}
5959impl<'tree> ::treesitter_types::FromNode<'tree> for Subshell<'tree> {
5960    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5961    fn from_node(
5962        node: ::treesitter_types::tree_sitter::Node<'tree>,
5963        src: &'tree [u8],
5964    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5965        debug_assert_eq!(node.kind(), "subshell");
5966        Ok(Self {
5967            span: ::treesitter_types::Span::from(node),
5968            children: {
5969                #[allow(clippy::suspicious_else_formatting)]
5970                let non_field_children = {
5971                    let mut cursor = node.walk();
5972                    let mut result = ::std::vec::Vec::new();
5973                    if cursor.goto_first_child() {
5974                        loop {
5975                            if cursor.field_name().is_none()
5976                                && cursor.node().is_named()
5977                                && !cursor.node().is_extra()
5978                            {
5979                                result.push(cursor.node());
5980                            }
5981                            if !cursor.goto_next_sibling() {
5982                                break;
5983                            }
5984                        }
5985                    }
5986                    result
5987                };
5988                let mut items = ::std::vec::Vec::new();
5989                for child in non_field_children {
5990                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5991                        <SubshellChildren as ::treesitter_types::FromNode>::from_node(child, src)
5992                    })?);
5993                }
5994                items
5995            },
5996        })
5997    }
5998}
5999impl ::treesitter_types::Spanned for Subshell<'_> {
6000    fn span(&self) -> ::treesitter_types::Span {
6001        self.span
6002    }
6003}
6004#[derive(Debug, Clone, PartialEq, Eq)]
6005pub struct Superclass<'tree> {
6006    pub span: ::treesitter_types::Span,
6007    pub children: Expression<'tree>,
6008}
6009impl<'tree> ::treesitter_types::FromNode<'tree> for Superclass<'tree> {
6010    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6011    fn from_node(
6012        node: ::treesitter_types::tree_sitter::Node<'tree>,
6013        src: &'tree [u8],
6014    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6015        debug_assert_eq!(node.kind(), "superclass");
6016        Ok(Self {
6017            span: ::treesitter_types::Span::from(node),
6018            children: {
6019                #[allow(clippy::suspicious_else_formatting)]
6020                let non_field_children = {
6021                    let mut cursor = node.walk();
6022                    let mut result = ::std::vec::Vec::new();
6023                    if cursor.goto_first_child() {
6024                        loop {
6025                            if cursor.field_name().is_none()
6026                                && cursor.node().is_named()
6027                                && !cursor.node().is_extra()
6028                            {
6029                                result.push(cursor.node());
6030                            }
6031                            if !cursor.goto_next_sibling() {
6032                                break;
6033                            }
6034                        }
6035                    }
6036                    result
6037                };
6038                let child = if let Some(&c) = non_field_children.first() {
6039                    c
6040                } else {
6041                    let mut fallback_cursor = node.walk();
6042                    let mut fallback_child = None;
6043                    if fallback_cursor.goto_first_child() {
6044                        loop {
6045                            if fallback_cursor.field_name().is_none()
6046                                && !fallback_cursor.node().is_extra()
6047                            {
6048                                let candidate = fallback_cursor.node();
6049                                #[allow(clippy::needless_question_mark)]
6050                                if (|| -> ::core::result::Result<
6051                                    _,
6052                                    ::treesitter_types::ParseError,
6053                                > {
6054                                    let child = candidate;
6055                                    Ok(
6056                                        ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6057                                            child,
6058                                            src,
6059                                        ))?,
6060                                    )
6061                                })()
6062                                    .is_ok()
6063                                {
6064                                    fallback_child = Some(candidate);
6065                                    break;
6066                                }
6067                            }
6068                            if !fallback_cursor.goto_next_sibling() {
6069                                break;
6070                            }
6071                        }
6072                    }
6073                    if fallback_child.is_none() {
6074                        let mut cursor2 = node.walk();
6075                        if cursor2.goto_first_child() {
6076                            loop {
6077                                if cursor2.node().is_named() && !cursor2.node().is_extra() {
6078                                    let candidate = cursor2.node();
6079                                    #[allow(clippy::needless_question_mark)]
6080                                    if (|| -> ::core::result::Result<
6081                                        _,
6082                                        ::treesitter_types::ParseError,
6083                                    > {
6084                                        let child = candidate;
6085                                        Ok(
6086                                            ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6087                                                child,
6088                                                src,
6089                                            ))?,
6090                                        )
6091                                    })()
6092                                        .is_ok()
6093                                    {
6094                                        fallback_child = Some(candidate);
6095                                        break;
6096                                    }
6097                                }
6098                                if !cursor2.goto_next_sibling() {
6099                                    break;
6100                                }
6101                            }
6102                        }
6103                    }
6104                    fallback_child.ok_or_else(|| {
6105                        ::treesitter_types::ParseError::missing_field("children", node)
6106                    })?
6107                };
6108                ::treesitter_types::runtime::maybe_grow_stack(|| {
6109                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6110                })?
6111            },
6112        })
6113    }
6114}
6115impl ::treesitter_types::Spanned for Superclass<'_> {
6116    fn span(&self) -> ::treesitter_types::Span {
6117        self.span
6118    }
6119}
6120#[derive(Debug, Clone, PartialEq, Eq)]
6121pub struct SymbolArray<'tree> {
6122    pub span: ::treesitter_types::Span,
6123    pub children: ::std::vec::Vec<BareSymbol<'tree>>,
6124}
6125impl<'tree> ::treesitter_types::FromNode<'tree> for SymbolArray<'tree> {
6126    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6127    fn from_node(
6128        node: ::treesitter_types::tree_sitter::Node<'tree>,
6129        src: &'tree [u8],
6130    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6131        debug_assert_eq!(node.kind(), "symbol_array");
6132        Ok(Self {
6133            span: ::treesitter_types::Span::from(node),
6134            children: {
6135                #[allow(clippy::suspicious_else_formatting)]
6136                let non_field_children = {
6137                    let mut cursor = node.walk();
6138                    let mut result = ::std::vec::Vec::new();
6139                    if cursor.goto_first_child() {
6140                        loop {
6141                            if cursor.field_name().is_none()
6142                                && cursor.node().is_named()
6143                                && !cursor.node().is_extra()
6144                            {
6145                                result.push(cursor.node());
6146                            }
6147                            if !cursor.goto_next_sibling() {
6148                                break;
6149                            }
6150                        }
6151                    }
6152                    result
6153                };
6154                let mut items = ::std::vec::Vec::new();
6155                for child in non_field_children {
6156                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6157                        <BareSymbol as ::treesitter_types::FromNode>::from_node(child, src)
6158                    })?);
6159                }
6160                items
6161            },
6162        })
6163    }
6164}
6165impl ::treesitter_types::Spanned for SymbolArray<'_> {
6166    fn span(&self) -> ::treesitter_types::Span {
6167        self.span
6168    }
6169}
6170#[derive(Debug, Clone, PartialEq, Eq)]
6171pub struct TestPattern<'tree> {
6172    pub span: ::treesitter_types::Span,
6173    pub pattern: PatternTopExprBody<'tree>,
6174    pub value: Arg<'tree>,
6175}
6176impl<'tree> ::treesitter_types::FromNode<'tree> for TestPattern<'tree> {
6177    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6178    fn from_node(
6179        node: ::treesitter_types::tree_sitter::Node<'tree>,
6180        src: &'tree [u8],
6181    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6182        debug_assert_eq!(node.kind(), "test_pattern");
6183        Ok(Self {
6184            span: ::treesitter_types::Span::from(node),
6185            pattern: {
6186                let child = node.child_by_field_name("pattern").ok_or_else(|| {
6187                    ::treesitter_types::ParseError::missing_field("pattern", node)
6188                })?;
6189                ::treesitter_types::runtime::maybe_grow_stack(|| {
6190                    <PatternTopExprBody as ::treesitter_types::FromNode>::from_node(child, src)
6191                })?
6192            },
6193            value: {
6194                let child = node
6195                    .child_by_field_name("value")
6196                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
6197                ::treesitter_types::runtime::maybe_grow_stack(|| {
6198                    <Arg as ::treesitter_types::FromNode>::from_node(child, src)
6199                })?
6200            },
6201        })
6202    }
6203}
6204impl ::treesitter_types::Spanned for TestPattern<'_> {
6205    fn span(&self) -> ::treesitter_types::Span {
6206        self.span
6207    }
6208}
6209#[derive(Debug, Clone, PartialEq, Eq)]
6210pub struct Then<'tree> {
6211    pub span: ::treesitter_types::Span,
6212    pub children: ::std::vec::Vec<ThenChildren<'tree>>,
6213}
6214impl<'tree> ::treesitter_types::FromNode<'tree> for Then<'tree> {
6215    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6216    fn from_node(
6217        node: ::treesitter_types::tree_sitter::Node<'tree>,
6218        src: &'tree [u8],
6219    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6220        debug_assert_eq!(node.kind(), "then");
6221        Ok(Self {
6222            span: ::treesitter_types::Span::from(node),
6223            children: {
6224                #[allow(clippy::suspicious_else_formatting)]
6225                let non_field_children = {
6226                    let mut cursor = node.walk();
6227                    let mut result = ::std::vec::Vec::new();
6228                    if cursor.goto_first_child() {
6229                        loop {
6230                            if cursor.field_name().is_none()
6231                                && cursor.node().is_named()
6232                                && !cursor.node().is_extra()
6233                            {
6234                                result.push(cursor.node());
6235                            }
6236                            if !cursor.goto_next_sibling() {
6237                                break;
6238                            }
6239                        }
6240                    }
6241                    result
6242                };
6243                let mut items = ::std::vec::Vec::new();
6244                for child in non_field_children {
6245                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6246                        <ThenChildren as ::treesitter_types::FromNode>::from_node(child, src)
6247                    })?);
6248                }
6249                items
6250            },
6251        })
6252    }
6253}
6254impl ::treesitter_types::Spanned for Then<'_> {
6255    fn span(&self) -> ::treesitter_types::Span {
6256        self.span
6257    }
6258}
6259#[derive(Debug, Clone, PartialEq, Eq)]
6260pub struct Unary<'tree> {
6261    pub span: ::treesitter_types::Span,
6262    pub operand: UnaryOperand<'tree>,
6263    pub operator: UnaryOperator,
6264}
6265impl<'tree> ::treesitter_types::FromNode<'tree> for Unary<'tree> {
6266    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6267    fn from_node(
6268        node: ::treesitter_types::tree_sitter::Node<'tree>,
6269        src: &'tree [u8],
6270    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6271        debug_assert_eq!(node.kind(), "unary");
6272        Ok(Self {
6273            span: ::treesitter_types::Span::from(node),
6274            operand: {
6275                let child = node.child_by_field_name("operand").ok_or_else(|| {
6276                    ::treesitter_types::ParseError::missing_field("operand", node)
6277                })?;
6278                ::treesitter_types::runtime::maybe_grow_stack(|| {
6279                    <UnaryOperand as ::treesitter_types::FromNode>::from_node(child, src)
6280                })?
6281            },
6282            operator: {
6283                let child = node.child_by_field_name("operator").ok_or_else(|| {
6284                    ::treesitter_types::ParseError::missing_field("operator", node)
6285                })?;
6286                ::treesitter_types::runtime::maybe_grow_stack(|| {
6287                    <UnaryOperator as ::treesitter_types::FromNode>::from_node(child, src)
6288                })?
6289            },
6290        })
6291    }
6292}
6293impl ::treesitter_types::Spanned for Unary<'_> {
6294    fn span(&self) -> ::treesitter_types::Span {
6295        self.span
6296    }
6297}
6298#[derive(Debug, Clone, PartialEq, Eq)]
6299pub struct Undef<'tree> {
6300    pub span: ::treesitter_types::Span,
6301    pub children: ::std::vec::Vec<MethodName<'tree>>,
6302}
6303impl<'tree> ::treesitter_types::FromNode<'tree> for Undef<'tree> {
6304    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6305    fn from_node(
6306        node: ::treesitter_types::tree_sitter::Node<'tree>,
6307        src: &'tree [u8],
6308    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6309        debug_assert_eq!(node.kind(), "undef");
6310        Ok(Self {
6311            span: ::treesitter_types::Span::from(node),
6312            children: {
6313                #[allow(clippy::suspicious_else_formatting)]
6314                let non_field_children = {
6315                    let mut cursor = node.walk();
6316                    let mut result = ::std::vec::Vec::new();
6317                    if cursor.goto_first_child() {
6318                        loop {
6319                            if cursor.field_name().is_none()
6320                                && cursor.node().is_named()
6321                                && !cursor.node().is_extra()
6322                            {
6323                                result.push(cursor.node());
6324                            }
6325                            if !cursor.goto_next_sibling() {
6326                                break;
6327                            }
6328                        }
6329                    }
6330                    result
6331                };
6332                let mut items = ::std::vec::Vec::new();
6333                for child in non_field_children {
6334                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6335                        <MethodName as ::treesitter_types::FromNode>::from_node(child, src)
6336                    })?);
6337                }
6338                items
6339            },
6340        })
6341    }
6342}
6343impl ::treesitter_types::Spanned for Undef<'_> {
6344    fn span(&self) -> ::treesitter_types::Span {
6345        self.span
6346    }
6347}
6348#[derive(Debug, Clone, PartialEq, Eq)]
6349pub struct Unless<'tree> {
6350    pub span: ::treesitter_types::Span,
6351    pub alternative: ::core::option::Option<UnlessAlternative<'tree>>,
6352    pub condition: Statement<'tree>,
6353    pub consequence: ::core::option::Option<Then<'tree>>,
6354}
6355impl<'tree> ::treesitter_types::FromNode<'tree> for Unless<'tree> {
6356    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6357    fn from_node(
6358        node: ::treesitter_types::tree_sitter::Node<'tree>,
6359        src: &'tree [u8],
6360    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6361        debug_assert_eq!(node.kind(), "unless");
6362        Ok(Self {
6363            span: ::treesitter_types::Span::from(node),
6364            alternative: match node.child_by_field_name("alternative") {
6365                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6366                    <UnlessAlternative as ::treesitter_types::FromNode>::from_node(child, src)
6367                })?),
6368                None => None,
6369            },
6370            condition: {
6371                let child = node.child_by_field_name("condition").ok_or_else(|| {
6372                    ::treesitter_types::ParseError::missing_field("condition", node)
6373                })?;
6374                ::treesitter_types::runtime::maybe_grow_stack(|| {
6375                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6376                })?
6377            },
6378            consequence: match node.child_by_field_name("consequence") {
6379                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6380                    <Then as ::treesitter_types::FromNode>::from_node(child, src)
6381                })?),
6382                None => None,
6383            },
6384        })
6385    }
6386}
6387impl ::treesitter_types::Spanned for Unless<'_> {
6388    fn span(&self) -> ::treesitter_types::Span {
6389        self.span
6390    }
6391}
6392#[derive(Debug, Clone, PartialEq, Eq)]
6393pub struct UnlessGuard<'tree> {
6394    pub span: ::treesitter_types::Span,
6395    pub condition: Expression<'tree>,
6396}
6397impl<'tree> ::treesitter_types::FromNode<'tree> for UnlessGuard<'tree> {
6398    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6399    fn from_node(
6400        node: ::treesitter_types::tree_sitter::Node<'tree>,
6401        src: &'tree [u8],
6402    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6403        debug_assert_eq!(node.kind(), "unless_guard");
6404        Ok(Self {
6405            span: ::treesitter_types::Span::from(node),
6406            condition: {
6407                let child = node.child_by_field_name("condition").ok_or_else(|| {
6408                    ::treesitter_types::ParseError::missing_field("condition", node)
6409                })?;
6410                ::treesitter_types::runtime::maybe_grow_stack(|| {
6411                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6412                })?
6413            },
6414        })
6415    }
6416}
6417impl ::treesitter_types::Spanned for UnlessGuard<'_> {
6418    fn span(&self) -> ::treesitter_types::Span {
6419        self.span
6420    }
6421}
6422#[derive(Debug, Clone, PartialEq, Eq)]
6423pub struct UnlessModifier<'tree> {
6424    pub span: ::treesitter_types::Span,
6425    pub body: Statement<'tree>,
6426    pub condition: Expression<'tree>,
6427}
6428impl<'tree> ::treesitter_types::FromNode<'tree> for UnlessModifier<'tree> {
6429    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6430    fn from_node(
6431        node: ::treesitter_types::tree_sitter::Node<'tree>,
6432        src: &'tree [u8],
6433    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6434        debug_assert_eq!(node.kind(), "unless_modifier");
6435        Ok(Self {
6436            span: ::treesitter_types::Span::from(node),
6437            body: {
6438                let child = node
6439                    .child_by_field_name("body")
6440                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6441                ::treesitter_types::runtime::maybe_grow_stack(|| {
6442                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6443                })?
6444            },
6445            condition: {
6446                let child = node.child_by_field_name("condition").ok_or_else(|| {
6447                    ::treesitter_types::ParseError::missing_field("condition", node)
6448                })?;
6449                ::treesitter_types::runtime::maybe_grow_stack(|| {
6450                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6451                })?
6452            },
6453        })
6454    }
6455}
6456impl ::treesitter_types::Spanned for UnlessModifier<'_> {
6457    fn span(&self) -> ::treesitter_types::Span {
6458        self.span
6459    }
6460}
6461#[derive(Debug, Clone, PartialEq, Eq)]
6462pub struct Until<'tree> {
6463    pub span: ::treesitter_types::Span,
6464    pub body: Do<'tree>,
6465    pub condition: Statement<'tree>,
6466}
6467impl<'tree> ::treesitter_types::FromNode<'tree> for Until<'tree> {
6468    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6469    fn from_node(
6470        node: ::treesitter_types::tree_sitter::Node<'tree>,
6471        src: &'tree [u8],
6472    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6473        debug_assert_eq!(node.kind(), "until");
6474        Ok(Self {
6475            span: ::treesitter_types::Span::from(node),
6476            body: {
6477                let child = node
6478                    .child_by_field_name("body")
6479                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6480                ::treesitter_types::runtime::maybe_grow_stack(|| {
6481                    <Do as ::treesitter_types::FromNode>::from_node(child, src)
6482                })?
6483            },
6484            condition: {
6485                let child = node.child_by_field_name("condition").ok_or_else(|| {
6486                    ::treesitter_types::ParseError::missing_field("condition", node)
6487                })?;
6488                ::treesitter_types::runtime::maybe_grow_stack(|| {
6489                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6490                })?
6491            },
6492        })
6493    }
6494}
6495impl ::treesitter_types::Spanned for Until<'_> {
6496    fn span(&self) -> ::treesitter_types::Span {
6497        self.span
6498    }
6499}
6500#[derive(Debug, Clone, PartialEq, Eq)]
6501pub struct UntilModifier<'tree> {
6502    pub span: ::treesitter_types::Span,
6503    pub body: Statement<'tree>,
6504    pub condition: Expression<'tree>,
6505}
6506impl<'tree> ::treesitter_types::FromNode<'tree> for UntilModifier<'tree> {
6507    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6508    fn from_node(
6509        node: ::treesitter_types::tree_sitter::Node<'tree>,
6510        src: &'tree [u8],
6511    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6512        debug_assert_eq!(node.kind(), "until_modifier");
6513        Ok(Self {
6514            span: ::treesitter_types::Span::from(node),
6515            body: {
6516                let child = node
6517                    .child_by_field_name("body")
6518                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6519                ::treesitter_types::runtime::maybe_grow_stack(|| {
6520                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6521                })?
6522            },
6523            condition: {
6524                let child = node.child_by_field_name("condition").ok_or_else(|| {
6525                    ::treesitter_types::ParseError::missing_field("condition", node)
6526                })?;
6527                ::treesitter_types::runtime::maybe_grow_stack(|| {
6528                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6529                })?
6530            },
6531        })
6532    }
6533}
6534impl ::treesitter_types::Spanned for UntilModifier<'_> {
6535    fn span(&self) -> ::treesitter_types::Span {
6536        self.span
6537    }
6538}
6539#[derive(Debug, Clone, PartialEq, Eq)]
6540pub struct VariableReferencePattern<'tree> {
6541    pub span: ::treesitter_types::Span,
6542    pub name: VariableReferencePatternName<'tree>,
6543}
6544impl<'tree> ::treesitter_types::FromNode<'tree> for VariableReferencePattern<'tree> {
6545    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6546    fn from_node(
6547        node: ::treesitter_types::tree_sitter::Node<'tree>,
6548        src: &'tree [u8],
6549    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6550        debug_assert_eq!(node.kind(), "variable_reference_pattern");
6551        Ok(Self {
6552            span: ::treesitter_types::Span::from(node),
6553            name: {
6554                let child = node
6555                    .child_by_field_name("name")
6556                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6557                ::treesitter_types::runtime::maybe_grow_stack(|| {
6558                    <VariableReferencePatternName as ::treesitter_types::FromNode>::from_node(
6559                        child, src,
6560                    )
6561                })?
6562            },
6563        })
6564    }
6565}
6566impl ::treesitter_types::Spanned for VariableReferencePattern<'_> {
6567    fn span(&self) -> ::treesitter_types::Span {
6568        self.span
6569    }
6570}
6571#[derive(Debug, Clone, PartialEq, Eq)]
6572pub struct When<'tree> {
6573    pub span: ::treesitter_types::Span,
6574    pub body: ::core::option::Option<Then<'tree>>,
6575    pub pattern: ::std::vec::Vec<Pattern<'tree>>,
6576}
6577impl<'tree> ::treesitter_types::FromNode<'tree> for When<'tree> {
6578    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6579    fn from_node(
6580        node: ::treesitter_types::tree_sitter::Node<'tree>,
6581        src: &'tree [u8],
6582    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6583        debug_assert_eq!(node.kind(), "when");
6584        Ok(Self {
6585            span: ::treesitter_types::Span::from(node),
6586            body: match node.child_by_field_name("body") {
6587                Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6588                    <Then as ::treesitter_types::FromNode>::from_node(child, src)
6589                })?),
6590                None => None,
6591            },
6592            pattern: {
6593                let mut cursor = node.walk();
6594                let mut items = ::std::vec::Vec::new();
6595                for child in node.children_by_field_name("pattern", &mut cursor) {
6596                    items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6597                        <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
6598                    })?);
6599                }
6600                items
6601            },
6602        })
6603    }
6604}
6605impl ::treesitter_types::Spanned for When<'_> {
6606    fn span(&self) -> ::treesitter_types::Span {
6607        self.span
6608    }
6609}
6610#[derive(Debug, Clone, PartialEq, Eq)]
6611pub struct While<'tree> {
6612    pub span: ::treesitter_types::Span,
6613    pub body: Do<'tree>,
6614    pub condition: Statement<'tree>,
6615}
6616impl<'tree> ::treesitter_types::FromNode<'tree> for While<'tree> {
6617    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6618    fn from_node(
6619        node: ::treesitter_types::tree_sitter::Node<'tree>,
6620        src: &'tree [u8],
6621    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6622        debug_assert_eq!(node.kind(), "while");
6623        Ok(Self {
6624            span: ::treesitter_types::Span::from(node),
6625            body: {
6626                let child = node
6627                    .child_by_field_name("body")
6628                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6629                ::treesitter_types::runtime::maybe_grow_stack(|| {
6630                    <Do as ::treesitter_types::FromNode>::from_node(child, src)
6631                })?
6632            },
6633            condition: {
6634                let child = node.child_by_field_name("condition").ok_or_else(|| {
6635                    ::treesitter_types::ParseError::missing_field("condition", node)
6636                })?;
6637                ::treesitter_types::runtime::maybe_grow_stack(|| {
6638                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6639                })?
6640            },
6641        })
6642    }
6643}
6644impl ::treesitter_types::Spanned for While<'_> {
6645    fn span(&self) -> ::treesitter_types::Span {
6646        self.span
6647    }
6648}
6649#[derive(Debug, Clone, PartialEq, Eq)]
6650pub struct WhileModifier<'tree> {
6651    pub span: ::treesitter_types::Span,
6652    pub body: Statement<'tree>,
6653    pub condition: Expression<'tree>,
6654}
6655impl<'tree> ::treesitter_types::FromNode<'tree> for WhileModifier<'tree> {
6656    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6657    fn from_node(
6658        node: ::treesitter_types::tree_sitter::Node<'tree>,
6659        src: &'tree [u8],
6660    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6661        debug_assert_eq!(node.kind(), "while_modifier");
6662        Ok(Self {
6663            span: ::treesitter_types::Span::from(node),
6664            body: {
6665                let child = node
6666                    .child_by_field_name("body")
6667                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6668                ::treesitter_types::runtime::maybe_grow_stack(|| {
6669                    <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6670                })?
6671            },
6672            condition: {
6673                let child = node.child_by_field_name("condition").ok_or_else(|| {
6674                    ::treesitter_types::ParseError::missing_field("condition", node)
6675                })?;
6676                ::treesitter_types::runtime::maybe_grow_stack(|| {
6677                    <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6678                })?
6679            },
6680        })
6681    }
6682}
6683impl ::treesitter_types::Spanned for WhileModifier<'_> {
6684    fn span(&self) -> ::treesitter_types::Span {
6685        self.span
6686    }
6687}
6688#[derive(Debug, Clone, PartialEq, Eq)]
6689pub struct Yield<'tree> {
6690    pub span: ::treesitter_types::Span,
6691    pub children: ::core::option::Option<ArgumentList<'tree>>,
6692}
6693impl<'tree> ::treesitter_types::FromNode<'tree> for Yield<'tree> {
6694    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6695    fn from_node(
6696        node: ::treesitter_types::tree_sitter::Node<'tree>,
6697        src: &'tree [u8],
6698    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6699        debug_assert_eq!(node.kind(), "yield");
6700        Ok(Self {
6701            span: ::treesitter_types::Span::from(node),
6702            children: {
6703                #[allow(clippy::suspicious_else_formatting)]
6704                let non_field_children = {
6705                    let mut cursor = node.walk();
6706                    let mut result = ::std::vec::Vec::new();
6707                    if cursor.goto_first_child() {
6708                        loop {
6709                            if cursor.field_name().is_none()
6710                                && cursor.node().is_named()
6711                                && !cursor.node().is_extra()
6712                            {
6713                                result.push(cursor.node());
6714                            }
6715                            if !cursor.goto_next_sibling() {
6716                                break;
6717                            }
6718                        }
6719                    }
6720                    result
6721                };
6722                match non_field_children.first() {
6723                    Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6724                        <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
6725                    })?),
6726                    None => None,
6727                }
6728            },
6729        })
6730    }
6731}
6732impl ::treesitter_types::Spanned for Yield<'_> {
6733    fn span(&self) -> ::treesitter_types::Span {
6734        self.span
6735    }
6736}
6737#[derive(Debug, Clone, PartialEq, Eq)]
6738pub struct Character<'tree> {
6739    pub span: ::treesitter_types::Span,
6740    text: &'tree str,
6741}
6742impl<'tree> ::treesitter_types::FromNode<'tree> for Character<'tree> {
6743    fn from_node(
6744        node: ::treesitter_types::tree_sitter::Node<'tree>,
6745        src: &'tree [u8],
6746    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6747        debug_assert_eq!(node.kind(), "character");
6748        Ok(Self {
6749            span: ::treesitter_types::Span::from(node),
6750            text: node.utf8_text(src)?,
6751        })
6752    }
6753}
6754impl<'tree> ::treesitter_types::LeafNode<'tree> for Character<'tree> {
6755    fn text(&self) -> &'tree str {
6756        self.text
6757    }
6758}
6759impl ::treesitter_types::Spanned for Character<'_> {
6760    fn span(&self) -> ::treesitter_types::Span {
6761        self.span
6762    }
6763}
6764#[derive(Debug, Clone, PartialEq, Eq)]
6765pub struct ClassVariable<'tree> {
6766    pub span: ::treesitter_types::Span,
6767    text: &'tree str,
6768}
6769impl<'tree> ::treesitter_types::FromNode<'tree> for ClassVariable<'tree> {
6770    fn from_node(
6771        node: ::treesitter_types::tree_sitter::Node<'tree>,
6772        src: &'tree [u8],
6773    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6774        debug_assert_eq!(node.kind(), "class_variable");
6775        Ok(Self {
6776            span: ::treesitter_types::Span::from(node),
6777            text: node.utf8_text(src)?,
6778        })
6779    }
6780}
6781impl<'tree> ::treesitter_types::LeafNode<'tree> for ClassVariable<'tree> {
6782    fn text(&self) -> &'tree str {
6783        self.text
6784    }
6785}
6786impl ::treesitter_types::Spanned for ClassVariable<'_> {
6787    fn span(&self) -> ::treesitter_types::Span {
6788        self.span
6789    }
6790}
6791#[derive(Debug, Clone, PartialEq, Eq)]
6792pub struct Comment<'tree> {
6793    pub span: ::treesitter_types::Span,
6794    text: &'tree str,
6795}
6796impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
6797    fn from_node(
6798        node: ::treesitter_types::tree_sitter::Node<'tree>,
6799        src: &'tree [u8],
6800    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6801        debug_assert_eq!(node.kind(), "comment");
6802        Ok(Self {
6803            span: ::treesitter_types::Span::from(node),
6804            text: node.utf8_text(src)?,
6805        })
6806    }
6807}
6808impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
6809    fn text(&self) -> &'tree str {
6810        self.text
6811    }
6812}
6813impl ::treesitter_types::Spanned for Comment<'_> {
6814    fn span(&self) -> ::treesitter_types::Span {
6815        self.span
6816    }
6817}
6818#[derive(Debug, Clone, PartialEq, Eq)]
6819pub struct Encoding<'tree> {
6820    pub span: ::treesitter_types::Span,
6821    text: &'tree str,
6822}
6823impl<'tree> ::treesitter_types::FromNode<'tree> for Encoding<'tree> {
6824    fn from_node(
6825        node: ::treesitter_types::tree_sitter::Node<'tree>,
6826        src: &'tree [u8],
6827    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6828        debug_assert_eq!(node.kind(), "encoding");
6829        Ok(Self {
6830            span: ::treesitter_types::Span::from(node),
6831            text: node.utf8_text(src)?,
6832        })
6833    }
6834}
6835impl<'tree> ::treesitter_types::LeafNode<'tree> for Encoding<'tree> {
6836    fn text(&self) -> &'tree str {
6837        self.text
6838    }
6839}
6840impl ::treesitter_types::Spanned for Encoding<'_> {
6841    fn span(&self) -> ::treesitter_types::Span {
6842        self.span
6843    }
6844}
6845#[derive(Debug, Clone, PartialEq, Eq)]
6846pub struct EscapeSequence<'tree> {
6847    pub span: ::treesitter_types::Span,
6848    text: &'tree str,
6849}
6850impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
6851    fn from_node(
6852        node: ::treesitter_types::tree_sitter::Node<'tree>,
6853        src: &'tree [u8],
6854    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6855        debug_assert_eq!(node.kind(), "escape_sequence");
6856        Ok(Self {
6857            span: ::treesitter_types::Span::from(node),
6858            text: node.utf8_text(src)?,
6859        })
6860    }
6861}
6862impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
6863    fn text(&self) -> &'tree str {
6864        self.text
6865    }
6866}
6867impl ::treesitter_types::Spanned for EscapeSequence<'_> {
6868    fn span(&self) -> ::treesitter_types::Span {
6869        self.span
6870    }
6871}
6872#[derive(Debug, Clone, PartialEq, Eq)]
6873pub struct False<'tree> {
6874    pub span: ::treesitter_types::Span,
6875    text: &'tree str,
6876}
6877impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
6878    fn from_node(
6879        node: ::treesitter_types::tree_sitter::Node<'tree>,
6880        src: &'tree [u8],
6881    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6882        debug_assert_eq!(node.kind(), "false");
6883        Ok(Self {
6884            span: ::treesitter_types::Span::from(node),
6885            text: node.utf8_text(src)?,
6886        })
6887    }
6888}
6889impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
6890    fn text(&self) -> &'tree str {
6891        self.text
6892    }
6893}
6894impl ::treesitter_types::Spanned for False<'_> {
6895    fn span(&self) -> ::treesitter_types::Span {
6896        self.span
6897    }
6898}
6899#[derive(Debug, Clone, PartialEq, Eq)]
6900pub struct File<'tree> {
6901    pub span: ::treesitter_types::Span,
6902    text: &'tree str,
6903}
6904impl<'tree> ::treesitter_types::FromNode<'tree> for File<'tree> {
6905    fn from_node(
6906        node: ::treesitter_types::tree_sitter::Node<'tree>,
6907        src: &'tree [u8],
6908    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6909        debug_assert_eq!(node.kind(), "file");
6910        Ok(Self {
6911            span: ::treesitter_types::Span::from(node),
6912            text: node.utf8_text(src)?,
6913        })
6914    }
6915}
6916impl<'tree> ::treesitter_types::LeafNode<'tree> for File<'tree> {
6917    fn text(&self) -> &'tree str {
6918        self.text
6919    }
6920}
6921impl ::treesitter_types::Spanned for File<'_> {
6922    fn span(&self) -> ::treesitter_types::Span {
6923        self.span
6924    }
6925}
6926#[derive(Debug, Clone, PartialEq, Eq)]
6927pub struct Float<'tree> {
6928    pub span: ::treesitter_types::Span,
6929    text: &'tree str,
6930}
6931impl<'tree> ::treesitter_types::FromNode<'tree> for Float<'tree> {
6932    fn from_node(
6933        node: ::treesitter_types::tree_sitter::Node<'tree>,
6934        src: &'tree [u8],
6935    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6936        debug_assert_eq!(node.kind(), "float");
6937        Ok(Self {
6938            span: ::treesitter_types::Span::from(node),
6939            text: node.utf8_text(src)?,
6940        })
6941    }
6942}
6943impl<'tree> ::treesitter_types::LeafNode<'tree> for Float<'tree> {
6944    fn text(&self) -> &'tree str {
6945        self.text
6946    }
6947}
6948impl ::treesitter_types::Spanned for Float<'_> {
6949    fn span(&self) -> ::treesitter_types::Span {
6950        self.span
6951    }
6952}
6953#[derive(Debug, Clone, PartialEq, Eq)]
6954pub struct GlobalVariable<'tree> {
6955    pub span: ::treesitter_types::Span,
6956    text: &'tree str,
6957}
6958impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalVariable<'tree> {
6959    fn from_node(
6960        node: ::treesitter_types::tree_sitter::Node<'tree>,
6961        src: &'tree [u8],
6962    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6963        debug_assert_eq!(node.kind(), "global_variable");
6964        Ok(Self {
6965            span: ::treesitter_types::Span::from(node),
6966            text: node.utf8_text(src)?,
6967        })
6968    }
6969}
6970impl<'tree> ::treesitter_types::LeafNode<'tree> for GlobalVariable<'tree> {
6971    fn text(&self) -> &'tree str {
6972        self.text
6973    }
6974}
6975impl ::treesitter_types::Spanned for GlobalVariable<'_> {
6976    fn span(&self) -> ::treesitter_types::Span {
6977        self.span
6978    }
6979}
6980#[derive(Debug, Clone, PartialEq, Eq)]
6981pub struct HeredocBeginning<'tree> {
6982    pub span: ::treesitter_types::Span,
6983    text: &'tree str,
6984}
6985impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBeginning<'tree> {
6986    fn from_node(
6987        node: ::treesitter_types::tree_sitter::Node<'tree>,
6988        src: &'tree [u8],
6989    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6990        debug_assert_eq!(node.kind(), "heredoc_beginning");
6991        Ok(Self {
6992            span: ::treesitter_types::Span::from(node),
6993            text: node.utf8_text(src)?,
6994        })
6995    }
6996}
6997impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocBeginning<'tree> {
6998    fn text(&self) -> &'tree str {
6999        self.text
7000    }
7001}
7002impl ::treesitter_types::Spanned for HeredocBeginning<'_> {
7003    fn span(&self) -> ::treesitter_types::Span {
7004        self.span
7005    }
7006}
7007#[derive(Debug, Clone, PartialEq, Eq)]
7008pub struct HeredocContent<'tree> {
7009    pub span: ::treesitter_types::Span,
7010    text: &'tree str,
7011}
7012impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocContent<'tree> {
7013    fn from_node(
7014        node: ::treesitter_types::tree_sitter::Node<'tree>,
7015        src: &'tree [u8],
7016    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7017        debug_assert_eq!(node.kind(), "heredoc_content");
7018        Ok(Self {
7019            span: ::treesitter_types::Span::from(node),
7020            text: node.utf8_text(src)?,
7021        })
7022    }
7023}
7024impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocContent<'tree> {
7025    fn text(&self) -> &'tree str {
7026        self.text
7027    }
7028}
7029impl ::treesitter_types::Spanned for HeredocContent<'_> {
7030    fn span(&self) -> ::treesitter_types::Span {
7031        self.span
7032    }
7033}
7034#[derive(Debug, Clone, PartialEq, Eq)]
7035pub struct HeredocEnd<'tree> {
7036    pub span: ::treesitter_types::Span,
7037    text: &'tree str,
7038}
7039impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocEnd<'tree> {
7040    fn from_node(
7041        node: ::treesitter_types::tree_sitter::Node<'tree>,
7042        src: &'tree [u8],
7043    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7044        debug_assert_eq!(node.kind(), "heredoc_end");
7045        Ok(Self {
7046            span: ::treesitter_types::Span::from(node),
7047            text: node.utf8_text(src)?,
7048        })
7049    }
7050}
7051impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocEnd<'tree> {
7052    fn text(&self) -> &'tree str {
7053        self.text
7054    }
7055}
7056impl ::treesitter_types::Spanned for HeredocEnd<'_> {
7057    fn span(&self) -> ::treesitter_types::Span {
7058        self.span
7059    }
7060}
7061#[derive(Debug, Clone, PartialEq, Eq)]
7062pub struct InstanceVariable<'tree> {
7063    pub span: ::treesitter_types::Span,
7064    text: &'tree str,
7065}
7066impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceVariable<'tree> {
7067    fn from_node(
7068        node: ::treesitter_types::tree_sitter::Node<'tree>,
7069        src: &'tree [u8],
7070    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7071        debug_assert_eq!(node.kind(), "instance_variable");
7072        Ok(Self {
7073            span: ::treesitter_types::Span::from(node),
7074            text: node.utf8_text(src)?,
7075        })
7076    }
7077}
7078impl<'tree> ::treesitter_types::LeafNode<'tree> for InstanceVariable<'tree> {
7079    fn text(&self) -> &'tree str {
7080        self.text
7081    }
7082}
7083impl ::treesitter_types::Spanned for InstanceVariable<'_> {
7084    fn span(&self) -> ::treesitter_types::Span {
7085        self.span
7086    }
7087}
7088#[derive(Debug, Clone, PartialEq, Eq)]
7089pub struct Integer<'tree> {
7090    pub span: ::treesitter_types::Span,
7091    text: &'tree str,
7092}
7093impl<'tree> ::treesitter_types::FromNode<'tree> for Integer<'tree> {
7094    fn from_node(
7095        node: ::treesitter_types::tree_sitter::Node<'tree>,
7096        src: &'tree [u8],
7097    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7098        debug_assert_eq!(node.kind(), "integer");
7099        Ok(Self {
7100            span: ::treesitter_types::Span::from(node),
7101            text: node.utf8_text(src)?,
7102        })
7103    }
7104}
7105impl<'tree> ::treesitter_types::LeafNode<'tree> for Integer<'tree> {
7106    fn text(&self) -> &'tree str {
7107        self.text
7108    }
7109}
7110impl ::treesitter_types::Spanned for Integer<'_> {
7111    fn span(&self) -> ::treesitter_types::Span {
7112        self.span
7113    }
7114}
7115#[derive(Debug, Clone, PartialEq, Eq)]
7116pub struct Line<'tree> {
7117    pub span: ::treesitter_types::Span,
7118    text: &'tree str,
7119}
7120impl<'tree> ::treesitter_types::FromNode<'tree> for Line<'tree> {
7121    fn from_node(
7122        node: ::treesitter_types::tree_sitter::Node<'tree>,
7123        src: &'tree [u8],
7124    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7125        debug_assert_eq!(node.kind(), "line");
7126        Ok(Self {
7127            span: ::treesitter_types::Span::from(node),
7128            text: node.utf8_text(src)?,
7129        })
7130    }
7131}
7132impl<'tree> ::treesitter_types::LeafNode<'tree> for Line<'tree> {
7133    fn text(&self) -> &'tree str {
7134        self.text
7135    }
7136}
7137impl ::treesitter_types::Spanned for Line<'_> {
7138    fn span(&self) -> ::treesitter_types::Span {
7139        self.span
7140    }
7141}
7142#[derive(Debug, Clone, PartialEq, Eq)]
7143pub struct SelfType<'tree> {
7144    pub span: ::treesitter_types::Span,
7145    text: &'tree str,
7146}
7147impl<'tree> ::treesitter_types::FromNode<'tree> for SelfType<'tree> {
7148    fn from_node(
7149        node: ::treesitter_types::tree_sitter::Node<'tree>,
7150        src: &'tree [u8],
7151    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7152        debug_assert_eq!(node.kind(), "self");
7153        Ok(Self {
7154            span: ::treesitter_types::Span::from(node),
7155            text: node.utf8_text(src)?,
7156        })
7157    }
7158}
7159impl<'tree> ::treesitter_types::LeafNode<'tree> for SelfType<'tree> {
7160    fn text(&self) -> &'tree str {
7161        self.text
7162    }
7163}
7164impl ::treesitter_types::Spanned for SelfType<'_> {
7165    fn span(&self) -> ::treesitter_types::Span {
7166        self.span
7167    }
7168}
7169#[derive(Debug, Clone, PartialEq, Eq)]
7170pub struct SimpleSymbol<'tree> {
7171    pub span: ::treesitter_types::Span,
7172    text: &'tree str,
7173}
7174impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleSymbol<'tree> {
7175    fn from_node(
7176        node: ::treesitter_types::tree_sitter::Node<'tree>,
7177        src: &'tree [u8],
7178    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7179        debug_assert_eq!(node.kind(), "simple_symbol");
7180        Ok(Self {
7181            span: ::treesitter_types::Span::from(node),
7182            text: node.utf8_text(src)?,
7183        })
7184    }
7185}
7186impl<'tree> ::treesitter_types::LeafNode<'tree> for SimpleSymbol<'tree> {
7187    fn text(&self) -> &'tree str {
7188        self.text
7189    }
7190}
7191impl ::treesitter_types::Spanned for SimpleSymbol<'_> {
7192    fn span(&self) -> ::treesitter_types::Span {
7193        self.span
7194    }
7195}
7196#[derive(Debug, Clone, PartialEq, Eq)]
7197pub struct StringContent<'tree> {
7198    pub span: ::treesitter_types::Span,
7199    text: &'tree str,
7200}
7201impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
7202    fn from_node(
7203        node: ::treesitter_types::tree_sitter::Node<'tree>,
7204        src: &'tree [u8],
7205    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7206        debug_assert_eq!(node.kind(), "string_content");
7207        Ok(Self {
7208            span: ::treesitter_types::Span::from(node),
7209            text: node.utf8_text(src)?,
7210        })
7211    }
7212}
7213impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
7214    fn text(&self) -> &'tree str {
7215        self.text
7216    }
7217}
7218impl ::treesitter_types::Spanned for StringContent<'_> {
7219    fn span(&self) -> ::treesitter_types::Span {
7220        self.span
7221    }
7222}
7223#[derive(Debug, Clone, PartialEq, Eq)]
7224pub struct Super<'tree> {
7225    pub span: ::treesitter_types::Span,
7226    text: &'tree str,
7227}
7228impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
7229    fn from_node(
7230        node: ::treesitter_types::tree_sitter::Node<'tree>,
7231        src: &'tree [u8],
7232    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7233        debug_assert_eq!(node.kind(), "super");
7234        Ok(Self {
7235            span: ::treesitter_types::Span::from(node),
7236            text: node.utf8_text(src)?,
7237        })
7238    }
7239}
7240impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
7241    fn text(&self) -> &'tree str {
7242        self.text
7243    }
7244}
7245impl ::treesitter_types::Spanned for Super<'_> {
7246    fn span(&self) -> ::treesitter_types::Span {
7247        self.span
7248    }
7249}
7250#[derive(Debug, Clone, PartialEq, Eq)]
7251pub struct True<'tree> {
7252    pub span: ::treesitter_types::Span,
7253    text: &'tree str,
7254}
7255impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
7256    fn from_node(
7257        node: ::treesitter_types::tree_sitter::Node<'tree>,
7258        src: &'tree [u8],
7259    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7260        debug_assert_eq!(node.kind(), "true");
7261        Ok(Self {
7262            span: ::treesitter_types::Span::from(node),
7263            text: node.utf8_text(src)?,
7264        })
7265    }
7266}
7267impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
7268    fn text(&self) -> &'tree str {
7269        self.text
7270    }
7271}
7272impl ::treesitter_types::Spanned for True<'_> {
7273    fn span(&self) -> ::treesitter_types::Span {
7274        self.span
7275    }
7276}
7277#[derive(Debug, Clone, PartialEq, Eq)]
7278pub struct Uninterpreted<'tree> {
7279    pub span: ::treesitter_types::Span,
7280    text: &'tree str,
7281}
7282impl<'tree> ::treesitter_types::FromNode<'tree> for Uninterpreted<'tree> {
7283    fn from_node(
7284        node: ::treesitter_types::tree_sitter::Node<'tree>,
7285        src: &'tree [u8],
7286    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7287        debug_assert_eq!(node.kind(), "uninterpreted");
7288        Ok(Self {
7289            span: ::treesitter_types::Span::from(node),
7290            text: node.utf8_text(src)?,
7291        })
7292    }
7293}
7294impl<'tree> ::treesitter_types::LeafNode<'tree> for Uninterpreted<'tree> {
7295    fn text(&self) -> &'tree str {
7296        self.text
7297    }
7298}
7299impl ::treesitter_types::Spanned for Uninterpreted<'_> {
7300    fn span(&self) -> ::treesitter_types::Span {
7301        self.span
7302    }
7303}
7304#[derive(Debug, Clone, PartialEq, Eq)]
7305pub enum ArgumentListChildren<'tree> {
7306    Expression(::std::boxed::Box<Expression<'tree>>),
7307    BlockArgument(::std::boxed::Box<BlockArgument<'tree>>),
7308    ForwardArgument(::std::boxed::Box<ForwardArgument<'tree>>),
7309    HashSplatArgument(::std::boxed::Box<HashSplatArgument<'tree>>),
7310    Pair(::std::boxed::Box<Pair<'tree>>),
7311    SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
7312}
7313impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentListChildren<'tree> {
7314    #[allow(clippy::collapsible_else_if)]
7315    fn from_node(
7316        node: ::treesitter_types::tree_sitter::Node<'tree>,
7317        src: &'tree [u8],
7318    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7319        match node.kind() {
7320            "block_argument" => Ok(Self::BlockArgument(::std::boxed::Box::new(
7321                ::treesitter_types::runtime::maybe_grow_stack(|| {
7322                    <BlockArgument as ::treesitter_types::FromNode>::from_node(node, src)
7323                })?,
7324            ))),
7325            "forward_argument" => Ok(Self::ForwardArgument(::std::boxed::Box::new(
7326                ::treesitter_types::runtime::maybe_grow_stack(|| {
7327                    <ForwardArgument as ::treesitter_types::FromNode>::from_node(node, src)
7328                })?,
7329            ))),
7330            "hash_splat_argument" => Ok(Self::HashSplatArgument(::std::boxed::Box::new(
7331                ::treesitter_types::runtime::maybe_grow_stack(|| {
7332                    <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
7333                })?,
7334            ))),
7335            "pair" => Ok(Self::Pair(::std::boxed::Box::new(
7336                ::treesitter_types::runtime::maybe_grow_stack(|| {
7337                    <Pair as ::treesitter_types::FromNode>::from_node(node, src)
7338                })?,
7339            ))),
7340            "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
7341                ::treesitter_types::runtime::maybe_grow_stack(|| {
7342                    <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
7343                })?,
7344            ))),
7345            _other => {
7346                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7347                    <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7348                }) {
7349                    Ok(Self::Expression(::std::boxed::Box::new(v)))
7350                } else {
7351                    Err(::treesitter_types::ParseError::unexpected_kind(
7352                        _other, node,
7353                    ))
7354                }
7355            }
7356        }
7357    }
7358}
7359impl ::treesitter_types::Spanned for ArgumentListChildren<'_> {
7360    fn span(&self) -> ::treesitter_types::Span {
7361        match self {
7362            Self::Expression(inner) => inner.span(),
7363            Self::BlockArgument(inner) => inner.span(),
7364            Self::ForwardArgument(inner) => inner.span(),
7365            Self::HashSplatArgument(inner) => inner.span(),
7366            Self::Pair(inner) => inner.span(),
7367            Self::SplatArgument(inner) => inner.span(),
7368        }
7369    }
7370}
7371#[derive(Debug, Clone, PartialEq, Eq)]
7372pub enum ArrayChildren<'tree> {
7373    Expression(::std::boxed::Box<Expression<'tree>>),
7374    BlockArgument(::std::boxed::Box<BlockArgument<'tree>>),
7375    ForwardArgument(::std::boxed::Box<ForwardArgument<'tree>>),
7376    HashSplatArgument(::std::boxed::Box<HashSplatArgument<'tree>>),
7377    Pair(::std::boxed::Box<Pair<'tree>>),
7378    SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
7379}
7380impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayChildren<'tree> {
7381    #[allow(clippy::collapsible_else_if)]
7382    fn from_node(
7383        node: ::treesitter_types::tree_sitter::Node<'tree>,
7384        src: &'tree [u8],
7385    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7386        match node.kind() {
7387            "block_argument" => Ok(Self::BlockArgument(::std::boxed::Box::new(
7388                ::treesitter_types::runtime::maybe_grow_stack(|| {
7389                    <BlockArgument as ::treesitter_types::FromNode>::from_node(node, src)
7390                })?,
7391            ))),
7392            "forward_argument" => Ok(Self::ForwardArgument(::std::boxed::Box::new(
7393                ::treesitter_types::runtime::maybe_grow_stack(|| {
7394                    <ForwardArgument as ::treesitter_types::FromNode>::from_node(node, src)
7395                })?,
7396            ))),
7397            "hash_splat_argument" => Ok(Self::HashSplatArgument(::std::boxed::Box::new(
7398                ::treesitter_types::runtime::maybe_grow_stack(|| {
7399                    <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
7400                })?,
7401            ))),
7402            "pair" => Ok(Self::Pair(::std::boxed::Box::new(
7403                ::treesitter_types::runtime::maybe_grow_stack(|| {
7404                    <Pair as ::treesitter_types::FromNode>::from_node(node, src)
7405                })?,
7406            ))),
7407            "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
7408                ::treesitter_types::runtime::maybe_grow_stack(|| {
7409                    <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
7410                })?,
7411            ))),
7412            _other => {
7413                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7414                    <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7415                }) {
7416                    Ok(Self::Expression(::std::boxed::Box::new(v)))
7417                } else {
7418                    Err(::treesitter_types::ParseError::unexpected_kind(
7419                        _other, node,
7420                    ))
7421                }
7422            }
7423        }
7424    }
7425}
7426impl ::treesitter_types::Spanned for ArrayChildren<'_> {
7427    fn span(&self) -> ::treesitter_types::Span {
7428        match self {
7429            Self::Expression(inner) => inner.span(),
7430            Self::BlockArgument(inner) => inner.span(),
7431            Self::ForwardArgument(inner) => inner.span(),
7432            Self::HashSplatArgument(inner) => inner.span(),
7433            Self::Pair(inner) => inner.span(),
7434            Self::SplatArgument(inner) => inner.span(),
7435        }
7436    }
7437}
7438#[derive(Debug, Clone, PartialEq, Eq)]
7439pub enum ArrayPatternChildren<'tree> {
7440    PatternExpr(::std::boxed::Box<PatternExpr<'tree>>),
7441    SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
7442}
7443impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPatternChildren<'tree> {
7444    #[allow(clippy::collapsible_else_if)]
7445    fn from_node(
7446        node: ::treesitter_types::tree_sitter::Node<'tree>,
7447        src: &'tree [u8],
7448    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7449        match node.kind() {
7450            "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
7451                ::treesitter_types::runtime::maybe_grow_stack(|| {
7452                    <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
7453                })?,
7454            ))),
7455            _other => {
7456                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7457                    <PatternExpr as ::treesitter_types::FromNode>::from_node(node, src)
7458                }) {
7459                    Ok(Self::PatternExpr(::std::boxed::Box::new(v)))
7460                } else {
7461                    Err(::treesitter_types::ParseError::unexpected_kind(
7462                        _other, node,
7463                    ))
7464                }
7465            }
7466        }
7467    }
7468}
7469impl ::treesitter_types::Spanned for ArrayPatternChildren<'_> {
7470    fn span(&self) -> ::treesitter_types::Span {
7471        match self {
7472            Self::PatternExpr(inner) => inner.span(),
7473            Self::SplatParameter(inner) => inner.span(),
7474        }
7475    }
7476}
7477#[derive(Debug, Clone, PartialEq, Eq)]
7478pub enum AssignmentLeft<'tree> {
7479    Lhs(::std::boxed::Box<Lhs<'tree>>),
7480    LeftAssignmentList(::std::boxed::Box<LeftAssignmentList<'tree>>),
7481}
7482impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentLeft<'tree> {
7483    #[allow(clippy::collapsible_else_if)]
7484    fn from_node(
7485        node: ::treesitter_types::tree_sitter::Node<'tree>,
7486        src: &'tree [u8],
7487    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7488        match node.kind() {
7489            "left_assignment_list" => Ok(Self::LeftAssignmentList(::std::boxed::Box::new(
7490                ::treesitter_types::runtime::maybe_grow_stack(|| {
7491                    <LeftAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)
7492                })?,
7493            ))),
7494            _other => {
7495                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7496                    <Lhs as ::treesitter_types::FromNode>::from_node(node, src)
7497                }) {
7498                    Ok(Self::Lhs(::std::boxed::Box::new(v)))
7499                } else {
7500                    Err(::treesitter_types::ParseError::unexpected_kind(
7501                        _other, node,
7502                    ))
7503                }
7504            }
7505        }
7506    }
7507}
7508impl ::treesitter_types::Spanned for AssignmentLeft<'_> {
7509    fn span(&self) -> ::treesitter_types::Span {
7510        match self {
7511            Self::Lhs(inner) => inner.span(),
7512            Self::LeftAssignmentList(inner) => inner.span(),
7513        }
7514    }
7515}
7516#[derive(Debug, Clone, PartialEq, Eq)]
7517pub enum AssignmentRight<'tree> {
7518    Expression(::std::boxed::Box<Expression<'tree>>),
7519    RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
7520    RightAssignmentList(::std::boxed::Box<RightAssignmentList<'tree>>),
7521    SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
7522}
7523impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentRight<'tree> {
7524    #[allow(clippy::collapsible_else_if)]
7525    fn from_node(
7526        node: ::treesitter_types::tree_sitter::Node<'tree>,
7527        src: &'tree [u8],
7528    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7529        match node.kind() {
7530            "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
7531                ::treesitter_types::runtime::maybe_grow_stack(|| {
7532                    <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)
7533                })?,
7534            ))),
7535            "right_assignment_list" => Ok(Self::RightAssignmentList(::std::boxed::Box::new(
7536                ::treesitter_types::runtime::maybe_grow_stack(|| {
7537                    <RightAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)
7538                })?,
7539            ))),
7540            "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
7541                ::treesitter_types::runtime::maybe_grow_stack(|| {
7542                    <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
7543                })?,
7544            ))),
7545            _other => {
7546                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7547                    <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7548                }) {
7549                    Ok(Self::Expression(::std::boxed::Box::new(v)))
7550                } else {
7551                    Err(::treesitter_types::ParseError::unexpected_kind(
7552                        _other, node,
7553                    ))
7554                }
7555            }
7556        }
7557    }
7558}
7559impl ::treesitter_types::Spanned for AssignmentRight<'_> {
7560    fn span(&self) -> ::treesitter_types::Span {
7561        match self {
7562            Self::Expression(inner) => inner.span(),
7563            Self::RescueModifier(inner) => inner.span(),
7564            Self::RightAssignmentList(inner) => inner.span(),
7565            Self::SplatArgument(inner) => inner.span(),
7566        }
7567    }
7568}
7569#[derive(Debug, Clone, PartialEq, Eq)]
7570pub enum BareStringChildren<'tree> {
7571    EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
7572    Interpolation(::std::boxed::Box<Interpolation<'tree>>),
7573    StringContent(::std::boxed::Box<StringContent<'tree>>),
7574}
7575impl<'tree> ::treesitter_types::FromNode<'tree> for BareStringChildren<'tree> {
7576    #[allow(clippy::collapsible_else_if)]
7577    fn from_node(
7578        node: ::treesitter_types::tree_sitter::Node<'tree>,
7579        src: &'tree [u8],
7580    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7581        match node.kind() {
7582            "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
7583                ::treesitter_types::runtime::maybe_grow_stack(|| {
7584                    <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
7585                })?,
7586            ))),
7587            "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
7588                ::treesitter_types::runtime::maybe_grow_stack(|| {
7589                    <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
7590                })?,
7591            ))),
7592            "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
7593                ::treesitter_types::runtime::maybe_grow_stack(|| {
7594                    <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
7595                })?,
7596            ))),
7597            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7598        }
7599    }
7600}
7601impl ::treesitter_types::Spanned for BareStringChildren<'_> {
7602    fn span(&self) -> ::treesitter_types::Span {
7603        match self {
7604            Self::EscapeSequence(inner) => inner.span(),
7605            Self::Interpolation(inner) => inner.span(),
7606            Self::StringContent(inner) => inner.span(),
7607        }
7608    }
7609}
7610#[derive(Debug, Clone, PartialEq, Eq)]
7611pub enum BareSymbolChildren<'tree> {
7612    EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
7613    Interpolation(::std::boxed::Box<Interpolation<'tree>>),
7614    StringContent(::std::boxed::Box<StringContent<'tree>>),
7615}
7616impl<'tree> ::treesitter_types::FromNode<'tree> for BareSymbolChildren<'tree> {
7617    #[allow(clippy::collapsible_else_if)]
7618    fn from_node(
7619        node: ::treesitter_types::tree_sitter::Node<'tree>,
7620        src: &'tree [u8],
7621    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7622        match node.kind() {
7623            "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
7624                ::treesitter_types::runtime::maybe_grow_stack(|| {
7625                    <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
7626                })?,
7627            ))),
7628            "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
7629                ::treesitter_types::runtime::maybe_grow_stack(|| {
7630                    <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
7631                })?,
7632            ))),
7633            "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
7634                ::treesitter_types::runtime::maybe_grow_stack(|| {
7635                    <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
7636                })?,
7637            ))),
7638            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7639        }
7640    }
7641}
7642impl ::treesitter_types::Spanned for BareSymbolChildren<'_> {
7643    fn span(&self) -> ::treesitter_types::Span {
7644        match self {
7645            Self::EscapeSequence(inner) => inner.span(),
7646            Self::Interpolation(inner) => inner.span(),
7647            Self::StringContent(inner) => inner.span(),
7648        }
7649    }
7650}
7651#[derive(Debug, Clone, PartialEq, Eq)]
7652pub enum BeginChildren<'tree> {
7653    Statement(::std::boxed::Box<Statement<'tree>>),
7654    Else(::std::boxed::Box<Else<'tree>>),
7655    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7656    Ensure(::std::boxed::Box<Ensure<'tree>>),
7657    Rescue(::std::boxed::Box<Rescue<'tree>>),
7658}
7659impl<'tree> ::treesitter_types::FromNode<'tree> for BeginChildren<'tree> {
7660    #[allow(clippy::collapsible_else_if)]
7661    fn from_node(
7662        node: ::treesitter_types::tree_sitter::Node<'tree>,
7663        src: &'tree [u8],
7664    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7665        match node.kind() {
7666            "else" => Ok(Self::Else(::std::boxed::Box::new(
7667                ::treesitter_types::runtime::maybe_grow_stack(|| {
7668                    <Else as ::treesitter_types::FromNode>::from_node(node, src)
7669                })?,
7670            ))),
7671            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7672                ::treesitter_types::runtime::maybe_grow_stack(|| {
7673                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
7674                })?,
7675            ))),
7676            "ensure" => Ok(Self::Ensure(::std::boxed::Box::new(
7677                ::treesitter_types::runtime::maybe_grow_stack(|| {
7678                    <Ensure as ::treesitter_types::FromNode>::from_node(node, src)
7679                })?,
7680            ))),
7681            "rescue" => Ok(Self::Rescue(::std::boxed::Box::new(
7682                ::treesitter_types::runtime::maybe_grow_stack(|| {
7683                    <Rescue as ::treesitter_types::FromNode>::from_node(node, src)
7684                })?,
7685            ))),
7686            _other => {
7687                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7688                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
7689                }) {
7690                    Ok(Self::Statement(::std::boxed::Box::new(v)))
7691                } else {
7692                    Err(::treesitter_types::ParseError::unexpected_kind(
7693                        _other, node,
7694                    ))
7695                }
7696            }
7697        }
7698    }
7699}
7700impl ::treesitter_types::Spanned for BeginChildren<'_> {
7701    fn span(&self) -> ::treesitter_types::Span {
7702        match self {
7703            Self::Statement(inner) => inner.span(),
7704            Self::Else(inner) => inner.span(),
7705            Self::EmptyStatement(inner) => inner.span(),
7706            Self::Ensure(inner) => inner.span(),
7707            Self::Rescue(inner) => inner.span(),
7708        }
7709    }
7710}
7711#[derive(Debug, Clone, PartialEq, Eq)]
7712pub enum BeginBlockChildren<'tree> {
7713    Statement(::std::boxed::Box<Statement<'tree>>),
7714    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7715}
7716impl<'tree> ::treesitter_types::FromNode<'tree> for BeginBlockChildren<'tree> {
7717    #[allow(clippy::collapsible_else_if)]
7718    fn from_node(
7719        node: ::treesitter_types::tree_sitter::Node<'tree>,
7720        src: &'tree [u8],
7721    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7722        match node.kind() {
7723            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7724                ::treesitter_types::runtime::maybe_grow_stack(|| {
7725                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
7726                })?,
7727            ))),
7728            _other => {
7729                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7730                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
7731                }) {
7732                    Ok(Self::Statement(::std::boxed::Box::new(v)))
7733                } else {
7734                    Err(::treesitter_types::ParseError::unexpected_kind(
7735                        _other, node,
7736                    ))
7737                }
7738            }
7739        }
7740    }
7741}
7742impl ::treesitter_types::Spanned for BeginBlockChildren<'_> {
7743    fn span(&self) -> ::treesitter_types::Span {
7744        match self {
7745            Self::Statement(inner) => inner.span(),
7746            Self::EmptyStatement(inner) => inner.span(),
7747        }
7748    }
7749}
7750#[derive(Debug, Clone, PartialEq, Eq)]
7751pub enum BinaryLeft<'tree> {
7752    Expression(::std::boxed::Box<Expression<'tree>>),
7753    SimpleNumeric(::std::boxed::Box<SimpleNumeric<'tree>>),
7754}
7755impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryLeft<'tree> {
7756    #[allow(clippy::collapsible_else_if)]
7757    fn from_node(
7758        node: ::treesitter_types::tree_sitter::Node<'tree>,
7759        src: &'tree [u8],
7760    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7761        if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7762            <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7763        }) {
7764            Ok(Self::Expression(::std::boxed::Box::new(v)))
7765        } else {
7766            if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7767                <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src)
7768            }) {
7769                Ok(Self::SimpleNumeric(::std::boxed::Box::new(v)))
7770            } else {
7771                Err(::treesitter_types::ParseError::unexpected_kind(
7772                    node.kind(),
7773                    node,
7774                ))
7775            }
7776        }
7777    }
7778}
7779impl ::treesitter_types::Spanned for BinaryLeft<'_> {
7780    fn span(&self) -> ::treesitter_types::Span {
7781        match self {
7782            Self::Expression(inner) => inner.span(),
7783            Self::SimpleNumeric(inner) => inner.span(),
7784        }
7785    }
7786}
7787#[derive(Debug, Clone, PartialEq, Eq)]
7788pub enum BinaryOperator {
7789    NotEq(::treesitter_types::Span),
7790    BangTilde(::treesitter_types::Span),
7791    Percent(::treesitter_types::Span),
7792    Amp(::treesitter_types::Span),
7793    AmpAmp(::treesitter_types::Span),
7794    Star(::treesitter_types::Span),
7795    StarStar(::treesitter_types::Span),
7796    Plus(::treesitter_types::Span),
7797    Minus(::treesitter_types::Span),
7798    Slash(::treesitter_types::Span),
7799    Lt(::treesitter_types::Span),
7800    Shl(::treesitter_types::Span),
7801    LtEq(::treesitter_types::Span),
7802    LtEqGt(::treesitter_types::Span),
7803    EqEq(::treesitter_types::Span),
7804    EqEqEq(::treesitter_types::Span),
7805    EqTilde(::treesitter_types::Span),
7806    Gt(::treesitter_types::Span),
7807    GtEq(::treesitter_types::Span),
7808    Shr(::treesitter_types::Span),
7809    Caret(::treesitter_types::Span),
7810    And(::treesitter_types::Span),
7811    Or(::treesitter_types::Span),
7812    Pipe(::treesitter_types::Span),
7813    PipePipe(::treesitter_types::Span),
7814}
7815impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryOperator {
7816    #[allow(clippy::collapsible_else_if)]
7817    fn from_node(
7818        node: ::treesitter_types::tree_sitter::Node<'tree>,
7819        _src: &'tree [u8],
7820    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7821        match node.kind() {
7822            "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
7823            "!~" => Ok(Self::BangTilde(::treesitter_types::Span::from(node))),
7824            "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
7825            "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
7826            "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
7827            "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
7828            "**" => Ok(Self::StarStar(::treesitter_types::Span::from(node))),
7829            "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
7830            "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
7831            "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
7832            "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
7833            "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
7834            "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
7835            "<=>" => Ok(Self::LtEqGt(::treesitter_types::Span::from(node))),
7836            "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
7837            "===" => Ok(Self::EqEqEq(::treesitter_types::Span::from(node))),
7838            "=~" => Ok(Self::EqTilde(::treesitter_types::Span::from(node))),
7839            ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
7840            ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
7841            ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
7842            "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
7843            "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
7844            "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
7845            "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
7846            "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
7847            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7848        }
7849    }
7850}
7851impl ::treesitter_types::Spanned for BinaryOperator {
7852    fn span(&self) -> ::treesitter_types::Span {
7853        match self {
7854            Self::NotEq(span) => *span,
7855            Self::BangTilde(span) => *span,
7856            Self::Percent(span) => *span,
7857            Self::Amp(span) => *span,
7858            Self::AmpAmp(span) => *span,
7859            Self::Star(span) => *span,
7860            Self::StarStar(span) => *span,
7861            Self::Plus(span) => *span,
7862            Self::Minus(span) => *span,
7863            Self::Slash(span) => *span,
7864            Self::Lt(span) => *span,
7865            Self::Shl(span) => *span,
7866            Self::LtEq(span) => *span,
7867            Self::LtEqGt(span) => *span,
7868            Self::EqEq(span) => *span,
7869            Self::EqEqEq(span) => *span,
7870            Self::EqTilde(span) => *span,
7871            Self::Gt(span) => *span,
7872            Self::GtEq(span) => *span,
7873            Self::Shr(span) => *span,
7874            Self::Caret(span) => *span,
7875            Self::And(span) => *span,
7876            Self::Or(span) => *span,
7877            Self::Pipe(span) => *span,
7878            Self::PipePipe(span) => *span,
7879        }
7880    }
7881}
7882#[derive(Debug, Clone, PartialEq, Eq)]
7883pub enum BlockBodyChildren<'tree> {
7884    Statement(::std::boxed::Box<Statement<'tree>>),
7885    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7886}
7887impl<'tree> ::treesitter_types::FromNode<'tree> for BlockBodyChildren<'tree> {
7888    #[allow(clippy::collapsible_else_if)]
7889    fn from_node(
7890        node: ::treesitter_types::tree_sitter::Node<'tree>,
7891        src: &'tree [u8],
7892    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7893        match node.kind() {
7894            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7895                ::treesitter_types::runtime::maybe_grow_stack(|| {
7896                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
7897                })?,
7898            ))),
7899            _other => {
7900                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7901                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
7902                }) {
7903                    Ok(Self::Statement(::std::boxed::Box::new(v)))
7904                } else {
7905                    Err(::treesitter_types::ParseError::unexpected_kind(
7906                        _other, node,
7907                    ))
7908                }
7909            }
7910        }
7911    }
7912}
7913impl ::treesitter_types::Spanned for BlockBodyChildren<'_> {
7914    fn span(&self) -> ::treesitter_types::Span {
7915        match self {
7916            Self::Statement(inner) => inner.span(),
7917            Self::EmptyStatement(inner) => inner.span(),
7918        }
7919    }
7920}
7921#[derive(Debug, Clone, PartialEq, Eq)]
7922pub enum BlockParametersChildren<'tree> {
7923    BlockParameter(::std::boxed::Box<BlockParameter<'tree>>),
7924    DestructuredParameter(::std::boxed::Box<DestructuredParameter<'tree>>),
7925    ForwardParameter(::std::boxed::Box<ForwardParameter<'tree>>),
7926    HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
7927    HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
7928    Identifier(::std::boxed::Box<Identifier<'tree>>),
7929    KeywordParameter(::std::boxed::Box<KeywordParameter<'tree>>),
7930    OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
7931    SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
7932}
7933impl<'tree> ::treesitter_types::FromNode<'tree> for BlockParametersChildren<'tree> {
7934    #[allow(clippy::collapsible_else_if)]
7935    fn from_node(
7936        node: ::treesitter_types::tree_sitter::Node<'tree>,
7937        src: &'tree [u8],
7938    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7939        match node.kind() {
7940            "block_parameter" => Ok(Self::BlockParameter(::std::boxed::Box::new(
7941                ::treesitter_types::runtime::maybe_grow_stack(|| {
7942                    <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)
7943                })?,
7944            ))),
7945            "destructured_parameter" => Ok(Self::DestructuredParameter(::std::boxed::Box::new(
7946                ::treesitter_types::runtime::maybe_grow_stack(|| {
7947                    <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)
7948                })?,
7949            ))),
7950            "forward_parameter" => Ok(Self::ForwardParameter(::std::boxed::Box::new(
7951                ::treesitter_types::runtime::maybe_grow_stack(|| {
7952                    <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)
7953                })?,
7954            ))),
7955            "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
7956                ::treesitter_types::runtime::maybe_grow_stack(|| {
7957                    <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)
7958                })?,
7959            ))),
7960            "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
7961                ::treesitter_types::runtime::maybe_grow_stack(|| {
7962                    <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
7963                })?,
7964            ))),
7965            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7966                ::treesitter_types::runtime::maybe_grow_stack(|| {
7967                    <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7968                })?,
7969            ))),
7970            "keyword_parameter" => Ok(Self::KeywordParameter(::std::boxed::Box::new(
7971                ::treesitter_types::runtime::maybe_grow_stack(|| {
7972                    <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)
7973                })?,
7974            ))),
7975            "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
7976                ::treesitter_types::runtime::maybe_grow_stack(|| {
7977                    <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)
7978                })?,
7979            ))),
7980            "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
7981                ::treesitter_types::runtime::maybe_grow_stack(|| {
7982                    <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
7983                })?,
7984            ))),
7985            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7986        }
7987    }
7988}
7989impl ::treesitter_types::Spanned for BlockParametersChildren<'_> {
7990    fn span(&self) -> ::treesitter_types::Span {
7991        match self {
7992            Self::BlockParameter(inner) => inner.span(),
7993            Self::DestructuredParameter(inner) => inner.span(),
7994            Self::ForwardParameter(inner) => inner.span(),
7995            Self::HashSplatNil(inner) => inner.span(),
7996            Self::HashSplatParameter(inner) => inner.span(),
7997            Self::Identifier(inner) => inner.span(),
7998            Self::KeywordParameter(inner) => inner.span(),
7999            Self::OptionalParameter(inner) => inner.span(),
8000            Self::SplatParameter(inner) => inner.span(),
8001        }
8002    }
8003}
8004#[derive(Debug, Clone, PartialEq, Eq)]
8005pub enum BodyStatementChildren<'tree> {
8006    Statement(::std::boxed::Box<Statement<'tree>>),
8007    Else(::std::boxed::Box<Else<'tree>>),
8008    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8009    Ensure(::std::boxed::Box<Ensure<'tree>>),
8010    Rescue(::std::boxed::Box<Rescue<'tree>>),
8011}
8012impl<'tree> ::treesitter_types::FromNode<'tree> for BodyStatementChildren<'tree> {
8013    #[allow(clippy::collapsible_else_if)]
8014    fn from_node(
8015        node: ::treesitter_types::tree_sitter::Node<'tree>,
8016        src: &'tree [u8],
8017    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8018        match node.kind() {
8019            "else" => Ok(Self::Else(::std::boxed::Box::new(
8020                ::treesitter_types::runtime::maybe_grow_stack(|| {
8021                    <Else as ::treesitter_types::FromNode>::from_node(node, src)
8022                })?,
8023            ))),
8024            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8025                ::treesitter_types::runtime::maybe_grow_stack(|| {
8026                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
8027                })?,
8028            ))),
8029            "ensure" => Ok(Self::Ensure(::std::boxed::Box::new(
8030                ::treesitter_types::runtime::maybe_grow_stack(|| {
8031                    <Ensure as ::treesitter_types::FromNode>::from_node(node, src)
8032                })?,
8033            ))),
8034            "rescue" => Ok(Self::Rescue(::std::boxed::Box::new(
8035                ::treesitter_types::runtime::maybe_grow_stack(|| {
8036                    <Rescue as ::treesitter_types::FromNode>::from_node(node, src)
8037                })?,
8038            ))),
8039            _other => {
8040                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8041                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8042                }) {
8043                    Ok(Self::Statement(::std::boxed::Box::new(v)))
8044                } else {
8045                    Err(::treesitter_types::ParseError::unexpected_kind(
8046                        _other, node,
8047                    ))
8048                }
8049            }
8050        }
8051    }
8052}
8053impl ::treesitter_types::Spanned for BodyStatementChildren<'_> {
8054    fn span(&self) -> ::treesitter_types::Span {
8055        match self {
8056            Self::Statement(inner) => inner.span(),
8057            Self::Else(inner) => inner.span(),
8058            Self::EmptyStatement(inner) => inner.span(),
8059            Self::Ensure(inner) => inner.span(),
8060            Self::Rescue(inner) => inner.span(),
8061        }
8062    }
8063}
8064#[derive(Debug, Clone, PartialEq, Eq)]
8065pub enum CallBlock<'tree> {
8066    Block(::std::boxed::Box<Block<'tree>>),
8067    DoBlock(::std::boxed::Box<DoBlock<'tree>>),
8068}
8069impl<'tree> ::treesitter_types::FromNode<'tree> for CallBlock<'tree> {
8070    #[allow(clippy::collapsible_else_if)]
8071    fn from_node(
8072        node: ::treesitter_types::tree_sitter::Node<'tree>,
8073        src: &'tree [u8],
8074    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8075        match node.kind() {
8076            "block" => Ok(Self::Block(::std::boxed::Box::new(
8077                ::treesitter_types::runtime::maybe_grow_stack(|| {
8078                    <Block as ::treesitter_types::FromNode>::from_node(node, src)
8079                })?,
8080            ))),
8081            "do_block" => Ok(Self::DoBlock(::std::boxed::Box::new(
8082                ::treesitter_types::runtime::maybe_grow_stack(|| {
8083                    <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)
8084                })?,
8085            ))),
8086            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8087        }
8088    }
8089}
8090impl ::treesitter_types::Spanned for CallBlock<'_> {
8091    fn span(&self) -> ::treesitter_types::Span {
8092        match self {
8093            Self::Block(inner) => inner.span(),
8094            Self::DoBlock(inner) => inner.span(),
8095        }
8096    }
8097}
8098#[derive(Debug, Clone, PartialEq, Eq)]
8099pub enum CallMethod<'tree> {
8100    Variable(::std::boxed::Box<Variable<'tree>>),
8101    Operator(::std::boxed::Box<Operator<'tree>>),
8102}
8103impl<'tree> ::treesitter_types::FromNode<'tree> for CallMethod<'tree> {
8104    #[allow(clippy::collapsible_else_if)]
8105    fn from_node(
8106        node: ::treesitter_types::tree_sitter::Node<'tree>,
8107        src: &'tree [u8],
8108    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8109        match node.kind() {
8110            "operator" => Ok(Self::Operator(::std::boxed::Box::new(
8111                ::treesitter_types::runtime::maybe_grow_stack(|| {
8112                    <Operator as ::treesitter_types::FromNode>::from_node(node, src)
8113                })?,
8114            ))),
8115            _other => {
8116                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8117                    <Variable as ::treesitter_types::FromNode>::from_node(node, src)
8118                }) {
8119                    Ok(Self::Variable(::std::boxed::Box::new(v)))
8120                } else {
8121                    Err(::treesitter_types::ParseError::unexpected_kind(
8122                        _other, node,
8123                    ))
8124                }
8125            }
8126        }
8127    }
8128}
8129impl ::treesitter_types::Spanned for CallMethod<'_> {
8130    fn span(&self) -> ::treesitter_types::Span {
8131        match self {
8132            Self::Variable(inner) => inner.span(),
8133            Self::Operator(inner) => inner.span(),
8134        }
8135    }
8136}
8137#[derive(Debug, Clone, PartialEq, Eq)]
8138pub enum CaseChildren<'tree> {
8139    Else(::std::boxed::Box<Else<'tree>>),
8140    When(::std::boxed::Box<When<'tree>>),
8141}
8142impl<'tree> ::treesitter_types::FromNode<'tree> for CaseChildren<'tree> {
8143    #[allow(clippy::collapsible_else_if)]
8144    fn from_node(
8145        node: ::treesitter_types::tree_sitter::Node<'tree>,
8146        src: &'tree [u8],
8147    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8148        match node.kind() {
8149            "else" => Ok(Self::Else(::std::boxed::Box::new(
8150                ::treesitter_types::runtime::maybe_grow_stack(|| {
8151                    <Else as ::treesitter_types::FromNode>::from_node(node, src)
8152                })?,
8153            ))),
8154            "when" => Ok(Self::When(::std::boxed::Box::new(
8155                ::treesitter_types::runtime::maybe_grow_stack(|| {
8156                    <When as ::treesitter_types::FromNode>::from_node(node, src)
8157                })?,
8158            ))),
8159            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8160        }
8161    }
8162}
8163impl ::treesitter_types::Spanned for CaseChildren<'_> {
8164    fn span(&self) -> ::treesitter_types::Span {
8165        match self {
8166            Self::Else(inner) => inner.span(),
8167            Self::When(inner) => inner.span(),
8168        }
8169    }
8170}
8171#[derive(Debug, Clone, PartialEq, Eq)]
8172pub enum ClassName<'tree> {
8173    Constant(::std::boxed::Box<Constant<'tree>>),
8174    ScopeResolution(::std::boxed::Box<ScopeResolution<'tree>>),
8175}
8176impl<'tree> ::treesitter_types::FromNode<'tree> for ClassName<'tree> {
8177    #[allow(clippy::collapsible_else_if)]
8178    fn from_node(
8179        node: ::treesitter_types::tree_sitter::Node<'tree>,
8180        src: &'tree [u8],
8181    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8182        match node.kind() {
8183            "constant" => Ok(Self::Constant(::std::boxed::Box::new(
8184                ::treesitter_types::runtime::maybe_grow_stack(|| {
8185                    <Constant as ::treesitter_types::FromNode>::from_node(node, src)
8186                })?,
8187            ))),
8188            "scope_resolution" => Ok(Self::ScopeResolution(::std::boxed::Box::new(
8189                ::treesitter_types::runtime::maybe_grow_stack(|| {
8190                    <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)
8191                })?,
8192            ))),
8193            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8194        }
8195    }
8196}
8197impl ::treesitter_types::Spanned for ClassName<'_> {
8198    fn span(&self) -> ::treesitter_types::Span {
8199        match self {
8200            Self::Constant(inner) => inner.span(),
8201            Self::ScopeResolution(inner) => inner.span(),
8202        }
8203    }
8204}
8205#[derive(Debug, Clone, PartialEq, Eq)]
8206pub enum ComplexChildren<'tree> {
8207    Float(::std::boxed::Box<Float<'tree>>),
8208    Integer(::std::boxed::Box<Integer<'tree>>),
8209    Rational(::std::boxed::Box<Rational<'tree>>),
8210}
8211impl<'tree> ::treesitter_types::FromNode<'tree> for ComplexChildren<'tree> {
8212    #[allow(clippy::collapsible_else_if)]
8213    fn from_node(
8214        node: ::treesitter_types::tree_sitter::Node<'tree>,
8215        src: &'tree [u8],
8216    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8217        match node.kind() {
8218            "float" => Ok(Self::Float(::std::boxed::Box::new(
8219                ::treesitter_types::runtime::maybe_grow_stack(|| {
8220                    <Float as ::treesitter_types::FromNode>::from_node(node, src)
8221                })?,
8222            ))),
8223            "integer" => Ok(Self::Integer(::std::boxed::Box::new(
8224                ::treesitter_types::runtime::maybe_grow_stack(|| {
8225                    <Integer as ::treesitter_types::FromNode>::from_node(node, src)
8226                })?,
8227            ))),
8228            "rational" => Ok(Self::Rational(::std::boxed::Box::new(
8229                ::treesitter_types::runtime::maybe_grow_stack(|| {
8230                    <Rational as ::treesitter_types::FromNode>::from_node(node, src)
8231                })?,
8232            ))),
8233            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8234        }
8235    }
8236}
8237impl ::treesitter_types::Spanned for ComplexChildren<'_> {
8238    fn span(&self) -> ::treesitter_types::Span {
8239        match self {
8240            Self::Float(inner) => inner.span(),
8241            Self::Integer(inner) => inner.span(),
8242            Self::Rational(inner) => inner.span(),
8243        }
8244    }
8245}
8246#[derive(Debug, Clone, PartialEq, Eq)]
8247pub enum DelimitedSymbolChildren<'tree> {
8248    EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
8249    Interpolation(::std::boxed::Box<Interpolation<'tree>>),
8250    StringContent(::std::boxed::Box<StringContent<'tree>>),
8251}
8252impl<'tree> ::treesitter_types::FromNode<'tree> for DelimitedSymbolChildren<'tree> {
8253    #[allow(clippy::collapsible_else_if)]
8254    fn from_node(
8255        node: ::treesitter_types::tree_sitter::Node<'tree>,
8256        src: &'tree [u8],
8257    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8258        match node.kind() {
8259            "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
8260                ::treesitter_types::runtime::maybe_grow_stack(|| {
8261                    <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
8262                })?,
8263            ))),
8264            "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
8265                ::treesitter_types::runtime::maybe_grow_stack(|| {
8266                    <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
8267                })?,
8268            ))),
8269            "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
8270                ::treesitter_types::runtime::maybe_grow_stack(|| {
8271                    <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
8272                })?,
8273            ))),
8274            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8275        }
8276    }
8277}
8278impl ::treesitter_types::Spanned for DelimitedSymbolChildren<'_> {
8279    fn span(&self) -> ::treesitter_types::Span {
8280        match self {
8281            Self::EscapeSequence(inner) => inner.span(),
8282            Self::Interpolation(inner) => inner.span(),
8283            Self::StringContent(inner) => inner.span(),
8284        }
8285    }
8286}
8287#[derive(Debug, Clone, PartialEq, Eq)]
8288pub enum DestructuredLeftAssignmentChildren<'tree> {
8289    Lhs(::std::boxed::Box<Lhs<'tree>>),
8290    DestructuredLeftAssignment(::std::boxed::Box<DestructuredLeftAssignment<'tree>>),
8291    RestAssignment(::std::boxed::Box<RestAssignment<'tree>>),
8292}
8293impl<'tree> ::treesitter_types::FromNode<'tree> for DestructuredLeftAssignmentChildren<'tree> {
8294    #[allow(clippy::collapsible_else_if)]
8295    fn from_node(
8296        node: ::treesitter_types::tree_sitter::Node<'tree>,
8297        src: &'tree [u8],
8298    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8299        match node.kind() {
8300            "destructured_left_assignment" => Ok(Self::DestructuredLeftAssignment(
8301                ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8302                    <DestructuredLeftAssignment as ::treesitter_types::FromNode>::from_node(
8303                        node, src,
8304                    )
8305                })?),
8306            )),
8307            "rest_assignment" => Ok(Self::RestAssignment(::std::boxed::Box::new(
8308                ::treesitter_types::runtime::maybe_grow_stack(|| {
8309                    <RestAssignment as ::treesitter_types::FromNode>::from_node(node, src)
8310                })?,
8311            ))),
8312            _other => {
8313                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8314                    <Lhs as ::treesitter_types::FromNode>::from_node(node, src)
8315                }) {
8316                    Ok(Self::Lhs(::std::boxed::Box::new(v)))
8317                } else {
8318                    Err(::treesitter_types::ParseError::unexpected_kind(
8319                        _other, node,
8320                    ))
8321                }
8322            }
8323        }
8324    }
8325}
8326impl ::treesitter_types::Spanned for DestructuredLeftAssignmentChildren<'_> {
8327    fn span(&self) -> ::treesitter_types::Span {
8328        match self {
8329            Self::Lhs(inner) => inner.span(),
8330            Self::DestructuredLeftAssignment(inner) => inner.span(),
8331            Self::RestAssignment(inner) => inner.span(),
8332        }
8333    }
8334}
8335#[derive(Debug, Clone, PartialEq, Eq)]
8336pub enum DestructuredParameterChildren<'tree> {
8337    BlockParameter(::std::boxed::Box<BlockParameter<'tree>>),
8338    DestructuredParameter(::std::boxed::Box<DestructuredParameter<'tree>>),
8339    ForwardParameter(::std::boxed::Box<ForwardParameter<'tree>>),
8340    HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
8341    HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
8342    Identifier(::std::boxed::Box<Identifier<'tree>>),
8343    KeywordParameter(::std::boxed::Box<KeywordParameter<'tree>>),
8344    OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
8345    SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
8346}
8347impl<'tree> ::treesitter_types::FromNode<'tree> for DestructuredParameterChildren<'tree> {
8348    #[allow(clippy::collapsible_else_if)]
8349    fn from_node(
8350        node: ::treesitter_types::tree_sitter::Node<'tree>,
8351        src: &'tree [u8],
8352    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8353        match node.kind() {
8354            "block_parameter" => Ok(Self::BlockParameter(::std::boxed::Box::new(
8355                ::treesitter_types::runtime::maybe_grow_stack(|| {
8356                    <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)
8357                })?,
8358            ))),
8359            "destructured_parameter" => Ok(Self::DestructuredParameter(::std::boxed::Box::new(
8360                ::treesitter_types::runtime::maybe_grow_stack(|| {
8361                    <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)
8362                })?,
8363            ))),
8364            "forward_parameter" => Ok(Self::ForwardParameter(::std::boxed::Box::new(
8365                ::treesitter_types::runtime::maybe_grow_stack(|| {
8366                    <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)
8367                })?,
8368            ))),
8369            "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
8370                ::treesitter_types::runtime::maybe_grow_stack(|| {
8371                    <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)
8372                })?,
8373            ))),
8374            "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
8375                ::treesitter_types::runtime::maybe_grow_stack(|| {
8376                    <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
8377                })?,
8378            ))),
8379            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8380                ::treesitter_types::runtime::maybe_grow_stack(|| {
8381                    <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
8382                })?,
8383            ))),
8384            "keyword_parameter" => Ok(Self::KeywordParameter(::std::boxed::Box::new(
8385                ::treesitter_types::runtime::maybe_grow_stack(|| {
8386                    <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)
8387                })?,
8388            ))),
8389            "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
8390                ::treesitter_types::runtime::maybe_grow_stack(|| {
8391                    <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)
8392                })?,
8393            ))),
8394            "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
8395                ::treesitter_types::runtime::maybe_grow_stack(|| {
8396                    <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
8397                })?,
8398            ))),
8399            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8400        }
8401    }
8402}
8403impl ::treesitter_types::Spanned for DestructuredParameterChildren<'_> {
8404    fn span(&self) -> ::treesitter_types::Span {
8405        match self {
8406            Self::BlockParameter(inner) => inner.span(),
8407            Self::DestructuredParameter(inner) => inner.span(),
8408            Self::ForwardParameter(inner) => inner.span(),
8409            Self::HashSplatNil(inner) => inner.span(),
8410            Self::HashSplatParameter(inner) => inner.span(),
8411            Self::Identifier(inner) => inner.span(),
8412            Self::KeywordParameter(inner) => inner.span(),
8413            Self::OptionalParameter(inner) => inner.span(),
8414            Self::SplatParameter(inner) => inner.span(),
8415        }
8416    }
8417}
8418#[derive(Debug, Clone, PartialEq, Eq)]
8419pub enum DoChildren<'tree> {
8420    Statement(::std::boxed::Box<Statement<'tree>>),
8421    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8422}
8423impl<'tree> ::treesitter_types::FromNode<'tree> for DoChildren<'tree> {
8424    #[allow(clippy::collapsible_else_if)]
8425    fn from_node(
8426        node: ::treesitter_types::tree_sitter::Node<'tree>,
8427        src: &'tree [u8],
8428    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8429        match node.kind() {
8430            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8431                ::treesitter_types::runtime::maybe_grow_stack(|| {
8432                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
8433                })?,
8434            ))),
8435            _other => {
8436                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8437                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8438                }) {
8439                    Ok(Self::Statement(::std::boxed::Box::new(v)))
8440                } else {
8441                    Err(::treesitter_types::ParseError::unexpected_kind(
8442                        _other, node,
8443                    ))
8444                }
8445            }
8446        }
8447    }
8448}
8449impl ::treesitter_types::Spanned for DoChildren<'_> {
8450    fn span(&self) -> ::treesitter_types::Span {
8451        match self {
8452            Self::Statement(inner) => inner.span(),
8453            Self::EmptyStatement(inner) => inner.span(),
8454        }
8455    }
8456}
8457#[derive(Debug, Clone, PartialEq, Eq)]
8458pub enum ElementReferenceBlock<'tree> {
8459    Block(::std::boxed::Box<Block<'tree>>),
8460    DoBlock(::std::boxed::Box<DoBlock<'tree>>),
8461}
8462impl<'tree> ::treesitter_types::FromNode<'tree> for ElementReferenceBlock<'tree> {
8463    #[allow(clippy::collapsible_else_if)]
8464    fn from_node(
8465        node: ::treesitter_types::tree_sitter::Node<'tree>,
8466        src: &'tree [u8],
8467    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8468        match node.kind() {
8469            "block" => Ok(Self::Block(::std::boxed::Box::new(
8470                ::treesitter_types::runtime::maybe_grow_stack(|| {
8471                    <Block as ::treesitter_types::FromNode>::from_node(node, src)
8472                })?,
8473            ))),
8474            "do_block" => Ok(Self::DoBlock(::std::boxed::Box::new(
8475                ::treesitter_types::runtime::maybe_grow_stack(|| {
8476                    <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)
8477                })?,
8478            ))),
8479            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8480        }
8481    }
8482}
8483impl ::treesitter_types::Spanned for ElementReferenceBlock<'_> {
8484    fn span(&self) -> ::treesitter_types::Span {
8485        match self {
8486            Self::Block(inner) => inner.span(),
8487            Self::DoBlock(inner) => inner.span(),
8488        }
8489    }
8490}
8491#[derive(Debug, Clone, PartialEq, Eq)]
8492pub enum ElementReferenceChildren<'tree> {
8493    Expression(::std::boxed::Box<Expression<'tree>>),
8494    BlockArgument(::std::boxed::Box<BlockArgument<'tree>>),
8495    ForwardArgument(::std::boxed::Box<ForwardArgument<'tree>>),
8496    HashSplatArgument(::std::boxed::Box<HashSplatArgument<'tree>>),
8497    Pair(::std::boxed::Box<Pair<'tree>>),
8498    SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
8499}
8500impl<'tree> ::treesitter_types::FromNode<'tree> for ElementReferenceChildren<'tree> {
8501    #[allow(clippy::collapsible_else_if)]
8502    fn from_node(
8503        node: ::treesitter_types::tree_sitter::Node<'tree>,
8504        src: &'tree [u8],
8505    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8506        match node.kind() {
8507            "block_argument" => Ok(Self::BlockArgument(::std::boxed::Box::new(
8508                ::treesitter_types::runtime::maybe_grow_stack(|| {
8509                    <BlockArgument as ::treesitter_types::FromNode>::from_node(node, src)
8510                })?,
8511            ))),
8512            "forward_argument" => Ok(Self::ForwardArgument(::std::boxed::Box::new(
8513                ::treesitter_types::runtime::maybe_grow_stack(|| {
8514                    <ForwardArgument as ::treesitter_types::FromNode>::from_node(node, src)
8515                })?,
8516            ))),
8517            "hash_splat_argument" => Ok(Self::HashSplatArgument(::std::boxed::Box::new(
8518                ::treesitter_types::runtime::maybe_grow_stack(|| {
8519                    <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
8520                })?,
8521            ))),
8522            "pair" => Ok(Self::Pair(::std::boxed::Box::new(
8523                ::treesitter_types::runtime::maybe_grow_stack(|| {
8524                    <Pair as ::treesitter_types::FromNode>::from_node(node, src)
8525                })?,
8526            ))),
8527            "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
8528                ::treesitter_types::runtime::maybe_grow_stack(|| {
8529                    <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
8530                })?,
8531            ))),
8532            _other => {
8533                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8534                    <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8535                }) {
8536                    Ok(Self::Expression(::std::boxed::Box::new(v)))
8537                } else {
8538                    Err(::treesitter_types::ParseError::unexpected_kind(
8539                        _other, node,
8540                    ))
8541                }
8542            }
8543        }
8544    }
8545}
8546impl ::treesitter_types::Spanned for ElementReferenceChildren<'_> {
8547    fn span(&self) -> ::treesitter_types::Span {
8548        match self {
8549            Self::Expression(inner) => inner.span(),
8550            Self::BlockArgument(inner) => inner.span(),
8551            Self::ForwardArgument(inner) => inner.span(),
8552            Self::HashSplatArgument(inner) => inner.span(),
8553            Self::Pair(inner) => inner.span(),
8554            Self::SplatArgument(inner) => inner.span(),
8555        }
8556    }
8557}
8558#[derive(Debug, Clone, PartialEq, Eq)]
8559pub enum ElseChildren<'tree> {
8560    Statement(::std::boxed::Box<Statement<'tree>>),
8561    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8562}
8563impl<'tree> ::treesitter_types::FromNode<'tree> for ElseChildren<'tree> {
8564    #[allow(clippy::collapsible_else_if)]
8565    fn from_node(
8566        node: ::treesitter_types::tree_sitter::Node<'tree>,
8567        src: &'tree [u8],
8568    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8569        match node.kind() {
8570            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8571                ::treesitter_types::runtime::maybe_grow_stack(|| {
8572                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
8573                })?,
8574            ))),
8575            _other => {
8576                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8577                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8578                }) {
8579                    Ok(Self::Statement(::std::boxed::Box::new(v)))
8580                } else {
8581                    Err(::treesitter_types::ParseError::unexpected_kind(
8582                        _other, node,
8583                    ))
8584                }
8585            }
8586        }
8587    }
8588}
8589impl ::treesitter_types::Spanned for ElseChildren<'_> {
8590    fn span(&self) -> ::treesitter_types::Span {
8591        match self {
8592            Self::Statement(inner) => inner.span(),
8593            Self::EmptyStatement(inner) => inner.span(),
8594        }
8595    }
8596}
8597#[derive(Debug, Clone, PartialEq, Eq)]
8598pub enum ElsifAlternative<'tree> {
8599    Else(::std::boxed::Box<Else<'tree>>),
8600    Elsif(::std::boxed::Box<Elsif<'tree>>),
8601}
8602impl<'tree> ::treesitter_types::FromNode<'tree> for ElsifAlternative<'tree> {
8603    #[allow(clippy::collapsible_else_if)]
8604    fn from_node(
8605        node: ::treesitter_types::tree_sitter::Node<'tree>,
8606        src: &'tree [u8],
8607    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8608        match node.kind() {
8609            "else" => Ok(Self::Else(::std::boxed::Box::new(
8610                ::treesitter_types::runtime::maybe_grow_stack(|| {
8611                    <Else as ::treesitter_types::FromNode>::from_node(node, src)
8612                })?,
8613            ))),
8614            "elsif" => Ok(Self::Elsif(::std::boxed::Box::new(
8615                ::treesitter_types::runtime::maybe_grow_stack(|| {
8616                    <Elsif as ::treesitter_types::FromNode>::from_node(node, src)
8617                })?,
8618            ))),
8619            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8620        }
8621    }
8622}
8623impl ::treesitter_types::Spanned for ElsifAlternative<'_> {
8624    fn span(&self) -> ::treesitter_types::Span {
8625        match self {
8626            Self::Else(inner) => inner.span(),
8627            Self::Elsif(inner) => inner.span(),
8628        }
8629    }
8630}
8631#[derive(Debug, Clone, PartialEq, Eq)]
8632pub enum EndBlockChildren<'tree> {
8633    Statement(::std::boxed::Box<Statement<'tree>>),
8634    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8635}
8636impl<'tree> ::treesitter_types::FromNode<'tree> for EndBlockChildren<'tree> {
8637    #[allow(clippy::collapsible_else_if)]
8638    fn from_node(
8639        node: ::treesitter_types::tree_sitter::Node<'tree>,
8640        src: &'tree [u8],
8641    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8642        match node.kind() {
8643            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8644                ::treesitter_types::runtime::maybe_grow_stack(|| {
8645                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
8646                })?,
8647            ))),
8648            _other => {
8649                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8650                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8651                }) {
8652                    Ok(Self::Statement(::std::boxed::Box::new(v)))
8653                } else {
8654                    Err(::treesitter_types::ParseError::unexpected_kind(
8655                        _other, node,
8656                    ))
8657                }
8658            }
8659        }
8660    }
8661}
8662impl ::treesitter_types::Spanned for EndBlockChildren<'_> {
8663    fn span(&self) -> ::treesitter_types::Span {
8664        match self {
8665            Self::Statement(inner) => inner.span(),
8666            Self::EmptyStatement(inner) => inner.span(),
8667        }
8668    }
8669}
8670#[derive(Debug, Clone, PartialEq, Eq)]
8671pub enum EnsureChildren<'tree> {
8672    Statement(::std::boxed::Box<Statement<'tree>>),
8673    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8674}
8675impl<'tree> ::treesitter_types::FromNode<'tree> for EnsureChildren<'tree> {
8676    #[allow(clippy::collapsible_else_if)]
8677    fn from_node(
8678        node: ::treesitter_types::tree_sitter::Node<'tree>,
8679        src: &'tree [u8],
8680    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8681        match node.kind() {
8682            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8683                ::treesitter_types::runtime::maybe_grow_stack(|| {
8684                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
8685                })?,
8686            ))),
8687            _other => {
8688                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8689                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8690                }) {
8691                    Ok(Self::Statement(::std::boxed::Box::new(v)))
8692                } else {
8693                    Err(::treesitter_types::ParseError::unexpected_kind(
8694                        _other, node,
8695                    ))
8696                }
8697            }
8698        }
8699    }
8700}
8701impl ::treesitter_types::Spanned for EnsureChildren<'_> {
8702    fn span(&self) -> ::treesitter_types::Span {
8703        match self {
8704            Self::Statement(inner) => inner.span(),
8705            Self::EmptyStatement(inner) => inner.span(),
8706        }
8707    }
8708}
8709#[derive(Debug, Clone, PartialEq, Eq)]
8710pub enum ExceptionsChildren<'tree> {
8711    Arg(::std::boxed::Box<Arg<'tree>>),
8712    SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
8713}
8714impl<'tree> ::treesitter_types::FromNode<'tree> for ExceptionsChildren<'tree> {
8715    #[allow(clippy::collapsible_else_if)]
8716    fn from_node(
8717        node: ::treesitter_types::tree_sitter::Node<'tree>,
8718        src: &'tree [u8],
8719    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8720        match node.kind() {
8721            "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
8722                ::treesitter_types::runtime::maybe_grow_stack(|| {
8723                    <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
8724                })?,
8725            ))),
8726            _other => {
8727                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8728                    <Arg as ::treesitter_types::FromNode>::from_node(node, src)
8729                }) {
8730                    Ok(Self::Arg(::std::boxed::Box::new(v)))
8731                } else {
8732                    Err(::treesitter_types::ParseError::unexpected_kind(
8733                        _other, node,
8734                    ))
8735                }
8736            }
8737        }
8738    }
8739}
8740impl ::treesitter_types::Spanned for ExceptionsChildren<'_> {
8741    fn span(&self) -> ::treesitter_types::Span {
8742        match self {
8743            Self::Arg(inner) => inner.span(),
8744            Self::SplatArgument(inner) => inner.span(),
8745        }
8746    }
8747}
8748#[derive(Debug, Clone, PartialEq, Eq)]
8749pub enum FindPatternChildren<'tree> {
8750    PatternExpr(::std::boxed::Box<PatternExpr<'tree>>),
8751    SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
8752}
8753impl<'tree> ::treesitter_types::FromNode<'tree> for FindPatternChildren<'tree> {
8754    #[allow(clippy::collapsible_else_if)]
8755    fn from_node(
8756        node: ::treesitter_types::tree_sitter::Node<'tree>,
8757        src: &'tree [u8],
8758    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8759        match node.kind() {
8760            "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
8761                ::treesitter_types::runtime::maybe_grow_stack(|| {
8762                    <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
8763                })?,
8764            ))),
8765            _other => {
8766                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8767                    <PatternExpr as ::treesitter_types::FromNode>::from_node(node, src)
8768                }) {
8769                    Ok(Self::PatternExpr(::std::boxed::Box::new(v)))
8770                } else {
8771                    Err(::treesitter_types::ParseError::unexpected_kind(
8772                        _other, node,
8773                    ))
8774                }
8775            }
8776        }
8777    }
8778}
8779impl ::treesitter_types::Spanned for FindPatternChildren<'_> {
8780    fn span(&self) -> ::treesitter_types::Span {
8781        match self {
8782            Self::PatternExpr(inner) => inner.span(),
8783            Self::SplatParameter(inner) => inner.span(),
8784        }
8785    }
8786}
8787#[derive(Debug, Clone, PartialEq, Eq)]
8788pub enum ForPattern<'tree> {
8789    Lhs(::std::boxed::Box<Lhs<'tree>>),
8790    LeftAssignmentList(::std::boxed::Box<LeftAssignmentList<'tree>>),
8791}
8792impl<'tree> ::treesitter_types::FromNode<'tree> for ForPattern<'tree> {
8793    #[allow(clippy::collapsible_else_if)]
8794    fn from_node(
8795        node: ::treesitter_types::tree_sitter::Node<'tree>,
8796        src: &'tree [u8],
8797    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8798        match node.kind() {
8799            "left_assignment_list" => Ok(Self::LeftAssignmentList(::std::boxed::Box::new(
8800                ::treesitter_types::runtime::maybe_grow_stack(|| {
8801                    <LeftAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)
8802                })?,
8803            ))),
8804            _other => {
8805                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8806                    <Lhs as ::treesitter_types::FromNode>::from_node(node, src)
8807                }) {
8808                    Ok(Self::Lhs(::std::boxed::Box::new(v)))
8809                } else {
8810                    Err(::treesitter_types::ParseError::unexpected_kind(
8811                        _other, node,
8812                    ))
8813                }
8814            }
8815        }
8816    }
8817}
8818impl ::treesitter_types::Spanned for ForPattern<'_> {
8819    fn span(&self) -> ::treesitter_types::Span {
8820        match self {
8821            Self::Lhs(inner) => inner.span(),
8822            Self::LeftAssignmentList(inner) => inner.span(),
8823        }
8824    }
8825}
8826#[derive(Debug, Clone, PartialEq, Eq)]
8827pub enum HashChildren<'tree> {
8828    HashSplatArgument(::std::boxed::Box<HashSplatArgument<'tree>>),
8829    Pair(::std::boxed::Box<Pair<'tree>>),
8830}
8831impl<'tree> ::treesitter_types::FromNode<'tree> for HashChildren<'tree> {
8832    #[allow(clippy::collapsible_else_if)]
8833    fn from_node(
8834        node: ::treesitter_types::tree_sitter::Node<'tree>,
8835        src: &'tree [u8],
8836    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8837        match node.kind() {
8838            "hash_splat_argument" => Ok(Self::HashSplatArgument(::std::boxed::Box::new(
8839                ::treesitter_types::runtime::maybe_grow_stack(|| {
8840                    <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
8841                })?,
8842            ))),
8843            "pair" => Ok(Self::Pair(::std::boxed::Box::new(
8844                ::treesitter_types::runtime::maybe_grow_stack(|| {
8845                    <Pair as ::treesitter_types::FromNode>::from_node(node, src)
8846                })?,
8847            ))),
8848            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8849        }
8850    }
8851}
8852impl ::treesitter_types::Spanned for HashChildren<'_> {
8853    fn span(&self) -> ::treesitter_types::Span {
8854        match self {
8855            Self::HashSplatArgument(inner) => inner.span(),
8856            Self::Pair(inner) => inner.span(),
8857        }
8858    }
8859}
8860#[derive(Debug, Clone, PartialEq, Eq)]
8861pub enum HashPatternChildren<'tree> {
8862    HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
8863    HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
8864    KeywordPattern(::std::boxed::Box<KeywordPattern<'tree>>),
8865}
8866impl<'tree> ::treesitter_types::FromNode<'tree> for HashPatternChildren<'tree> {
8867    #[allow(clippy::collapsible_else_if)]
8868    fn from_node(
8869        node: ::treesitter_types::tree_sitter::Node<'tree>,
8870        src: &'tree [u8],
8871    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8872        match node.kind() {
8873            "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
8874                ::treesitter_types::runtime::maybe_grow_stack(|| {
8875                    <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)
8876                })?,
8877            ))),
8878            "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
8879                ::treesitter_types::runtime::maybe_grow_stack(|| {
8880                    <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
8881                })?,
8882            ))),
8883            "keyword_pattern" => Ok(Self::KeywordPattern(::std::boxed::Box::new(
8884                ::treesitter_types::runtime::maybe_grow_stack(|| {
8885                    <KeywordPattern as ::treesitter_types::FromNode>::from_node(node, src)
8886                })?,
8887            ))),
8888            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8889        }
8890    }
8891}
8892impl ::treesitter_types::Spanned for HashPatternChildren<'_> {
8893    fn span(&self) -> ::treesitter_types::Span {
8894        match self {
8895            Self::HashSplatNil(inner) => inner.span(),
8896            Self::HashSplatParameter(inner) => inner.span(),
8897            Self::KeywordPattern(inner) => inner.span(),
8898        }
8899    }
8900}
8901#[derive(Debug, Clone, PartialEq, Eq)]
8902pub enum HeredocBodyChildren<'tree> {
8903    EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
8904    HeredocContent(::std::boxed::Box<HeredocContent<'tree>>),
8905    HeredocEnd(::std::boxed::Box<HeredocEnd<'tree>>),
8906    Interpolation(::std::boxed::Box<Interpolation<'tree>>),
8907}
8908impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBodyChildren<'tree> {
8909    #[allow(clippy::collapsible_else_if)]
8910    fn from_node(
8911        node: ::treesitter_types::tree_sitter::Node<'tree>,
8912        src: &'tree [u8],
8913    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8914        match node.kind() {
8915            "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
8916                ::treesitter_types::runtime::maybe_grow_stack(|| {
8917                    <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
8918                })?,
8919            ))),
8920            "heredoc_content" => Ok(Self::HeredocContent(::std::boxed::Box::new(
8921                ::treesitter_types::runtime::maybe_grow_stack(|| {
8922                    <HeredocContent as ::treesitter_types::FromNode>::from_node(node, src)
8923                })?,
8924            ))),
8925            "heredoc_end" => Ok(Self::HeredocEnd(::std::boxed::Box::new(
8926                ::treesitter_types::runtime::maybe_grow_stack(|| {
8927                    <HeredocEnd as ::treesitter_types::FromNode>::from_node(node, src)
8928                })?,
8929            ))),
8930            "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
8931                ::treesitter_types::runtime::maybe_grow_stack(|| {
8932                    <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
8933                })?,
8934            ))),
8935            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8936        }
8937    }
8938}
8939impl ::treesitter_types::Spanned for HeredocBodyChildren<'_> {
8940    fn span(&self) -> ::treesitter_types::Span {
8941        match self {
8942            Self::EscapeSequence(inner) => inner.span(),
8943            Self::HeredocContent(inner) => inner.span(),
8944            Self::HeredocEnd(inner) => inner.span(),
8945            Self::Interpolation(inner) => inner.span(),
8946        }
8947    }
8948}
8949#[derive(Debug, Clone, PartialEq, Eq)]
8950pub enum IfAlternative<'tree> {
8951    Else(::std::boxed::Box<Else<'tree>>),
8952    Elsif(::std::boxed::Box<Elsif<'tree>>),
8953}
8954impl<'tree> ::treesitter_types::FromNode<'tree> for IfAlternative<'tree> {
8955    #[allow(clippy::collapsible_else_if)]
8956    fn from_node(
8957        node: ::treesitter_types::tree_sitter::Node<'tree>,
8958        src: &'tree [u8],
8959    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8960        match node.kind() {
8961            "else" => Ok(Self::Else(::std::boxed::Box::new(
8962                ::treesitter_types::runtime::maybe_grow_stack(|| {
8963                    <Else as ::treesitter_types::FromNode>::from_node(node, src)
8964                })?,
8965            ))),
8966            "elsif" => Ok(Self::Elsif(::std::boxed::Box::new(
8967                ::treesitter_types::runtime::maybe_grow_stack(|| {
8968                    <Elsif as ::treesitter_types::FromNode>::from_node(node, src)
8969                })?,
8970            ))),
8971            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8972        }
8973    }
8974}
8975impl ::treesitter_types::Spanned for IfAlternative<'_> {
8976    fn span(&self) -> ::treesitter_types::Span {
8977        match self {
8978            Self::Else(inner) => inner.span(),
8979            Self::Elsif(inner) => inner.span(),
8980        }
8981    }
8982}
8983#[derive(Debug, Clone, PartialEq, Eq)]
8984pub enum InClauseGuard<'tree> {
8985    IfGuard(::std::boxed::Box<IfGuard<'tree>>),
8986    UnlessGuard(::std::boxed::Box<UnlessGuard<'tree>>),
8987}
8988impl<'tree> ::treesitter_types::FromNode<'tree> for InClauseGuard<'tree> {
8989    #[allow(clippy::collapsible_else_if)]
8990    fn from_node(
8991        node: ::treesitter_types::tree_sitter::Node<'tree>,
8992        src: &'tree [u8],
8993    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8994        match node.kind() {
8995            "if_guard" => Ok(Self::IfGuard(::std::boxed::Box::new(
8996                ::treesitter_types::runtime::maybe_grow_stack(|| {
8997                    <IfGuard as ::treesitter_types::FromNode>::from_node(node, src)
8998                })?,
8999            ))),
9000            "unless_guard" => Ok(Self::UnlessGuard(::std::boxed::Box::new(
9001                ::treesitter_types::runtime::maybe_grow_stack(|| {
9002                    <UnlessGuard as ::treesitter_types::FromNode>::from_node(node, src)
9003                })?,
9004            ))),
9005            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9006        }
9007    }
9008}
9009impl ::treesitter_types::Spanned for InClauseGuard<'_> {
9010    fn span(&self) -> ::treesitter_types::Span {
9011        match self {
9012            Self::IfGuard(inner) => inner.span(),
9013            Self::UnlessGuard(inner) => inner.span(),
9014        }
9015    }
9016}
9017#[derive(Debug, Clone, PartialEq, Eq)]
9018pub enum InterpolationChildren<'tree> {
9019    NonlocalVariable(::std::boxed::Box<NonlocalVariable<'tree>>),
9020    Statement(::std::boxed::Box<Statement<'tree>>),
9021    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
9022}
9023impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationChildren<'tree> {
9024    #[allow(clippy::collapsible_else_if)]
9025    fn from_node(
9026        node: ::treesitter_types::tree_sitter::Node<'tree>,
9027        src: &'tree [u8],
9028    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9029        match node.kind() {
9030            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
9031                ::treesitter_types::runtime::maybe_grow_stack(|| {
9032                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
9033                })?,
9034            ))),
9035            _other => {
9036                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9037                    <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
9038                }) {
9039                    Ok(Self::NonlocalVariable(::std::boxed::Box::new(v)))
9040                } else {
9041                    if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9042                        <Statement as ::treesitter_types::FromNode>::from_node(node, src)
9043                    }) {
9044                        Ok(Self::Statement(::std::boxed::Box::new(v)))
9045                    } else {
9046                        Err(::treesitter_types::ParseError::unexpected_kind(
9047                            _other, node,
9048                        ))
9049                    }
9050                }
9051            }
9052        }
9053    }
9054}
9055impl ::treesitter_types::Spanned for InterpolationChildren<'_> {
9056    fn span(&self) -> ::treesitter_types::Span {
9057        match self {
9058            Self::NonlocalVariable(inner) => inner.span(),
9059            Self::Statement(inner) => inner.span(),
9060            Self::EmptyStatement(inner) => inner.span(),
9061        }
9062    }
9063}
9064#[derive(Debug, Clone, PartialEq, Eq)]
9065pub enum KeywordPatternKey<'tree> {
9066    HashKeySymbol(::std::boxed::Box<HashKeySymbol<'tree>>),
9067    String(::std::boxed::Box<String<'tree>>),
9068}
9069impl<'tree> ::treesitter_types::FromNode<'tree> for KeywordPatternKey<'tree> {
9070    #[allow(clippy::collapsible_else_if)]
9071    fn from_node(
9072        node: ::treesitter_types::tree_sitter::Node<'tree>,
9073        src: &'tree [u8],
9074    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9075        match node.kind() {
9076            "hash_key_symbol" => Ok(Self::HashKeySymbol(::std::boxed::Box::new(
9077                ::treesitter_types::runtime::maybe_grow_stack(|| {
9078                    <HashKeySymbol as ::treesitter_types::FromNode>::from_node(node, src)
9079                })?,
9080            ))),
9081            "string" => Ok(Self::String(::std::boxed::Box::new(
9082                ::treesitter_types::runtime::maybe_grow_stack(|| {
9083                    <String as ::treesitter_types::FromNode>::from_node(node, src)
9084                })?,
9085            ))),
9086            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9087        }
9088    }
9089}
9090impl ::treesitter_types::Spanned for KeywordPatternKey<'_> {
9091    fn span(&self) -> ::treesitter_types::Span {
9092        match self {
9093            Self::HashKeySymbol(inner) => inner.span(),
9094            Self::String(inner) => inner.span(),
9095        }
9096    }
9097}
9098#[derive(Debug, Clone, PartialEq, Eq)]
9099pub enum LambdaBody<'tree> {
9100    Block(::std::boxed::Box<Block<'tree>>),
9101    DoBlock(::std::boxed::Box<DoBlock<'tree>>),
9102}
9103impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaBody<'tree> {
9104    #[allow(clippy::collapsible_else_if)]
9105    fn from_node(
9106        node: ::treesitter_types::tree_sitter::Node<'tree>,
9107        src: &'tree [u8],
9108    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9109        match node.kind() {
9110            "block" => Ok(Self::Block(::std::boxed::Box::new(
9111                ::treesitter_types::runtime::maybe_grow_stack(|| {
9112                    <Block as ::treesitter_types::FromNode>::from_node(node, src)
9113                })?,
9114            ))),
9115            "do_block" => Ok(Self::DoBlock(::std::boxed::Box::new(
9116                ::treesitter_types::runtime::maybe_grow_stack(|| {
9117                    <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)
9118                })?,
9119            ))),
9120            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9121        }
9122    }
9123}
9124impl ::treesitter_types::Spanned for LambdaBody<'_> {
9125    fn span(&self) -> ::treesitter_types::Span {
9126        match self {
9127            Self::Block(inner) => inner.span(),
9128            Self::DoBlock(inner) => inner.span(),
9129        }
9130    }
9131}
9132#[derive(Debug, Clone, PartialEq, Eq)]
9133pub enum LambdaParametersChildren<'tree> {
9134    BlockParameter(::std::boxed::Box<BlockParameter<'tree>>),
9135    DestructuredParameter(::std::boxed::Box<DestructuredParameter<'tree>>),
9136    ForwardParameter(::std::boxed::Box<ForwardParameter<'tree>>),
9137    HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
9138    HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
9139    Identifier(::std::boxed::Box<Identifier<'tree>>),
9140    KeywordParameter(::std::boxed::Box<KeywordParameter<'tree>>),
9141    OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
9142    SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
9143}
9144impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaParametersChildren<'tree> {
9145    #[allow(clippy::collapsible_else_if)]
9146    fn from_node(
9147        node: ::treesitter_types::tree_sitter::Node<'tree>,
9148        src: &'tree [u8],
9149    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9150        match node.kind() {
9151            "block_parameter" => Ok(Self::BlockParameter(::std::boxed::Box::new(
9152                ::treesitter_types::runtime::maybe_grow_stack(|| {
9153                    <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)
9154                })?,
9155            ))),
9156            "destructured_parameter" => Ok(Self::DestructuredParameter(::std::boxed::Box::new(
9157                ::treesitter_types::runtime::maybe_grow_stack(|| {
9158                    <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)
9159                })?,
9160            ))),
9161            "forward_parameter" => Ok(Self::ForwardParameter(::std::boxed::Box::new(
9162                ::treesitter_types::runtime::maybe_grow_stack(|| {
9163                    <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)
9164                })?,
9165            ))),
9166            "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
9167                ::treesitter_types::runtime::maybe_grow_stack(|| {
9168                    <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)
9169                })?,
9170            ))),
9171            "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
9172                ::treesitter_types::runtime::maybe_grow_stack(|| {
9173                    <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
9174                })?,
9175            ))),
9176            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9177                ::treesitter_types::runtime::maybe_grow_stack(|| {
9178                    <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9179                })?,
9180            ))),
9181            "keyword_parameter" => Ok(Self::KeywordParameter(::std::boxed::Box::new(
9182                ::treesitter_types::runtime::maybe_grow_stack(|| {
9183                    <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)
9184                })?,
9185            ))),
9186            "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
9187                ::treesitter_types::runtime::maybe_grow_stack(|| {
9188                    <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)
9189                })?,
9190            ))),
9191            "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
9192                ::treesitter_types::runtime::maybe_grow_stack(|| {
9193                    <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
9194                })?,
9195            ))),
9196            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9197        }
9198    }
9199}
9200impl ::treesitter_types::Spanned for LambdaParametersChildren<'_> {
9201    fn span(&self) -> ::treesitter_types::Span {
9202        match self {
9203            Self::BlockParameter(inner) => inner.span(),
9204            Self::DestructuredParameter(inner) => inner.span(),
9205            Self::ForwardParameter(inner) => inner.span(),
9206            Self::HashSplatNil(inner) => inner.span(),
9207            Self::HashSplatParameter(inner) => inner.span(),
9208            Self::Identifier(inner) => inner.span(),
9209            Self::KeywordParameter(inner) => inner.span(),
9210            Self::OptionalParameter(inner) => inner.span(),
9211            Self::SplatParameter(inner) => inner.span(),
9212        }
9213    }
9214}
9215#[derive(Debug, Clone, PartialEq, Eq)]
9216pub enum LeftAssignmentListChildren<'tree> {
9217    Lhs(::std::boxed::Box<Lhs<'tree>>),
9218    DestructuredLeftAssignment(::std::boxed::Box<DestructuredLeftAssignment<'tree>>),
9219    RestAssignment(::std::boxed::Box<RestAssignment<'tree>>),
9220}
9221impl<'tree> ::treesitter_types::FromNode<'tree> for LeftAssignmentListChildren<'tree> {
9222    #[allow(clippy::collapsible_else_if)]
9223    fn from_node(
9224        node: ::treesitter_types::tree_sitter::Node<'tree>,
9225        src: &'tree [u8],
9226    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9227        match node.kind() {
9228            "destructured_left_assignment" => Ok(Self::DestructuredLeftAssignment(
9229                ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9230                    <DestructuredLeftAssignment as ::treesitter_types::FromNode>::from_node(
9231                        node, src,
9232                    )
9233                })?),
9234            )),
9235            "rest_assignment" => Ok(Self::RestAssignment(::std::boxed::Box::new(
9236                ::treesitter_types::runtime::maybe_grow_stack(|| {
9237                    <RestAssignment as ::treesitter_types::FromNode>::from_node(node, src)
9238                })?,
9239            ))),
9240            _other => {
9241                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9242                    <Lhs as ::treesitter_types::FromNode>::from_node(node, src)
9243                }) {
9244                    Ok(Self::Lhs(::std::boxed::Box::new(v)))
9245                } else {
9246                    Err(::treesitter_types::ParseError::unexpected_kind(
9247                        _other, node,
9248                    ))
9249                }
9250            }
9251        }
9252    }
9253}
9254impl ::treesitter_types::Spanned for LeftAssignmentListChildren<'_> {
9255    fn span(&self) -> ::treesitter_types::Span {
9256        match self {
9257            Self::Lhs(inner) => inner.span(),
9258            Self::DestructuredLeftAssignment(inner) => inner.span(),
9259            Self::RestAssignment(inner) => inner.span(),
9260        }
9261    }
9262}
9263#[derive(Debug, Clone, PartialEq, Eq)]
9264pub enum MethodBody<'tree> {
9265    Arg(::std::boxed::Box<Arg<'tree>>),
9266    BodyStatement(::std::boxed::Box<BodyStatement<'tree>>),
9267    RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
9268}
9269impl<'tree> ::treesitter_types::FromNode<'tree> for MethodBody<'tree> {
9270    #[allow(clippy::collapsible_else_if)]
9271    fn from_node(
9272        node: ::treesitter_types::tree_sitter::Node<'tree>,
9273        src: &'tree [u8],
9274    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9275        match node.kind() {
9276            "body_statement" => Ok(Self::BodyStatement(::std::boxed::Box::new(
9277                ::treesitter_types::runtime::maybe_grow_stack(|| {
9278                    <BodyStatement as ::treesitter_types::FromNode>::from_node(node, src)
9279                })?,
9280            ))),
9281            "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
9282                ::treesitter_types::runtime::maybe_grow_stack(|| {
9283                    <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)
9284                })?,
9285            ))),
9286            _other => {
9287                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9288                    <Arg as ::treesitter_types::FromNode>::from_node(node, src)
9289                }) {
9290                    Ok(Self::Arg(::std::boxed::Box::new(v)))
9291                } else {
9292                    Err(::treesitter_types::ParseError::unexpected_kind(
9293                        _other, node,
9294                    ))
9295                }
9296            }
9297        }
9298    }
9299}
9300impl ::treesitter_types::Spanned for MethodBody<'_> {
9301    fn span(&self) -> ::treesitter_types::Span {
9302        match self {
9303            Self::Arg(inner) => inner.span(),
9304            Self::BodyStatement(inner) => inner.span(),
9305            Self::RescueModifier(inner) => inner.span(),
9306        }
9307    }
9308}
9309#[derive(Debug, Clone, PartialEq, Eq)]
9310pub enum MethodParametersChildren<'tree> {
9311    BlockParameter(::std::boxed::Box<BlockParameter<'tree>>),
9312    DestructuredParameter(::std::boxed::Box<DestructuredParameter<'tree>>),
9313    ForwardParameter(::std::boxed::Box<ForwardParameter<'tree>>),
9314    HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
9315    HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
9316    Identifier(::std::boxed::Box<Identifier<'tree>>),
9317    KeywordParameter(::std::boxed::Box<KeywordParameter<'tree>>),
9318    OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
9319    SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
9320}
9321impl<'tree> ::treesitter_types::FromNode<'tree> for MethodParametersChildren<'tree> {
9322    #[allow(clippy::collapsible_else_if)]
9323    fn from_node(
9324        node: ::treesitter_types::tree_sitter::Node<'tree>,
9325        src: &'tree [u8],
9326    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9327        match node.kind() {
9328            "block_parameter" => Ok(Self::BlockParameter(::std::boxed::Box::new(
9329                ::treesitter_types::runtime::maybe_grow_stack(|| {
9330                    <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)
9331                })?,
9332            ))),
9333            "destructured_parameter" => Ok(Self::DestructuredParameter(::std::boxed::Box::new(
9334                ::treesitter_types::runtime::maybe_grow_stack(|| {
9335                    <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)
9336                })?,
9337            ))),
9338            "forward_parameter" => Ok(Self::ForwardParameter(::std::boxed::Box::new(
9339                ::treesitter_types::runtime::maybe_grow_stack(|| {
9340                    <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)
9341                })?,
9342            ))),
9343            "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
9344                ::treesitter_types::runtime::maybe_grow_stack(|| {
9345                    <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)
9346                })?,
9347            ))),
9348            "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
9349                ::treesitter_types::runtime::maybe_grow_stack(|| {
9350                    <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
9351                })?,
9352            ))),
9353            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9354                ::treesitter_types::runtime::maybe_grow_stack(|| {
9355                    <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9356                })?,
9357            ))),
9358            "keyword_parameter" => Ok(Self::KeywordParameter(::std::boxed::Box::new(
9359                ::treesitter_types::runtime::maybe_grow_stack(|| {
9360                    <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)
9361                })?,
9362            ))),
9363            "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
9364                ::treesitter_types::runtime::maybe_grow_stack(|| {
9365                    <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)
9366                })?,
9367            ))),
9368            "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
9369                ::treesitter_types::runtime::maybe_grow_stack(|| {
9370                    <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
9371                })?,
9372            ))),
9373            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9374        }
9375    }
9376}
9377impl ::treesitter_types::Spanned for MethodParametersChildren<'_> {
9378    fn span(&self) -> ::treesitter_types::Span {
9379        match self {
9380            Self::BlockParameter(inner) => inner.span(),
9381            Self::DestructuredParameter(inner) => inner.span(),
9382            Self::ForwardParameter(inner) => inner.span(),
9383            Self::HashSplatNil(inner) => inner.span(),
9384            Self::HashSplatParameter(inner) => inner.span(),
9385            Self::Identifier(inner) => inner.span(),
9386            Self::KeywordParameter(inner) => inner.span(),
9387            Self::OptionalParameter(inner) => inner.span(),
9388            Self::SplatParameter(inner) => inner.span(),
9389        }
9390    }
9391}
9392#[derive(Debug, Clone, PartialEq, Eq)]
9393pub enum ModuleName<'tree> {
9394    Constant(::std::boxed::Box<Constant<'tree>>),
9395    ScopeResolution(::std::boxed::Box<ScopeResolution<'tree>>),
9396}
9397impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleName<'tree> {
9398    #[allow(clippy::collapsible_else_if)]
9399    fn from_node(
9400        node: ::treesitter_types::tree_sitter::Node<'tree>,
9401        src: &'tree [u8],
9402    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9403        match node.kind() {
9404            "constant" => Ok(Self::Constant(::std::boxed::Box::new(
9405                ::treesitter_types::runtime::maybe_grow_stack(|| {
9406                    <Constant as ::treesitter_types::FromNode>::from_node(node, src)
9407                })?,
9408            ))),
9409            "scope_resolution" => Ok(Self::ScopeResolution(::std::boxed::Box::new(
9410                ::treesitter_types::runtime::maybe_grow_stack(|| {
9411                    <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)
9412                })?,
9413            ))),
9414            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9415        }
9416    }
9417}
9418impl ::treesitter_types::Spanned for ModuleName<'_> {
9419    fn span(&self) -> ::treesitter_types::Span {
9420        match self {
9421            Self::Constant(inner) => inner.span(),
9422            Self::ScopeResolution(inner) => inner.span(),
9423        }
9424    }
9425}
9426#[derive(Debug, Clone, PartialEq, Eq)]
9427pub enum OperatorAssignmentOperator {
9428    PercentEq(::treesitter_types::Span),
9429    AmpAmpEq(::treesitter_types::Span),
9430    AmpEq(::treesitter_types::Span),
9431    StarStarEq(::treesitter_types::Span),
9432    StarEq(::treesitter_types::Span),
9433    PlusEq(::treesitter_types::Span),
9434    MinusEq(::treesitter_types::Span),
9435    SlashEq(::treesitter_types::Span),
9436    ShlEq(::treesitter_types::Span),
9437    ShrEq(::treesitter_types::Span),
9438    CaretEq(::treesitter_types::Span),
9439    PipeEq(::treesitter_types::Span),
9440    PipePipeEq(::treesitter_types::Span),
9441}
9442impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorAssignmentOperator {
9443    #[allow(clippy::collapsible_else_if)]
9444    fn from_node(
9445        node: ::treesitter_types::tree_sitter::Node<'tree>,
9446        _src: &'tree [u8],
9447    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9448        match node.kind() {
9449            "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
9450            "&&=" => Ok(Self::AmpAmpEq(::treesitter_types::Span::from(node))),
9451            "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
9452            "**=" => Ok(Self::StarStarEq(::treesitter_types::Span::from(node))),
9453            "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
9454            "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
9455            "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
9456            "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
9457            "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
9458            ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
9459            "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
9460            "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
9461            "||=" => Ok(Self::PipePipeEq(::treesitter_types::Span::from(node))),
9462            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9463        }
9464    }
9465}
9466impl ::treesitter_types::Spanned for OperatorAssignmentOperator {
9467    fn span(&self) -> ::treesitter_types::Span {
9468        match self {
9469            Self::PercentEq(span) => *span,
9470            Self::AmpAmpEq(span) => *span,
9471            Self::AmpEq(span) => *span,
9472            Self::StarStarEq(span) => *span,
9473            Self::StarEq(span) => *span,
9474            Self::PlusEq(span) => *span,
9475            Self::MinusEq(span) => *span,
9476            Self::SlashEq(span) => *span,
9477            Self::ShlEq(span) => *span,
9478            Self::ShrEq(span) => *span,
9479            Self::CaretEq(span) => *span,
9480            Self::PipeEq(span) => *span,
9481            Self::PipePipeEq(span) => *span,
9482        }
9483    }
9484}
9485#[derive(Debug, Clone, PartialEq, Eq)]
9486pub enum OperatorAssignmentRight<'tree> {
9487    Expression(::std::boxed::Box<Expression<'tree>>),
9488    RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
9489}
9490impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorAssignmentRight<'tree> {
9491    #[allow(clippy::collapsible_else_if)]
9492    fn from_node(
9493        node: ::treesitter_types::tree_sitter::Node<'tree>,
9494        src: &'tree [u8],
9495    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9496        match node.kind() {
9497            "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
9498                ::treesitter_types::runtime::maybe_grow_stack(|| {
9499                    <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)
9500                })?,
9501            ))),
9502            _other => {
9503                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9504                    <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9505                }) {
9506                    Ok(Self::Expression(::std::boxed::Box::new(v)))
9507                } else {
9508                    Err(::treesitter_types::ParseError::unexpected_kind(
9509                        _other, node,
9510                    ))
9511                }
9512            }
9513        }
9514    }
9515}
9516impl ::treesitter_types::Spanned for OperatorAssignmentRight<'_> {
9517    fn span(&self) -> ::treesitter_types::Span {
9518        match self {
9519            Self::Expression(inner) => inner.span(),
9520            Self::RescueModifier(inner) => inner.span(),
9521        }
9522    }
9523}
9524#[derive(Debug, Clone, PartialEq, Eq)]
9525pub enum PairKey<'tree> {
9526    Arg(::std::boxed::Box<Arg<'tree>>),
9527    HashKeySymbol(::std::boxed::Box<HashKeySymbol<'tree>>),
9528    String(::std::boxed::Box<String<'tree>>),
9529}
9530impl<'tree> ::treesitter_types::FromNode<'tree> for PairKey<'tree> {
9531    #[allow(clippy::collapsible_else_if)]
9532    fn from_node(
9533        node: ::treesitter_types::tree_sitter::Node<'tree>,
9534        src: &'tree [u8],
9535    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9536        match node.kind() {
9537            "hash_key_symbol" => Ok(Self::HashKeySymbol(::std::boxed::Box::new(
9538                ::treesitter_types::runtime::maybe_grow_stack(|| {
9539                    <HashKeySymbol as ::treesitter_types::FromNode>::from_node(node, src)
9540                })?,
9541            ))),
9542            "string" => Ok(Self::String(::std::boxed::Box::new(
9543                ::treesitter_types::runtime::maybe_grow_stack(|| {
9544                    <String as ::treesitter_types::FromNode>::from_node(node, src)
9545                })?,
9546            ))),
9547            _other => {
9548                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9549                    <Arg as ::treesitter_types::FromNode>::from_node(node, src)
9550                }) {
9551                    Ok(Self::Arg(::std::boxed::Box::new(v)))
9552                } else {
9553                    Err(::treesitter_types::ParseError::unexpected_kind(
9554                        _other, node,
9555                    ))
9556                }
9557            }
9558        }
9559    }
9560}
9561impl ::treesitter_types::Spanned for PairKey<'_> {
9562    fn span(&self) -> ::treesitter_types::Span {
9563        match self {
9564            Self::Arg(inner) => inner.span(),
9565            Self::HashKeySymbol(inner) => inner.span(),
9566            Self::String(inner) => inner.span(),
9567        }
9568    }
9569}
9570#[derive(Debug, Clone, PartialEq, Eq)]
9571pub enum ParenthesizedStatementsChildren<'tree> {
9572    Statement(::std::boxed::Box<Statement<'tree>>),
9573    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
9574}
9575impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedStatementsChildren<'tree> {
9576    #[allow(clippy::collapsible_else_if)]
9577    fn from_node(
9578        node: ::treesitter_types::tree_sitter::Node<'tree>,
9579        src: &'tree [u8],
9580    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9581        match node.kind() {
9582            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
9583                ::treesitter_types::runtime::maybe_grow_stack(|| {
9584                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
9585                })?,
9586            ))),
9587            _other => {
9588                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9589                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
9590                }) {
9591                    Ok(Self::Statement(::std::boxed::Box::new(v)))
9592                } else {
9593                    Err(::treesitter_types::ParseError::unexpected_kind(
9594                        _other, node,
9595                    ))
9596                }
9597            }
9598        }
9599    }
9600}
9601impl ::treesitter_types::Spanned for ParenthesizedStatementsChildren<'_> {
9602    fn span(&self) -> ::treesitter_types::Span {
9603        match self {
9604            Self::Statement(inner) => inner.span(),
9605            Self::EmptyStatement(inner) => inner.span(),
9606        }
9607    }
9608}
9609#[derive(Debug, Clone, PartialEq, Eq)]
9610pub enum PatternChildren<'tree> {
9611    Arg(::std::boxed::Box<Arg<'tree>>),
9612    SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
9613}
9614impl<'tree> ::treesitter_types::FromNode<'tree> for PatternChildren<'tree> {
9615    #[allow(clippy::collapsible_else_if)]
9616    fn from_node(
9617        node: ::treesitter_types::tree_sitter::Node<'tree>,
9618        src: &'tree [u8],
9619    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9620        match node.kind() {
9621            "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
9622                ::treesitter_types::runtime::maybe_grow_stack(|| {
9623                    <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
9624                })?,
9625            ))),
9626            _other => {
9627                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9628                    <Arg as ::treesitter_types::FromNode>::from_node(node, src)
9629                }) {
9630                    Ok(Self::Arg(::std::boxed::Box::new(v)))
9631                } else {
9632                    Err(::treesitter_types::ParseError::unexpected_kind(
9633                        _other, node,
9634                    ))
9635                }
9636            }
9637        }
9638    }
9639}
9640impl ::treesitter_types::Spanned for PatternChildren<'_> {
9641    fn span(&self) -> ::treesitter_types::Span {
9642        match self {
9643            Self::Arg(inner) => inner.span(),
9644            Self::SplatArgument(inner) => inner.span(),
9645        }
9646    }
9647}
9648#[derive(Debug, Clone, PartialEq, Eq)]
9649pub enum ProgramChildren<'tree> {
9650    Statement(::std::boxed::Box<Statement<'tree>>),
9651    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
9652    Uninterpreted(::std::boxed::Box<Uninterpreted<'tree>>),
9653}
9654impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
9655    #[allow(clippy::collapsible_else_if)]
9656    fn from_node(
9657        node: ::treesitter_types::tree_sitter::Node<'tree>,
9658        src: &'tree [u8],
9659    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9660        match node.kind() {
9661            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
9662                ::treesitter_types::runtime::maybe_grow_stack(|| {
9663                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
9664                })?,
9665            ))),
9666            "uninterpreted" => Ok(Self::Uninterpreted(::std::boxed::Box::new(
9667                ::treesitter_types::runtime::maybe_grow_stack(|| {
9668                    <Uninterpreted as ::treesitter_types::FromNode>::from_node(node, src)
9669                })?,
9670            ))),
9671            _other => {
9672                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9673                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
9674                }) {
9675                    Ok(Self::Statement(::std::boxed::Box::new(v)))
9676                } else {
9677                    Err(::treesitter_types::ParseError::unexpected_kind(
9678                        _other, node,
9679                    ))
9680                }
9681            }
9682        }
9683    }
9684}
9685impl ::treesitter_types::Spanned for ProgramChildren<'_> {
9686    fn span(&self) -> ::treesitter_types::Span {
9687        match self {
9688            Self::Statement(inner) => inner.span(),
9689            Self::EmptyStatement(inner) => inner.span(),
9690            Self::Uninterpreted(inner) => inner.span(),
9691        }
9692    }
9693}
9694#[derive(Debug, Clone, PartialEq, Eq)]
9695pub enum RangeBegin<'tree> {
9696    Arg(::std::boxed::Box<Arg<'tree>>),
9697    PatternPrimitive(::std::boxed::Box<PatternPrimitive<'tree>>),
9698}
9699impl<'tree> ::treesitter_types::FromNode<'tree> for RangeBegin<'tree> {
9700    #[allow(clippy::collapsible_else_if)]
9701    fn from_node(
9702        node: ::treesitter_types::tree_sitter::Node<'tree>,
9703        src: &'tree [u8],
9704    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9705        if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9706            <Arg as ::treesitter_types::FromNode>::from_node(node, src)
9707        }) {
9708            Ok(Self::Arg(::std::boxed::Box::new(v)))
9709        } else {
9710            if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9711                <PatternPrimitive as ::treesitter_types::FromNode>::from_node(node, src)
9712            }) {
9713                Ok(Self::PatternPrimitive(::std::boxed::Box::new(v)))
9714            } else {
9715                Err(::treesitter_types::ParseError::unexpected_kind(
9716                    node.kind(),
9717                    node,
9718                ))
9719            }
9720        }
9721    }
9722}
9723impl ::treesitter_types::Spanned for RangeBegin<'_> {
9724    fn span(&self) -> ::treesitter_types::Span {
9725        match self {
9726            Self::Arg(inner) => inner.span(),
9727            Self::PatternPrimitive(inner) => inner.span(),
9728        }
9729    }
9730}
9731#[derive(Debug, Clone, PartialEq, Eq)]
9732pub enum RangeEnd<'tree> {
9733    Arg(::std::boxed::Box<Arg<'tree>>),
9734    PatternPrimitive(::std::boxed::Box<PatternPrimitive<'tree>>),
9735}
9736impl<'tree> ::treesitter_types::FromNode<'tree> for RangeEnd<'tree> {
9737    #[allow(clippy::collapsible_else_if)]
9738    fn from_node(
9739        node: ::treesitter_types::tree_sitter::Node<'tree>,
9740        src: &'tree [u8],
9741    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9742        if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9743            <Arg as ::treesitter_types::FromNode>::from_node(node, src)
9744        }) {
9745            Ok(Self::Arg(::std::boxed::Box::new(v)))
9746        } else {
9747            if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9748                <PatternPrimitive as ::treesitter_types::FromNode>::from_node(node, src)
9749            }) {
9750                Ok(Self::PatternPrimitive(::std::boxed::Box::new(v)))
9751            } else {
9752                Err(::treesitter_types::ParseError::unexpected_kind(
9753                    node.kind(),
9754                    node,
9755                ))
9756            }
9757        }
9758    }
9759}
9760impl ::treesitter_types::Spanned for RangeEnd<'_> {
9761    fn span(&self) -> ::treesitter_types::Span {
9762        match self {
9763            Self::Arg(inner) => inner.span(),
9764            Self::PatternPrimitive(inner) => inner.span(),
9765        }
9766    }
9767}
9768#[derive(Debug, Clone, PartialEq, Eq)]
9769pub enum RangeOperator {
9770    DotDot(::treesitter_types::Span),
9771    Ellipsis(::treesitter_types::Span),
9772}
9773impl<'tree> ::treesitter_types::FromNode<'tree> for RangeOperator {
9774    #[allow(clippy::collapsible_else_if)]
9775    fn from_node(
9776        node: ::treesitter_types::tree_sitter::Node<'tree>,
9777        _src: &'tree [u8],
9778    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9779        match node.kind() {
9780            ".." => Ok(Self::DotDot(::treesitter_types::Span::from(node))),
9781            "..." => Ok(Self::Ellipsis(::treesitter_types::Span::from(node))),
9782            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9783        }
9784    }
9785}
9786impl ::treesitter_types::Spanned for RangeOperator {
9787    fn span(&self) -> ::treesitter_types::Span {
9788        match self {
9789            Self::DotDot(span) => *span,
9790            Self::Ellipsis(span) => *span,
9791        }
9792    }
9793}
9794#[derive(Debug, Clone, PartialEq, Eq)]
9795pub enum RationalChildren<'tree> {
9796    Float(::std::boxed::Box<Float<'tree>>),
9797    Integer(::std::boxed::Box<Integer<'tree>>),
9798}
9799impl<'tree> ::treesitter_types::FromNode<'tree> for RationalChildren<'tree> {
9800    #[allow(clippy::collapsible_else_if)]
9801    fn from_node(
9802        node: ::treesitter_types::tree_sitter::Node<'tree>,
9803        src: &'tree [u8],
9804    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9805        match node.kind() {
9806            "float" => Ok(Self::Float(::std::boxed::Box::new(
9807                ::treesitter_types::runtime::maybe_grow_stack(|| {
9808                    <Float as ::treesitter_types::FromNode>::from_node(node, src)
9809                })?,
9810            ))),
9811            "integer" => Ok(Self::Integer(::std::boxed::Box::new(
9812                ::treesitter_types::runtime::maybe_grow_stack(|| {
9813                    <Integer as ::treesitter_types::FromNode>::from_node(node, src)
9814                })?,
9815            ))),
9816            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9817        }
9818    }
9819}
9820impl ::treesitter_types::Spanned for RationalChildren<'_> {
9821    fn span(&self) -> ::treesitter_types::Span {
9822        match self {
9823            Self::Float(inner) => inner.span(),
9824            Self::Integer(inner) => inner.span(),
9825        }
9826    }
9827}
9828#[derive(Debug, Clone, PartialEq, Eq)]
9829pub enum RegexChildren<'tree> {
9830    EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
9831    Interpolation(::std::boxed::Box<Interpolation<'tree>>),
9832    StringContent(::std::boxed::Box<StringContent<'tree>>),
9833}
9834impl<'tree> ::treesitter_types::FromNode<'tree> for RegexChildren<'tree> {
9835    #[allow(clippy::collapsible_else_if)]
9836    fn from_node(
9837        node: ::treesitter_types::tree_sitter::Node<'tree>,
9838        src: &'tree [u8],
9839    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9840        match node.kind() {
9841            "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
9842                ::treesitter_types::runtime::maybe_grow_stack(|| {
9843                    <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
9844                })?,
9845            ))),
9846            "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
9847                ::treesitter_types::runtime::maybe_grow_stack(|| {
9848                    <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
9849                })?,
9850            ))),
9851            "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
9852                ::treesitter_types::runtime::maybe_grow_stack(|| {
9853                    <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
9854                })?,
9855            ))),
9856            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9857        }
9858    }
9859}
9860impl ::treesitter_types::Spanned for RegexChildren<'_> {
9861    fn span(&self) -> ::treesitter_types::Span {
9862        match self {
9863            Self::EscapeSequence(inner) => inner.span(),
9864            Self::Interpolation(inner) => inner.span(),
9865            Self::StringContent(inner) => inner.span(),
9866        }
9867    }
9868}
9869#[derive(Debug, Clone, PartialEq, Eq)]
9870pub enum RescueModifierBody<'tree> {
9871    Arg(::std::boxed::Box<Arg<'tree>>),
9872    Statement(::std::boxed::Box<Statement<'tree>>),
9873}
9874impl<'tree> ::treesitter_types::FromNode<'tree> for RescueModifierBody<'tree> {
9875    #[allow(clippy::collapsible_else_if)]
9876    fn from_node(
9877        node: ::treesitter_types::tree_sitter::Node<'tree>,
9878        src: &'tree [u8],
9879    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9880        if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9881            <Arg as ::treesitter_types::FromNode>::from_node(node, src)
9882        }) {
9883            Ok(Self::Arg(::std::boxed::Box::new(v)))
9884        } else {
9885            if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9886                <Statement as ::treesitter_types::FromNode>::from_node(node, src)
9887            }) {
9888                Ok(Self::Statement(::std::boxed::Box::new(v)))
9889            } else {
9890                Err(::treesitter_types::ParseError::unexpected_kind(
9891                    node.kind(),
9892                    node,
9893                ))
9894            }
9895        }
9896    }
9897}
9898impl ::treesitter_types::Spanned for RescueModifierBody<'_> {
9899    fn span(&self) -> ::treesitter_types::Span {
9900        match self {
9901            Self::Arg(inner) => inner.span(),
9902            Self::Statement(inner) => inner.span(),
9903        }
9904    }
9905}
9906#[derive(Debug, Clone, PartialEq, Eq)]
9907pub enum RightAssignmentListChildren<'tree> {
9908    Arg(::std::boxed::Box<Arg<'tree>>),
9909    SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
9910}
9911impl<'tree> ::treesitter_types::FromNode<'tree> for RightAssignmentListChildren<'tree> {
9912    #[allow(clippy::collapsible_else_if)]
9913    fn from_node(
9914        node: ::treesitter_types::tree_sitter::Node<'tree>,
9915        src: &'tree [u8],
9916    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9917        match node.kind() {
9918            "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
9919                ::treesitter_types::runtime::maybe_grow_stack(|| {
9920                    <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
9921                })?,
9922            ))),
9923            _other => {
9924                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9925                    <Arg as ::treesitter_types::FromNode>::from_node(node, src)
9926                }) {
9927                    Ok(Self::Arg(::std::boxed::Box::new(v)))
9928                } else {
9929                    Err(::treesitter_types::ParseError::unexpected_kind(
9930                        _other, node,
9931                    ))
9932                }
9933            }
9934        }
9935    }
9936}
9937impl ::treesitter_types::Spanned for RightAssignmentListChildren<'_> {
9938    fn span(&self) -> ::treesitter_types::Span {
9939        match self {
9940            Self::Arg(inner) => inner.span(),
9941            Self::SplatArgument(inner) => inner.span(),
9942        }
9943    }
9944}
9945#[derive(Debug, Clone, PartialEq, Eq)]
9946pub enum ScopeResolutionScope<'tree> {
9947    PatternConstant(::std::boxed::Box<PatternConstant<'tree>>),
9948    Primary(::std::boxed::Box<Primary<'tree>>),
9949}
9950impl<'tree> ::treesitter_types::FromNode<'tree> for ScopeResolutionScope<'tree> {
9951    #[allow(clippy::collapsible_else_if)]
9952    fn from_node(
9953        node: ::treesitter_types::tree_sitter::Node<'tree>,
9954        src: &'tree [u8],
9955    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9956        if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9957            <PatternConstant as ::treesitter_types::FromNode>::from_node(node, src)
9958        }) {
9959            Ok(Self::PatternConstant(::std::boxed::Box::new(v)))
9960        } else {
9961            if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9962                <Primary as ::treesitter_types::FromNode>::from_node(node, src)
9963            }) {
9964                Ok(Self::Primary(::std::boxed::Box::new(v)))
9965            } else {
9966                Err(::treesitter_types::ParseError::unexpected_kind(
9967                    node.kind(),
9968                    node,
9969                ))
9970            }
9971        }
9972    }
9973}
9974impl ::treesitter_types::Spanned for ScopeResolutionScope<'_> {
9975    fn span(&self) -> ::treesitter_types::Span {
9976        match self {
9977            Self::PatternConstant(inner) => inner.span(),
9978            Self::Primary(inner) => inner.span(),
9979        }
9980    }
9981}
9982#[derive(Debug, Clone, PartialEq, Eq)]
9983pub enum SingletonMethodBody<'tree> {
9984    Arg(::std::boxed::Box<Arg<'tree>>),
9985    BodyStatement(::std::boxed::Box<BodyStatement<'tree>>),
9986    RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
9987}
9988impl<'tree> ::treesitter_types::FromNode<'tree> for SingletonMethodBody<'tree> {
9989    #[allow(clippy::collapsible_else_if)]
9990    fn from_node(
9991        node: ::treesitter_types::tree_sitter::Node<'tree>,
9992        src: &'tree [u8],
9993    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9994        match node.kind() {
9995            "body_statement" => Ok(Self::BodyStatement(::std::boxed::Box::new(
9996                ::treesitter_types::runtime::maybe_grow_stack(|| {
9997                    <BodyStatement as ::treesitter_types::FromNode>::from_node(node, src)
9998                })?,
9999            ))),
10000            "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
10001                ::treesitter_types::runtime::maybe_grow_stack(|| {
10002                    <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)
10003                })?,
10004            ))),
10005            _other => {
10006                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10007                    <Arg as ::treesitter_types::FromNode>::from_node(node, src)
10008                }) {
10009                    Ok(Self::Arg(::std::boxed::Box::new(v)))
10010                } else {
10011                    Err(::treesitter_types::ParseError::unexpected_kind(
10012                        _other, node,
10013                    ))
10014                }
10015            }
10016        }
10017    }
10018}
10019impl ::treesitter_types::Spanned for SingletonMethodBody<'_> {
10020    fn span(&self) -> ::treesitter_types::Span {
10021        match self {
10022            Self::Arg(inner) => inner.span(),
10023            Self::BodyStatement(inner) => inner.span(),
10024            Self::RescueModifier(inner) => inner.span(),
10025        }
10026    }
10027}
10028#[derive(Debug, Clone, PartialEq, Eq)]
10029pub enum SingletonMethodObject<'tree> {
10030    Arg(::std::boxed::Box<Arg<'tree>>),
10031    Variable(::std::boxed::Box<Variable<'tree>>),
10032}
10033impl<'tree> ::treesitter_types::FromNode<'tree> for SingletonMethodObject<'tree> {
10034    #[allow(clippy::collapsible_else_if)]
10035    fn from_node(
10036        node: ::treesitter_types::tree_sitter::Node<'tree>,
10037        src: &'tree [u8],
10038    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10039        if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10040            <Arg as ::treesitter_types::FromNode>::from_node(node, src)
10041        }) {
10042            Ok(Self::Arg(::std::boxed::Box::new(v)))
10043        } else {
10044            if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10045                <Variable as ::treesitter_types::FromNode>::from_node(node, src)
10046            }) {
10047                Ok(Self::Variable(::std::boxed::Box::new(v)))
10048            } else {
10049                Err(::treesitter_types::ParseError::unexpected_kind(
10050                    node.kind(),
10051                    node,
10052                ))
10053            }
10054        }
10055    }
10056}
10057impl ::treesitter_types::Spanned for SingletonMethodObject<'_> {
10058    fn span(&self) -> ::treesitter_types::Span {
10059        match self {
10060            Self::Arg(inner) => inner.span(),
10061            Self::Variable(inner) => inner.span(),
10062        }
10063    }
10064}
10065#[derive(Debug, Clone, PartialEq, Eq)]
10066pub enum StringChildren<'tree> {
10067    EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
10068    Interpolation(::std::boxed::Box<Interpolation<'tree>>),
10069    StringContent(::std::boxed::Box<StringContent<'tree>>),
10070}
10071impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
10072    #[allow(clippy::collapsible_else_if)]
10073    fn from_node(
10074        node: ::treesitter_types::tree_sitter::Node<'tree>,
10075        src: &'tree [u8],
10076    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10077        match node.kind() {
10078            "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
10079                ::treesitter_types::runtime::maybe_grow_stack(|| {
10080                    <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
10081                })?,
10082            ))),
10083            "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
10084                ::treesitter_types::runtime::maybe_grow_stack(|| {
10085                    <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
10086                })?,
10087            ))),
10088            "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
10089                ::treesitter_types::runtime::maybe_grow_stack(|| {
10090                    <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
10091                })?,
10092            ))),
10093            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10094        }
10095    }
10096}
10097impl ::treesitter_types::Spanned for StringChildren<'_> {
10098    fn span(&self) -> ::treesitter_types::Span {
10099        match self {
10100            Self::EscapeSequence(inner) => inner.span(),
10101            Self::Interpolation(inner) => inner.span(),
10102            Self::StringContent(inner) => inner.span(),
10103        }
10104    }
10105}
10106#[derive(Debug, Clone, PartialEq, Eq)]
10107pub enum SubshellChildren<'tree> {
10108    EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
10109    Interpolation(::std::boxed::Box<Interpolation<'tree>>),
10110    StringContent(::std::boxed::Box<StringContent<'tree>>),
10111}
10112impl<'tree> ::treesitter_types::FromNode<'tree> for SubshellChildren<'tree> {
10113    #[allow(clippy::collapsible_else_if)]
10114    fn from_node(
10115        node: ::treesitter_types::tree_sitter::Node<'tree>,
10116        src: &'tree [u8],
10117    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10118        match node.kind() {
10119            "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
10120                ::treesitter_types::runtime::maybe_grow_stack(|| {
10121                    <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
10122                })?,
10123            ))),
10124            "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
10125                ::treesitter_types::runtime::maybe_grow_stack(|| {
10126                    <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
10127                })?,
10128            ))),
10129            "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
10130                ::treesitter_types::runtime::maybe_grow_stack(|| {
10131                    <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
10132                })?,
10133            ))),
10134            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10135        }
10136    }
10137}
10138impl ::treesitter_types::Spanned for SubshellChildren<'_> {
10139    fn span(&self) -> ::treesitter_types::Span {
10140        match self {
10141            Self::EscapeSequence(inner) => inner.span(),
10142            Self::Interpolation(inner) => inner.span(),
10143            Self::StringContent(inner) => inner.span(),
10144        }
10145    }
10146}
10147#[derive(Debug, Clone, PartialEq, Eq)]
10148pub enum ThenChildren<'tree> {
10149    Statement(::std::boxed::Box<Statement<'tree>>),
10150    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
10151}
10152impl<'tree> ::treesitter_types::FromNode<'tree> for ThenChildren<'tree> {
10153    #[allow(clippy::collapsible_else_if)]
10154    fn from_node(
10155        node: ::treesitter_types::tree_sitter::Node<'tree>,
10156        src: &'tree [u8],
10157    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10158        match node.kind() {
10159            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
10160                ::treesitter_types::runtime::maybe_grow_stack(|| {
10161                    <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
10162                })?,
10163            ))),
10164            _other => {
10165                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10166                    <Statement as ::treesitter_types::FromNode>::from_node(node, src)
10167                }) {
10168                    Ok(Self::Statement(::std::boxed::Box::new(v)))
10169                } else {
10170                    Err(::treesitter_types::ParseError::unexpected_kind(
10171                        _other, node,
10172                    ))
10173                }
10174            }
10175        }
10176    }
10177}
10178impl ::treesitter_types::Spanned for ThenChildren<'_> {
10179    fn span(&self) -> ::treesitter_types::Span {
10180        match self {
10181            Self::Statement(inner) => inner.span(),
10182            Self::EmptyStatement(inner) => inner.span(),
10183        }
10184    }
10185}
10186#[derive(Debug, Clone, PartialEq, Eq)]
10187pub enum UnaryOperand<'tree> {
10188    Expression(::std::boxed::Box<Expression<'tree>>),
10189    SimpleNumeric(::std::boxed::Box<SimpleNumeric<'tree>>),
10190    ParenthesizedStatements(::std::boxed::Box<ParenthesizedStatements<'tree>>),
10191}
10192impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOperand<'tree> {
10193    #[allow(clippy::collapsible_else_if)]
10194    fn from_node(
10195        node: ::treesitter_types::tree_sitter::Node<'tree>,
10196        src: &'tree [u8],
10197    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10198        match node.kind() {
10199            "parenthesized_statements" => Ok(Self::ParenthesizedStatements(
10200                ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10201                    <ParenthesizedStatements as ::treesitter_types::FromNode>::from_node(node, src)
10202                })?),
10203            )),
10204            _other => {
10205                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10206                    <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10207                }) {
10208                    Ok(Self::Expression(::std::boxed::Box::new(v)))
10209                } else {
10210                    if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10211                        <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src)
10212                    }) {
10213                        Ok(Self::SimpleNumeric(::std::boxed::Box::new(v)))
10214                    } else {
10215                        Err(::treesitter_types::ParseError::unexpected_kind(
10216                            _other, node,
10217                        ))
10218                    }
10219                }
10220            }
10221        }
10222    }
10223}
10224impl ::treesitter_types::Spanned for UnaryOperand<'_> {
10225    fn span(&self) -> ::treesitter_types::Span {
10226        match self {
10227            Self::Expression(inner) => inner.span(),
10228            Self::SimpleNumeric(inner) => inner.span(),
10229            Self::ParenthesizedStatements(inner) => inner.span(),
10230        }
10231    }
10232}
10233#[derive(Debug, Clone, PartialEq, Eq)]
10234pub enum UnaryOperator {
10235    Bang(::treesitter_types::Span),
10236    Plus(::treesitter_types::Span),
10237    Minus(::treesitter_types::Span),
10238    DEFINEDQuestion(::treesitter_types::Span),
10239    Not(::treesitter_types::Span),
10240    Tilde(::treesitter_types::Span),
10241}
10242impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOperator {
10243    #[allow(clippy::collapsible_else_if)]
10244    fn from_node(
10245        node: ::treesitter_types::tree_sitter::Node<'tree>,
10246        _src: &'tree [u8],
10247    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10248        match node.kind() {
10249            "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
10250            "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
10251            "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
10252            "defined?" => Ok(Self::DEFINEDQuestion(::treesitter_types::Span::from(node))),
10253            "not" => Ok(Self::Not(::treesitter_types::Span::from(node))),
10254            "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
10255            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10256        }
10257    }
10258}
10259impl ::treesitter_types::Spanned for UnaryOperator {
10260    fn span(&self) -> ::treesitter_types::Span {
10261        match self {
10262            Self::Bang(span) => *span,
10263            Self::Plus(span) => *span,
10264            Self::Minus(span) => *span,
10265            Self::DEFINEDQuestion(span) => *span,
10266            Self::Not(span) => *span,
10267            Self::Tilde(span) => *span,
10268        }
10269    }
10270}
10271#[derive(Debug, Clone, PartialEq, Eq)]
10272pub enum UnlessAlternative<'tree> {
10273    Else(::std::boxed::Box<Else<'tree>>),
10274    Elsif(::std::boxed::Box<Elsif<'tree>>),
10275}
10276impl<'tree> ::treesitter_types::FromNode<'tree> for UnlessAlternative<'tree> {
10277    #[allow(clippy::collapsible_else_if)]
10278    fn from_node(
10279        node: ::treesitter_types::tree_sitter::Node<'tree>,
10280        src: &'tree [u8],
10281    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10282        match node.kind() {
10283            "else" => Ok(Self::Else(::std::boxed::Box::new(
10284                ::treesitter_types::runtime::maybe_grow_stack(|| {
10285                    <Else as ::treesitter_types::FromNode>::from_node(node, src)
10286                })?,
10287            ))),
10288            "elsif" => Ok(Self::Elsif(::std::boxed::Box::new(
10289                ::treesitter_types::runtime::maybe_grow_stack(|| {
10290                    <Elsif as ::treesitter_types::FromNode>::from_node(node, src)
10291                })?,
10292            ))),
10293            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10294        }
10295    }
10296}
10297impl ::treesitter_types::Spanned for UnlessAlternative<'_> {
10298    fn span(&self) -> ::treesitter_types::Span {
10299        match self {
10300            Self::Else(inner) => inner.span(),
10301            Self::Elsif(inner) => inner.span(),
10302        }
10303    }
10304}
10305#[derive(Debug, Clone, PartialEq, Eq)]
10306pub enum VariableReferencePatternName<'tree> {
10307    NonlocalVariable(::std::boxed::Box<NonlocalVariable<'tree>>),
10308    Identifier(::std::boxed::Box<Identifier<'tree>>),
10309}
10310impl<'tree> ::treesitter_types::FromNode<'tree> for VariableReferencePatternName<'tree> {
10311    #[allow(clippy::collapsible_else_if)]
10312    fn from_node(
10313        node: ::treesitter_types::tree_sitter::Node<'tree>,
10314        src: &'tree [u8],
10315    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10316        match node.kind() {
10317            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10318                ::treesitter_types::runtime::maybe_grow_stack(|| {
10319                    <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10320                })?,
10321            ))),
10322            _other => {
10323                if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10324                    <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
10325                }) {
10326                    Ok(Self::NonlocalVariable(::std::boxed::Box::new(v)))
10327                } else {
10328                    Err(::treesitter_types::ParseError::unexpected_kind(
10329                        _other, node,
10330                    ))
10331                }
10332            }
10333        }
10334    }
10335}
10336impl ::treesitter_types::Spanned for VariableReferencePatternName<'_> {
10337    fn span(&self) -> ::treesitter_types::Span {
10338        match self {
10339            Self::NonlocalVariable(inner) => inner.span(),
10340            Self::Identifier(inner) => inner.span(),
10341        }
10342    }
10343}
10344#[derive(Debug, Clone, PartialEq, Eq)]
10345pub enum AnyNode<'tree> {
10346    Arg(Arg<'tree>),
10347    CallOperator(CallOperator),
10348    Expression(Expression<'tree>),
10349    Lhs(Lhs<'tree>),
10350    MethodName(MethodName<'tree>),
10351    NonlocalVariable(NonlocalVariable<'tree>),
10352    PatternConstant(PatternConstant<'tree>),
10353    PatternExpr(PatternExpr<'tree>),
10354    PatternExprBasic(PatternExprBasic<'tree>),
10355    PatternPrimitive(PatternPrimitive<'tree>),
10356    PatternTopExprBody(PatternTopExprBody<'tree>),
10357    Primary(Primary<'tree>),
10358    SimpleNumeric(SimpleNumeric<'tree>),
10359    Statement(Statement<'tree>),
10360    Variable(Variable<'tree>),
10361    Alias(Alias<'tree>),
10362    AlternativePattern(AlternativePattern<'tree>),
10363    ArgumentList(ArgumentList<'tree>),
10364    Array(Array<'tree>),
10365    ArrayPattern(ArrayPattern<'tree>),
10366    AsPattern(AsPattern<'tree>),
10367    Assignment(Assignment<'tree>),
10368    BareString(BareString<'tree>),
10369    BareSymbol(BareSymbol<'tree>),
10370    Begin(Begin<'tree>),
10371    BeginBlock(BeginBlock<'tree>),
10372    Binary(Binary<'tree>),
10373    Block(Block<'tree>),
10374    BlockArgument(BlockArgument<'tree>),
10375    BlockBody(BlockBody<'tree>),
10376    BlockParameter(BlockParameter<'tree>),
10377    BlockParameters(BlockParameters<'tree>),
10378    BodyStatement(BodyStatement<'tree>),
10379    Break(Break<'tree>),
10380    Call(Call<'tree>),
10381    Case(Case<'tree>),
10382    CaseMatch(CaseMatch<'tree>),
10383    ChainedString(ChainedString<'tree>),
10384    Class(Class<'tree>),
10385    Complex(Complex<'tree>),
10386    Conditional(Conditional<'tree>),
10387    Constant(Constant<'tree>),
10388    DelimitedSymbol(DelimitedSymbol<'tree>),
10389    DestructuredLeftAssignment(DestructuredLeftAssignment<'tree>),
10390    DestructuredParameter(DestructuredParameter<'tree>),
10391    Do(Do<'tree>),
10392    DoBlock(DoBlock<'tree>),
10393    ElementReference(ElementReference<'tree>),
10394    Else(Else<'tree>),
10395    Elsif(Elsif<'tree>),
10396    EmptyStatement(EmptyStatement<'tree>),
10397    EndBlock(EndBlock<'tree>),
10398    Ensure(Ensure<'tree>),
10399    ExceptionVariable(ExceptionVariable<'tree>),
10400    Exceptions(Exceptions<'tree>),
10401    ExpressionReferencePattern(ExpressionReferencePattern<'tree>),
10402    FindPattern(FindPattern<'tree>),
10403    For(For<'tree>),
10404    ForwardArgument(ForwardArgument<'tree>),
10405    ForwardParameter(ForwardParameter<'tree>),
10406    Hash(Hash<'tree>),
10407    HashKeySymbol(HashKeySymbol<'tree>),
10408    HashPattern(HashPattern<'tree>),
10409    HashSplatArgument(HashSplatArgument<'tree>),
10410    HashSplatNil(HashSplatNil<'tree>),
10411    HashSplatParameter(HashSplatParameter<'tree>),
10412    HeredocBody(HeredocBody<'tree>),
10413    Identifier(Identifier<'tree>),
10414    If(If<'tree>),
10415    IfGuard(IfGuard<'tree>),
10416    IfModifier(IfModifier<'tree>),
10417    In(In<'tree>),
10418    InClause(InClause<'tree>),
10419    Interpolation(Interpolation<'tree>),
10420    KeywordParameter(KeywordParameter<'tree>),
10421    KeywordPattern(KeywordPattern<'tree>),
10422    Lambda(Lambda<'tree>),
10423    LambdaParameters(LambdaParameters<'tree>),
10424    LeftAssignmentList(LeftAssignmentList<'tree>),
10425    MatchPattern(MatchPattern<'tree>),
10426    Method(Method<'tree>),
10427    MethodParameters(MethodParameters<'tree>),
10428    Module(Module<'tree>),
10429    Next(Next<'tree>),
10430    Nil(Nil<'tree>),
10431    Operator(Operator<'tree>),
10432    OperatorAssignment(OperatorAssignment<'tree>),
10433    OptionalParameter(OptionalParameter<'tree>),
10434    Pair(Pair<'tree>),
10435    ParenthesizedPattern(ParenthesizedPattern<'tree>),
10436    ParenthesizedStatements(ParenthesizedStatements<'tree>),
10437    Pattern(Pattern<'tree>),
10438    Program(Program<'tree>),
10439    Range(Range<'tree>),
10440    Rational(Rational<'tree>),
10441    Redo(Redo<'tree>),
10442    Regex(Regex<'tree>),
10443    Rescue(Rescue<'tree>),
10444    RescueModifier(RescueModifier<'tree>),
10445    RestAssignment(RestAssignment<'tree>),
10446    Retry(Retry<'tree>),
10447    Return(Return<'tree>),
10448    RightAssignmentList(RightAssignmentList<'tree>),
10449    ScopeResolution(ScopeResolution<'tree>),
10450    Setter(Setter<'tree>),
10451    SingletonClass(SingletonClass<'tree>),
10452    SingletonMethod(SingletonMethod<'tree>),
10453    SplatArgument(SplatArgument<'tree>),
10454    SplatParameter(SplatParameter<'tree>),
10455    String(String<'tree>),
10456    StringArray(StringArray<'tree>),
10457    Subshell(Subshell<'tree>),
10458    Superclass(Superclass<'tree>),
10459    SymbolArray(SymbolArray<'tree>),
10460    TestPattern(TestPattern<'tree>),
10461    Then(Then<'tree>),
10462    Unary(Unary<'tree>),
10463    Undef(Undef<'tree>),
10464    Unless(Unless<'tree>),
10465    UnlessGuard(UnlessGuard<'tree>),
10466    UnlessModifier(UnlessModifier<'tree>),
10467    Until(Until<'tree>),
10468    UntilModifier(UntilModifier<'tree>),
10469    VariableReferencePattern(VariableReferencePattern<'tree>),
10470    When(When<'tree>),
10471    While(While<'tree>),
10472    WhileModifier(WhileModifier<'tree>),
10473    Yield(Yield<'tree>),
10474    Character(Character<'tree>),
10475    ClassVariable(ClassVariable<'tree>),
10476    Comment(Comment<'tree>),
10477    Encoding(Encoding<'tree>),
10478    EscapeSequence(EscapeSequence<'tree>),
10479    False(False<'tree>),
10480    File(File<'tree>),
10481    Float(Float<'tree>),
10482    GlobalVariable(GlobalVariable<'tree>),
10483    HeredocBeginning(HeredocBeginning<'tree>),
10484    HeredocContent(HeredocContent<'tree>),
10485    HeredocEnd(HeredocEnd<'tree>),
10486    InstanceVariable(InstanceVariable<'tree>),
10487    Integer(Integer<'tree>),
10488    Line(Line<'tree>),
10489    SelfType(SelfType<'tree>),
10490    SimpleSymbol(SimpleSymbol<'tree>),
10491    StringContent(StringContent<'tree>),
10492    Super(Super<'tree>),
10493    True(True<'tree>),
10494    Uninterpreted(Uninterpreted<'tree>),
10495    Unknown(::treesitter_types::tree_sitter::Node<'tree>),
10496}
10497impl<'tree> AnyNode<'tree> {
10498    pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
10499        match node.kind() {
10500            "_arg" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10501                <Arg as ::treesitter_types::FromNode>::from_node(node, src)
10502            })
10503            .map(Self::Arg)
10504            .unwrap_or(Self::Unknown(node)),
10505            "_call_operator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10506                <CallOperator as ::treesitter_types::FromNode>::from_node(node, src)
10507            })
10508            .map(Self::CallOperator)
10509            .unwrap_or(Self::Unknown(node)),
10510            "_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10511                <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10512            })
10513            .map(Self::Expression)
10514            .unwrap_or(Self::Unknown(node)),
10515            "_lhs" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10516                <Lhs as ::treesitter_types::FromNode>::from_node(node, src)
10517            })
10518            .map(Self::Lhs)
10519            .unwrap_or(Self::Unknown(node)),
10520            "_method_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10521                <MethodName as ::treesitter_types::FromNode>::from_node(node, src)
10522            })
10523            .map(Self::MethodName)
10524            .unwrap_or(Self::Unknown(node)),
10525            "_nonlocal_variable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10526                <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
10527            })
10528            .map(Self::NonlocalVariable)
10529            .unwrap_or(Self::Unknown(node)),
10530            "_pattern_constant" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10531                <PatternConstant as ::treesitter_types::FromNode>::from_node(node, src)
10532            })
10533            .map(Self::PatternConstant)
10534            .unwrap_or(Self::Unknown(node)),
10535            "_pattern_expr" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10536                <PatternExpr as ::treesitter_types::FromNode>::from_node(node, src)
10537            })
10538            .map(Self::PatternExpr)
10539            .unwrap_or(Self::Unknown(node)),
10540            "_pattern_expr_basic" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10541                <PatternExprBasic as ::treesitter_types::FromNode>::from_node(node, src)
10542            })
10543            .map(Self::PatternExprBasic)
10544            .unwrap_or(Self::Unknown(node)),
10545            "_pattern_primitive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10546                <PatternPrimitive as ::treesitter_types::FromNode>::from_node(node, src)
10547            })
10548            .map(Self::PatternPrimitive)
10549            .unwrap_or(Self::Unknown(node)),
10550            "_pattern_top_expr_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10551                <PatternTopExprBody as ::treesitter_types::FromNode>::from_node(node, src)
10552            })
10553            .map(Self::PatternTopExprBody)
10554            .unwrap_or(Self::Unknown(node)),
10555            "_primary" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10556                <Primary as ::treesitter_types::FromNode>::from_node(node, src)
10557            })
10558            .map(Self::Primary)
10559            .unwrap_or(Self::Unknown(node)),
10560            "_simple_numeric" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10561                <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src)
10562            })
10563            .map(Self::SimpleNumeric)
10564            .unwrap_or(Self::Unknown(node)),
10565            "_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10566                <Statement as ::treesitter_types::FromNode>::from_node(node, src)
10567            })
10568            .map(Self::Statement)
10569            .unwrap_or(Self::Unknown(node)),
10570            "_variable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10571                <Variable as ::treesitter_types::FromNode>::from_node(node, src)
10572            })
10573            .map(Self::Variable)
10574            .unwrap_or(Self::Unknown(node)),
10575            "alias" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10576                <Alias as ::treesitter_types::FromNode>::from_node(node, src)
10577            })
10578            .map(Self::Alias)
10579            .unwrap_or(Self::Unknown(node)),
10580            "alternative_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10581                <AlternativePattern as ::treesitter_types::FromNode>::from_node(node, src)
10582            })
10583            .map(Self::AlternativePattern)
10584            .unwrap_or(Self::Unknown(node)),
10585            "argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10586                <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
10587            })
10588            .map(Self::ArgumentList)
10589            .unwrap_or(Self::Unknown(node)),
10590            "array" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10591                <Array as ::treesitter_types::FromNode>::from_node(node, src)
10592            })
10593            .map(Self::Array)
10594            .unwrap_or(Self::Unknown(node)),
10595            "array_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10596                <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
10597            })
10598            .map(Self::ArrayPattern)
10599            .unwrap_or(Self::Unknown(node)),
10600            "as_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10601                <AsPattern as ::treesitter_types::FromNode>::from_node(node, src)
10602            })
10603            .map(Self::AsPattern)
10604            .unwrap_or(Self::Unknown(node)),
10605            "assignment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10606                <Assignment as ::treesitter_types::FromNode>::from_node(node, src)
10607            })
10608            .map(Self::Assignment)
10609            .unwrap_or(Self::Unknown(node)),
10610            "bare_string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10611                <BareString as ::treesitter_types::FromNode>::from_node(node, src)
10612            })
10613            .map(Self::BareString)
10614            .unwrap_or(Self::Unknown(node)),
10615            "bare_symbol" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10616                <BareSymbol as ::treesitter_types::FromNode>::from_node(node, src)
10617            })
10618            .map(Self::BareSymbol)
10619            .unwrap_or(Self::Unknown(node)),
10620            "begin" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10621                <Begin as ::treesitter_types::FromNode>::from_node(node, src)
10622            })
10623            .map(Self::Begin)
10624            .unwrap_or(Self::Unknown(node)),
10625            "begin_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10626                <BeginBlock as ::treesitter_types::FromNode>::from_node(node, src)
10627            })
10628            .map(Self::BeginBlock)
10629            .unwrap_or(Self::Unknown(node)),
10630            "binary" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10631                <Binary as ::treesitter_types::FromNode>::from_node(node, src)
10632            })
10633            .map(Self::Binary)
10634            .unwrap_or(Self::Unknown(node)),
10635            "block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10636                <Block as ::treesitter_types::FromNode>::from_node(node, src)
10637            })
10638            .map(Self::Block)
10639            .unwrap_or(Self::Unknown(node)),
10640            "block_argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10641                <BlockArgument as ::treesitter_types::FromNode>::from_node(node, src)
10642            })
10643            .map(Self::BlockArgument)
10644            .unwrap_or(Self::Unknown(node)),
10645            "block_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10646                <BlockBody as ::treesitter_types::FromNode>::from_node(node, src)
10647            })
10648            .map(Self::BlockBody)
10649            .unwrap_or(Self::Unknown(node)),
10650            "block_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10651                <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)
10652            })
10653            .map(Self::BlockParameter)
10654            .unwrap_or(Self::Unknown(node)),
10655            "block_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10656                <BlockParameters as ::treesitter_types::FromNode>::from_node(node, src)
10657            })
10658            .map(Self::BlockParameters)
10659            .unwrap_or(Self::Unknown(node)),
10660            "body_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10661                <BodyStatement as ::treesitter_types::FromNode>::from_node(node, src)
10662            })
10663            .map(Self::BodyStatement)
10664            .unwrap_or(Self::Unknown(node)),
10665            "break" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10666                <Break as ::treesitter_types::FromNode>::from_node(node, src)
10667            })
10668            .map(Self::Break)
10669            .unwrap_or(Self::Unknown(node)),
10670            "call" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10671                <Call as ::treesitter_types::FromNode>::from_node(node, src)
10672            })
10673            .map(Self::Call)
10674            .unwrap_or(Self::Unknown(node)),
10675            "case" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10676                <Case as ::treesitter_types::FromNode>::from_node(node, src)
10677            })
10678            .map(Self::Case)
10679            .unwrap_or(Self::Unknown(node)),
10680            "case_match" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10681                <CaseMatch as ::treesitter_types::FromNode>::from_node(node, src)
10682            })
10683            .map(Self::CaseMatch)
10684            .unwrap_or(Self::Unknown(node)),
10685            "chained_string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10686                <ChainedString as ::treesitter_types::FromNode>::from_node(node, src)
10687            })
10688            .map(Self::ChainedString)
10689            .unwrap_or(Self::Unknown(node)),
10690            "class" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10691                <Class as ::treesitter_types::FromNode>::from_node(node, src)
10692            })
10693            .map(Self::Class)
10694            .unwrap_or(Self::Unknown(node)),
10695            "complex" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10696                <Complex as ::treesitter_types::FromNode>::from_node(node, src)
10697            })
10698            .map(Self::Complex)
10699            .unwrap_or(Self::Unknown(node)),
10700            "conditional" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10701                <Conditional as ::treesitter_types::FromNode>::from_node(node, src)
10702            })
10703            .map(Self::Conditional)
10704            .unwrap_or(Self::Unknown(node)),
10705            "constant" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10706                <Constant as ::treesitter_types::FromNode>::from_node(node, src)
10707            })
10708            .map(Self::Constant)
10709            .unwrap_or(Self::Unknown(node)),
10710            "delimited_symbol" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10711                <DelimitedSymbol as ::treesitter_types::FromNode>::from_node(node, src)
10712            })
10713            .map(Self::DelimitedSymbol)
10714            .unwrap_or(Self::Unknown(node)),
10715            "destructured_left_assignment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10716                <DestructuredLeftAssignment as ::treesitter_types::FromNode>::from_node(node, src)
10717            })
10718            .map(Self::DestructuredLeftAssignment)
10719            .unwrap_or(Self::Unknown(node)),
10720            "destructured_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10721                <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)
10722            })
10723            .map(Self::DestructuredParameter)
10724            .unwrap_or(Self::Unknown(node)),
10725            "do" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10726                <Do as ::treesitter_types::FromNode>::from_node(node, src)
10727            })
10728            .map(Self::Do)
10729            .unwrap_or(Self::Unknown(node)),
10730            "do_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10731                <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)
10732            })
10733            .map(Self::DoBlock)
10734            .unwrap_or(Self::Unknown(node)),
10735            "element_reference" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10736                <ElementReference as ::treesitter_types::FromNode>::from_node(node, src)
10737            })
10738            .map(Self::ElementReference)
10739            .unwrap_or(Self::Unknown(node)),
10740            "else" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10741                <Else as ::treesitter_types::FromNode>::from_node(node, src)
10742            })
10743            .map(Self::Else)
10744            .unwrap_or(Self::Unknown(node)),
10745            "elsif" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10746                <Elsif as ::treesitter_types::FromNode>::from_node(node, src)
10747            })
10748            .map(Self::Elsif)
10749            .unwrap_or(Self::Unknown(node)),
10750            "empty_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10751                <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
10752            })
10753            .map(Self::EmptyStatement)
10754            .unwrap_or(Self::Unknown(node)),
10755            "end_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10756                <EndBlock as ::treesitter_types::FromNode>::from_node(node, src)
10757            })
10758            .map(Self::EndBlock)
10759            .unwrap_or(Self::Unknown(node)),
10760            "ensure" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10761                <Ensure as ::treesitter_types::FromNode>::from_node(node, src)
10762            })
10763            .map(Self::Ensure)
10764            .unwrap_or(Self::Unknown(node)),
10765            "exception_variable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10766                <ExceptionVariable as ::treesitter_types::FromNode>::from_node(node, src)
10767            })
10768            .map(Self::ExceptionVariable)
10769            .unwrap_or(Self::Unknown(node)),
10770            "exceptions" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10771                <Exceptions as ::treesitter_types::FromNode>::from_node(node, src)
10772            })
10773            .map(Self::Exceptions)
10774            .unwrap_or(Self::Unknown(node)),
10775            "expression_reference_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10776                <ExpressionReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)
10777            })
10778            .map(Self::ExpressionReferencePattern)
10779            .unwrap_or(Self::Unknown(node)),
10780            "find_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10781                <FindPattern as ::treesitter_types::FromNode>::from_node(node, src)
10782            })
10783            .map(Self::FindPattern)
10784            .unwrap_or(Self::Unknown(node)),
10785            "for" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10786                <For as ::treesitter_types::FromNode>::from_node(node, src)
10787            })
10788            .map(Self::For)
10789            .unwrap_or(Self::Unknown(node)),
10790            "forward_argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10791                <ForwardArgument as ::treesitter_types::FromNode>::from_node(node, src)
10792            })
10793            .map(Self::ForwardArgument)
10794            .unwrap_or(Self::Unknown(node)),
10795            "forward_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10796                <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)
10797            })
10798            .map(Self::ForwardParameter)
10799            .unwrap_or(Self::Unknown(node)),
10800            "hash" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10801                <Hash as ::treesitter_types::FromNode>::from_node(node, src)
10802            })
10803            .map(Self::Hash)
10804            .unwrap_or(Self::Unknown(node)),
10805            "hash_key_symbol" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10806                <HashKeySymbol as ::treesitter_types::FromNode>::from_node(node, src)
10807            })
10808            .map(Self::HashKeySymbol)
10809            .unwrap_or(Self::Unknown(node)),
10810            "hash_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10811                <HashPattern as ::treesitter_types::FromNode>::from_node(node, src)
10812            })
10813            .map(Self::HashPattern)
10814            .unwrap_or(Self::Unknown(node)),
10815            "hash_splat_argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10816                <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
10817            })
10818            .map(Self::HashSplatArgument)
10819            .unwrap_or(Self::Unknown(node)),
10820            "hash_splat_nil" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10821                <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)
10822            })
10823            .map(Self::HashSplatNil)
10824            .unwrap_or(Self::Unknown(node)),
10825            "hash_splat_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10826                <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
10827            })
10828            .map(Self::HashSplatParameter)
10829            .unwrap_or(Self::Unknown(node)),
10830            "heredoc_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10831                <HeredocBody as ::treesitter_types::FromNode>::from_node(node, src)
10832            })
10833            .map(Self::HeredocBody)
10834            .unwrap_or(Self::Unknown(node)),
10835            "identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10836                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10837            })
10838            .map(Self::Identifier)
10839            .unwrap_or(Self::Unknown(node)),
10840            "if" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10841                <If as ::treesitter_types::FromNode>::from_node(node, src)
10842            })
10843            .map(Self::If)
10844            .unwrap_or(Self::Unknown(node)),
10845            "if_guard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10846                <IfGuard as ::treesitter_types::FromNode>::from_node(node, src)
10847            })
10848            .map(Self::IfGuard)
10849            .unwrap_or(Self::Unknown(node)),
10850            "if_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10851                <IfModifier as ::treesitter_types::FromNode>::from_node(node, src)
10852            })
10853            .map(Self::IfModifier)
10854            .unwrap_or(Self::Unknown(node)),
10855            "in" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10856                <In as ::treesitter_types::FromNode>::from_node(node, src)
10857            })
10858            .map(Self::In)
10859            .unwrap_or(Self::Unknown(node)),
10860            "in_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10861                <InClause as ::treesitter_types::FromNode>::from_node(node, src)
10862            })
10863            .map(Self::InClause)
10864            .unwrap_or(Self::Unknown(node)),
10865            "interpolation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10866                <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
10867            })
10868            .map(Self::Interpolation)
10869            .unwrap_or(Self::Unknown(node)),
10870            "keyword_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10871                <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)
10872            })
10873            .map(Self::KeywordParameter)
10874            .unwrap_or(Self::Unknown(node)),
10875            "keyword_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10876                <KeywordPattern as ::treesitter_types::FromNode>::from_node(node, src)
10877            })
10878            .map(Self::KeywordPattern)
10879            .unwrap_or(Self::Unknown(node)),
10880            "lambda" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10881                <Lambda as ::treesitter_types::FromNode>::from_node(node, src)
10882            })
10883            .map(Self::Lambda)
10884            .unwrap_or(Self::Unknown(node)),
10885            "lambda_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10886                <LambdaParameters as ::treesitter_types::FromNode>::from_node(node, src)
10887            })
10888            .map(Self::LambdaParameters)
10889            .unwrap_or(Self::Unknown(node)),
10890            "left_assignment_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10891                <LeftAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)
10892            })
10893            .map(Self::LeftAssignmentList)
10894            .unwrap_or(Self::Unknown(node)),
10895            "match_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10896                <MatchPattern as ::treesitter_types::FromNode>::from_node(node, src)
10897            })
10898            .map(Self::MatchPattern)
10899            .unwrap_or(Self::Unknown(node)),
10900            "method" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10901                <Method as ::treesitter_types::FromNode>::from_node(node, src)
10902            })
10903            .map(Self::Method)
10904            .unwrap_or(Self::Unknown(node)),
10905            "method_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10906                <MethodParameters as ::treesitter_types::FromNode>::from_node(node, src)
10907            })
10908            .map(Self::MethodParameters)
10909            .unwrap_or(Self::Unknown(node)),
10910            "module" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10911                <Module as ::treesitter_types::FromNode>::from_node(node, src)
10912            })
10913            .map(Self::Module)
10914            .unwrap_or(Self::Unknown(node)),
10915            "next" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10916                <Next as ::treesitter_types::FromNode>::from_node(node, src)
10917            })
10918            .map(Self::Next)
10919            .unwrap_or(Self::Unknown(node)),
10920            "nil" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10921                <Nil as ::treesitter_types::FromNode>::from_node(node, src)
10922            })
10923            .map(Self::Nil)
10924            .unwrap_or(Self::Unknown(node)),
10925            "operator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10926                <Operator as ::treesitter_types::FromNode>::from_node(node, src)
10927            })
10928            .map(Self::Operator)
10929            .unwrap_or(Self::Unknown(node)),
10930            "operator_assignment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10931                <OperatorAssignment as ::treesitter_types::FromNode>::from_node(node, src)
10932            })
10933            .map(Self::OperatorAssignment)
10934            .unwrap_or(Self::Unknown(node)),
10935            "optional_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10936                <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)
10937            })
10938            .map(Self::OptionalParameter)
10939            .unwrap_or(Self::Unknown(node)),
10940            "pair" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10941                <Pair as ::treesitter_types::FromNode>::from_node(node, src)
10942            })
10943            .map(Self::Pair)
10944            .unwrap_or(Self::Unknown(node)),
10945            "parenthesized_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10946                <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)
10947            })
10948            .map(Self::ParenthesizedPattern)
10949            .unwrap_or(Self::Unknown(node)),
10950            "parenthesized_statements" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10951                <ParenthesizedStatements as ::treesitter_types::FromNode>::from_node(node, src)
10952            })
10953            .map(Self::ParenthesizedStatements)
10954            .unwrap_or(Self::Unknown(node)),
10955            "pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10956                <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
10957            })
10958            .map(Self::Pattern)
10959            .unwrap_or(Self::Unknown(node)),
10960            "program" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10961                <Program as ::treesitter_types::FromNode>::from_node(node, src)
10962            })
10963            .map(Self::Program)
10964            .unwrap_or(Self::Unknown(node)),
10965            "range" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10966                <Range as ::treesitter_types::FromNode>::from_node(node, src)
10967            })
10968            .map(Self::Range)
10969            .unwrap_or(Self::Unknown(node)),
10970            "rational" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10971                <Rational as ::treesitter_types::FromNode>::from_node(node, src)
10972            })
10973            .map(Self::Rational)
10974            .unwrap_or(Self::Unknown(node)),
10975            "redo" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10976                <Redo as ::treesitter_types::FromNode>::from_node(node, src)
10977            })
10978            .map(Self::Redo)
10979            .unwrap_or(Self::Unknown(node)),
10980            "regex" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10981                <Regex as ::treesitter_types::FromNode>::from_node(node, src)
10982            })
10983            .map(Self::Regex)
10984            .unwrap_or(Self::Unknown(node)),
10985            "rescue" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10986                <Rescue as ::treesitter_types::FromNode>::from_node(node, src)
10987            })
10988            .map(Self::Rescue)
10989            .unwrap_or(Self::Unknown(node)),
10990            "rescue_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10991                <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)
10992            })
10993            .map(Self::RescueModifier)
10994            .unwrap_or(Self::Unknown(node)),
10995            "rest_assignment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
10996                <RestAssignment as ::treesitter_types::FromNode>::from_node(node, src)
10997            })
10998            .map(Self::RestAssignment)
10999            .unwrap_or(Self::Unknown(node)),
11000            "retry" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11001                <Retry as ::treesitter_types::FromNode>::from_node(node, src)
11002            })
11003            .map(Self::Retry)
11004            .unwrap_or(Self::Unknown(node)),
11005            "return" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11006                <Return as ::treesitter_types::FromNode>::from_node(node, src)
11007            })
11008            .map(Self::Return)
11009            .unwrap_or(Self::Unknown(node)),
11010            "right_assignment_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11011                <RightAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)
11012            })
11013            .map(Self::RightAssignmentList)
11014            .unwrap_or(Self::Unknown(node)),
11015            "scope_resolution" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11016                <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)
11017            })
11018            .map(Self::ScopeResolution)
11019            .unwrap_or(Self::Unknown(node)),
11020            "setter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11021                <Setter as ::treesitter_types::FromNode>::from_node(node, src)
11022            })
11023            .map(Self::Setter)
11024            .unwrap_or(Self::Unknown(node)),
11025            "singleton_class" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11026                <SingletonClass as ::treesitter_types::FromNode>::from_node(node, src)
11027            })
11028            .map(Self::SingletonClass)
11029            .unwrap_or(Self::Unknown(node)),
11030            "singleton_method" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11031                <SingletonMethod as ::treesitter_types::FromNode>::from_node(node, src)
11032            })
11033            .map(Self::SingletonMethod)
11034            .unwrap_or(Self::Unknown(node)),
11035            "splat_argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11036                <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
11037            })
11038            .map(Self::SplatArgument)
11039            .unwrap_or(Self::Unknown(node)),
11040            "splat_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11041                <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
11042            })
11043            .map(Self::SplatParameter)
11044            .unwrap_or(Self::Unknown(node)),
11045            "string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11046                <String as ::treesitter_types::FromNode>::from_node(node, src)
11047            })
11048            .map(Self::String)
11049            .unwrap_or(Self::Unknown(node)),
11050            "string_array" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11051                <StringArray as ::treesitter_types::FromNode>::from_node(node, src)
11052            })
11053            .map(Self::StringArray)
11054            .unwrap_or(Self::Unknown(node)),
11055            "subshell" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11056                <Subshell as ::treesitter_types::FromNode>::from_node(node, src)
11057            })
11058            .map(Self::Subshell)
11059            .unwrap_or(Self::Unknown(node)),
11060            "superclass" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11061                <Superclass as ::treesitter_types::FromNode>::from_node(node, src)
11062            })
11063            .map(Self::Superclass)
11064            .unwrap_or(Self::Unknown(node)),
11065            "symbol_array" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11066                <SymbolArray as ::treesitter_types::FromNode>::from_node(node, src)
11067            })
11068            .map(Self::SymbolArray)
11069            .unwrap_or(Self::Unknown(node)),
11070            "test_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11071                <TestPattern as ::treesitter_types::FromNode>::from_node(node, src)
11072            })
11073            .map(Self::TestPattern)
11074            .unwrap_or(Self::Unknown(node)),
11075            "then" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11076                <Then as ::treesitter_types::FromNode>::from_node(node, src)
11077            })
11078            .map(Self::Then)
11079            .unwrap_or(Self::Unknown(node)),
11080            "unary" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11081                <Unary as ::treesitter_types::FromNode>::from_node(node, src)
11082            })
11083            .map(Self::Unary)
11084            .unwrap_or(Self::Unknown(node)),
11085            "undef" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11086                <Undef as ::treesitter_types::FromNode>::from_node(node, src)
11087            })
11088            .map(Self::Undef)
11089            .unwrap_or(Self::Unknown(node)),
11090            "unless" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11091                <Unless as ::treesitter_types::FromNode>::from_node(node, src)
11092            })
11093            .map(Self::Unless)
11094            .unwrap_or(Self::Unknown(node)),
11095            "unless_guard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11096                <UnlessGuard as ::treesitter_types::FromNode>::from_node(node, src)
11097            })
11098            .map(Self::UnlessGuard)
11099            .unwrap_or(Self::Unknown(node)),
11100            "unless_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11101                <UnlessModifier as ::treesitter_types::FromNode>::from_node(node, src)
11102            })
11103            .map(Self::UnlessModifier)
11104            .unwrap_or(Self::Unknown(node)),
11105            "until" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11106                <Until as ::treesitter_types::FromNode>::from_node(node, src)
11107            })
11108            .map(Self::Until)
11109            .unwrap_or(Self::Unknown(node)),
11110            "until_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11111                <UntilModifier as ::treesitter_types::FromNode>::from_node(node, src)
11112            })
11113            .map(Self::UntilModifier)
11114            .unwrap_or(Self::Unknown(node)),
11115            "variable_reference_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11116                <VariableReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)
11117            })
11118            .map(Self::VariableReferencePattern)
11119            .unwrap_or(Self::Unknown(node)),
11120            "when" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11121                <When as ::treesitter_types::FromNode>::from_node(node, src)
11122            })
11123            .map(Self::When)
11124            .unwrap_or(Self::Unknown(node)),
11125            "while" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11126                <While as ::treesitter_types::FromNode>::from_node(node, src)
11127            })
11128            .map(Self::While)
11129            .unwrap_or(Self::Unknown(node)),
11130            "while_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11131                <WhileModifier as ::treesitter_types::FromNode>::from_node(node, src)
11132            })
11133            .map(Self::WhileModifier)
11134            .unwrap_or(Self::Unknown(node)),
11135            "yield" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11136                <Yield as ::treesitter_types::FromNode>::from_node(node, src)
11137            })
11138            .map(Self::Yield)
11139            .unwrap_or(Self::Unknown(node)),
11140            "character" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11141                <Character as ::treesitter_types::FromNode>::from_node(node, src)
11142            })
11143            .map(Self::Character)
11144            .unwrap_or(Self::Unknown(node)),
11145            "class_variable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11146                <ClassVariable as ::treesitter_types::FromNode>::from_node(node, src)
11147            })
11148            .map(Self::ClassVariable)
11149            .unwrap_or(Self::Unknown(node)),
11150            "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11151                <Comment as ::treesitter_types::FromNode>::from_node(node, src)
11152            })
11153            .map(Self::Comment)
11154            .unwrap_or(Self::Unknown(node)),
11155            "encoding" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11156                <Encoding as ::treesitter_types::FromNode>::from_node(node, src)
11157            })
11158            .map(Self::Encoding)
11159            .unwrap_or(Self::Unknown(node)),
11160            "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11161                <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
11162            })
11163            .map(Self::EscapeSequence)
11164            .unwrap_or(Self::Unknown(node)),
11165            "false" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11166                <False as ::treesitter_types::FromNode>::from_node(node, src)
11167            })
11168            .map(Self::False)
11169            .unwrap_or(Self::Unknown(node)),
11170            "file" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11171                <File as ::treesitter_types::FromNode>::from_node(node, src)
11172            })
11173            .map(Self::File)
11174            .unwrap_or(Self::Unknown(node)),
11175            "float" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11176                <Float as ::treesitter_types::FromNode>::from_node(node, src)
11177            })
11178            .map(Self::Float)
11179            .unwrap_or(Self::Unknown(node)),
11180            "global_variable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11181                <GlobalVariable as ::treesitter_types::FromNode>::from_node(node, src)
11182            })
11183            .map(Self::GlobalVariable)
11184            .unwrap_or(Self::Unknown(node)),
11185            "heredoc_beginning" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11186                <HeredocBeginning as ::treesitter_types::FromNode>::from_node(node, src)
11187            })
11188            .map(Self::HeredocBeginning)
11189            .unwrap_or(Self::Unknown(node)),
11190            "heredoc_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11191                <HeredocContent as ::treesitter_types::FromNode>::from_node(node, src)
11192            })
11193            .map(Self::HeredocContent)
11194            .unwrap_or(Self::Unknown(node)),
11195            "heredoc_end" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11196                <HeredocEnd as ::treesitter_types::FromNode>::from_node(node, src)
11197            })
11198            .map(Self::HeredocEnd)
11199            .unwrap_or(Self::Unknown(node)),
11200            "instance_variable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11201                <InstanceVariable as ::treesitter_types::FromNode>::from_node(node, src)
11202            })
11203            .map(Self::InstanceVariable)
11204            .unwrap_or(Self::Unknown(node)),
11205            "integer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11206                <Integer as ::treesitter_types::FromNode>::from_node(node, src)
11207            })
11208            .map(Self::Integer)
11209            .unwrap_or(Self::Unknown(node)),
11210            "line" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11211                <Line as ::treesitter_types::FromNode>::from_node(node, src)
11212            })
11213            .map(Self::Line)
11214            .unwrap_or(Self::Unknown(node)),
11215            "self" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11216                <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
11217            })
11218            .map(Self::SelfType)
11219            .unwrap_or(Self::Unknown(node)),
11220            "simple_symbol" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11221                <SimpleSymbol as ::treesitter_types::FromNode>::from_node(node, src)
11222            })
11223            .map(Self::SimpleSymbol)
11224            .unwrap_or(Self::Unknown(node)),
11225            "string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11226                <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
11227            })
11228            .map(Self::StringContent)
11229            .unwrap_or(Self::Unknown(node)),
11230            "super" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11231                <Super as ::treesitter_types::FromNode>::from_node(node, src)
11232            })
11233            .map(Self::Super)
11234            .unwrap_or(Self::Unknown(node)),
11235            "true" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11236                <True as ::treesitter_types::FromNode>::from_node(node, src)
11237            })
11238            .map(Self::True)
11239            .unwrap_or(Self::Unknown(node)),
11240            "uninterpreted" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11241                <Uninterpreted as ::treesitter_types::FromNode>::from_node(node, src)
11242            })
11243            .map(Self::Uninterpreted)
11244            .unwrap_or(Self::Unknown(node)),
11245            _ => Self::Unknown(node),
11246        }
11247    }
11248}
11249impl ::treesitter_types::Spanned for AnyNode<'_> {
11250    fn span(&self) -> ::treesitter_types::Span {
11251        match self {
11252            Self::Arg(inner) => inner.span(),
11253            Self::CallOperator(inner) => inner.span(),
11254            Self::Expression(inner) => inner.span(),
11255            Self::Lhs(inner) => inner.span(),
11256            Self::MethodName(inner) => inner.span(),
11257            Self::NonlocalVariable(inner) => inner.span(),
11258            Self::PatternConstant(inner) => inner.span(),
11259            Self::PatternExpr(inner) => inner.span(),
11260            Self::PatternExprBasic(inner) => inner.span(),
11261            Self::PatternPrimitive(inner) => inner.span(),
11262            Self::PatternTopExprBody(inner) => inner.span(),
11263            Self::Primary(inner) => inner.span(),
11264            Self::SimpleNumeric(inner) => inner.span(),
11265            Self::Statement(inner) => inner.span(),
11266            Self::Variable(inner) => inner.span(),
11267            Self::Alias(inner) => inner.span(),
11268            Self::AlternativePattern(inner) => inner.span(),
11269            Self::ArgumentList(inner) => inner.span(),
11270            Self::Array(inner) => inner.span(),
11271            Self::ArrayPattern(inner) => inner.span(),
11272            Self::AsPattern(inner) => inner.span(),
11273            Self::Assignment(inner) => inner.span(),
11274            Self::BareString(inner) => inner.span(),
11275            Self::BareSymbol(inner) => inner.span(),
11276            Self::Begin(inner) => inner.span(),
11277            Self::BeginBlock(inner) => inner.span(),
11278            Self::Binary(inner) => inner.span(),
11279            Self::Block(inner) => inner.span(),
11280            Self::BlockArgument(inner) => inner.span(),
11281            Self::BlockBody(inner) => inner.span(),
11282            Self::BlockParameter(inner) => inner.span(),
11283            Self::BlockParameters(inner) => inner.span(),
11284            Self::BodyStatement(inner) => inner.span(),
11285            Self::Break(inner) => inner.span(),
11286            Self::Call(inner) => inner.span(),
11287            Self::Case(inner) => inner.span(),
11288            Self::CaseMatch(inner) => inner.span(),
11289            Self::ChainedString(inner) => inner.span(),
11290            Self::Class(inner) => inner.span(),
11291            Self::Complex(inner) => inner.span(),
11292            Self::Conditional(inner) => inner.span(),
11293            Self::Constant(inner) => inner.span(),
11294            Self::DelimitedSymbol(inner) => inner.span(),
11295            Self::DestructuredLeftAssignment(inner) => inner.span(),
11296            Self::DestructuredParameter(inner) => inner.span(),
11297            Self::Do(inner) => inner.span(),
11298            Self::DoBlock(inner) => inner.span(),
11299            Self::ElementReference(inner) => inner.span(),
11300            Self::Else(inner) => inner.span(),
11301            Self::Elsif(inner) => inner.span(),
11302            Self::EmptyStatement(inner) => inner.span(),
11303            Self::EndBlock(inner) => inner.span(),
11304            Self::Ensure(inner) => inner.span(),
11305            Self::ExceptionVariable(inner) => inner.span(),
11306            Self::Exceptions(inner) => inner.span(),
11307            Self::ExpressionReferencePattern(inner) => inner.span(),
11308            Self::FindPattern(inner) => inner.span(),
11309            Self::For(inner) => inner.span(),
11310            Self::ForwardArgument(inner) => inner.span(),
11311            Self::ForwardParameter(inner) => inner.span(),
11312            Self::Hash(inner) => inner.span(),
11313            Self::HashKeySymbol(inner) => inner.span(),
11314            Self::HashPattern(inner) => inner.span(),
11315            Self::HashSplatArgument(inner) => inner.span(),
11316            Self::HashSplatNil(inner) => inner.span(),
11317            Self::HashSplatParameter(inner) => inner.span(),
11318            Self::HeredocBody(inner) => inner.span(),
11319            Self::Identifier(inner) => inner.span(),
11320            Self::If(inner) => inner.span(),
11321            Self::IfGuard(inner) => inner.span(),
11322            Self::IfModifier(inner) => inner.span(),
11323            Self::In(inner) => inner.span(),
11324            Self::InClause(inner) => inner.span(),
11325            Self::Interpolation(inner) => inner.span(),
11326            Self::KeywordParameter(inner) => inner.span(),
11327            Self::KeywordPattern(inner) => inner.span(),
11328            Self::Lambda(inner) => inner.span(),
11329            Self::LambdaParameters(inner) => inner.span(),
11330            Self::LeftAssignmentList(inner) => inner.span(),
11331            Self::MatchPattern(inner) => inner.span(),
11332            Self::Method(inner) => inner.span(),
11333            Self::MethodParameters(inner) => inner.span(),
11334            Self::Module(inner) => inner.span(),
11335            Self::Next(inner) => inner.span(),
11336            Self::Nil(inner) => inner.span(),
11337            Self::Operator(inner) => inner.span(),
11338            Self::OperatorAssignment(inner) => inner.span(),
11339            Self::OptionalParameter(inner) => inner.span(),
11340            Self::Pair(inner) => inner.span(),
11341            Self::ParenthesizedPattern(inner) => inner.span(),
11342            Self::ParenthesizedStatements(inner) => inner.span(),
11343            Self::Pattern(inner) => inner.span(),
11344            Self::Program(inner) => inner.span(),
11345            Self::Range(inner) => inner.span(),
11346            Self::Rational(inner) => inner.span(),
11347            Self::Redo(inner) => inner.span(),
11348            Self::Regex(inner) => inner.span(),
11349            Self::Rescue(inner) => inner.span(),
11350            Self::RescueModifier(inner) => inner.span(),
11351            Self::RestAssignment(inner) => inner.span(),
11352            Self::Retry(inner) => inner.span(),
11353            Self::Return(inner) => inner.span(),
11354            Self::RightAssignmentList(inner) => inner.span(),
11355            Self::ScopeResolution(inner) => inner.span(),
11356            Self::Setter(inner) => inner.span(),
11357            Self::SingletonClass(inner) => inner.span(),
11358            Self::SingletonMethod(inner) => inner.span(),
11359            Self::SplatArgument(inner) => inner.span(),
11360            Self::SplatParameter(inner) => inner.span(),
11361            Self::String(inner) => inner.span(),
11362            Self::StringArray(inner) => inner.span(),
11363            Self::Subshell(inner) => inner.span(),
11364            Self::Superclass(inner) => inner.span(),
11365            Self::SymbolArray(inner) => inner.span(),
11366            Self::TestPattern(inner) => inner.span(),
11367            Self::Then(inner) => inner.span(),
11368            Self::Unary(inner) => inner.span(),
11369            Self::Undef(inner) => inner.span(),
11370            Self::Unless(inner) => inner.span(),
11371            Self::UnlessGuard(inner) => inner.span(),
11372            Self::UnlessModifier(inner) => inner.span(),
11373            Self::Until(inner) => inner.span(),
11374            Self::UntilModifier(inner) => inner.span(),
11375            Self::VariableReferencePattern(inner) => inner.span(),
11376            Self::When(inner) => inner.span(),
11377            Self::While(inner) => inner.span(),
11378            Self::WhileModifier(inner) => inner.span(),
11379            Self::Yield(inner) => inner.span(),
11380            Self::Character(inner) => inner.span(),
11381            Self::ClassVariable(inner) => inner.span(),
11382            Self::Comment(inner) => inner.span(),
11383            Self::Encoding(inner) => inner.span(),
11384            Self::EscapeSequence(inner) => inner.span(),
11385            Self::False(inner) => inner.span(),
11386            Self::File(inner) => inner.span(),
11387            Self::Float(inner) => inner.span(),
11388            Self::GlobalVariable(inner) => inner.span(),
11389            Self::HeredocBeginning(inner) => inner.span(),
11390            Self::HeredocContent(inner) => inner.span(),
11391            Self::HeredocEnd(inner) => inner.span(),
11392            Self::InstanceVariable(inner) => inner.span(),
11393            Self::Integer(inner) => inner.span(),
11394            Self::Line(inner) => inner.span(),
11395            Self::SelfType(inner) => inner.span(),
11396            Self::SimpleSymbol(inner) => inner.span(),
11397            Self::StringContent(inner) => inner.span(),
11398            Self::Super(inner) => inner.span(),
11399            Self::True(inner) => inner.span(),
11400            Self::Uninterpreted(inner) => inner.span(),
11401            Self::Unknown(node) => ::treesitter_types::Span::from(*node),
11402        }
11403    }
11404}