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: ::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 <Assignment as ::treesitter_types::FromNode>::from_node(node, src)?,
20 ))),
21 "binary" => Ok(Self::Binary(::std::boxed::Box::new(
22 <Binary as ::treesitter_types::FromNode>::from_node(node, src)?,
23 ))),
24 "conditional" => Ok(Self::Conditional(::std::boxed::Box::new(
25 <Conditional as ::treesitter_types::FromNode>::from_node(node, src)?,
26 ))),
27 "operator_assignment" => Ok(Self::OperatorAssignment(::std::boxed::Box::new(
28 <OperatorAssignment as ::treesitter_types::FromNode>::from_node(node, src)?,
29 ))),
30 "range" => Ok(Self::Range(::std::boxed::Box::new(
31 <Range as ::treesitter_types::FromNode>::from_node(node, src)?,
32 ))),
33 "unary" => Ok(Self::Unary(::std::boxed::Box::new(
34 <Unary as ::treesitter_types::FromNode>::from_node(node, src)?,
35 ))),
36 _other => {
37 if let Ok(v) = <Primary as ::treesitter_types::FromNode>::from_node(node, src) {
38 Ok(Self::Primary(::std::boxed::Box::new(v)))
39 } else {
40 Err(::treesitter_types::ParseError::unexpected_kind(
41 _other, node,
42 ))
43 }
44 }
45 }
46 }
47}
48impl ::treesitter_types::Spanned for Arg<'_> {
49 fn span(&self) -> ::treesitter_types::Span {
50 match self {
51 Self::Primary(inner) => inner.span(),
52 Self::Assignment(inner) => inner.span(),
53 Self::Binary(inner) => inner.span(),
54 Self::Conditional(inner) => inner.span(),
55 Self::OperatorAssignment(inner) => inner.span(),
56 Self::Range(inner) => inner.span(),
57 Self::Unary(inner) => inner.span(),
58 }
59 }
60}
61#[derive(Debug, Clone, PartialEq, Eq)]
62pub enum CallOperator {
63 AmpDot(::treesitter_types::Span),
64 Dot(::treesitter_types::Span),
65 DoubleColon(::treesitter_types::Span),
66}
67impl<'tree> ::treesitter_types::FromNode<'tree> for CallOperator {
68 #[allow(clippy::collapsible_else_if)]
69 fn from_node(
70 node: ::tree_sitter::Node<'tree>,
71 _src: &'tree [u8],
72 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
73 match node.kind() {
74 "&." => Ok(Self::AmpDot(::treesitter_types::Span::from(node))),
75 "." => Ok(Self::Dot(::treesitter_types::Span::from(node))),
76 "::" => Ok(Self::DoubleColon(::treesitter_types::Span::from(node))),
77 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
78 }
79 }
80}
81impl ::treesitter_types::Spanned for CallOperator {
82 fn span(&self) -> ::treesitter_types::Span {
83 match self {
84 Self::AmpDot(span) => *span,
85 Self::Dot(span) => *span,
86 Self::DoubleColon(span) => *span,
87 }
88 }
89}
90#[derive(Debug, Clone, PartialEq, Eq)]
91pub enum Expression<'tree> {
92 Arg(::std::boxed::Box<Arg<'tree>>),
93 Assignment(::std::boxed::Box<Assignment<'tree>>),
94 Binary(::std::boxed::Box<Binary<'tree>>),
95 Break(::std::boxed::Box<Break<'tree>>),
96 Call(::std::boxed::Box<Call<'tree>>),
97 MatchPattern(::std::boxed::Box<MatchPattern<'tree>>),
98 Next(::std::boxed::Box<Next<'tree>>),
99 OperatorAssignment(::std::boxed::Box<OperatorAssignment<'tree>>),
100 Return(::std::boxed::Box<Return<'tree>>),
101 TestPattern(::std::boxed::Box<TestPattern<'tree>>),
102 Unary(::std::boxed::Box<Unary<'tree>>),
103 Yield(::std::boxed::Box<Yield<'tree>>),
104}
105impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
106 #[allow(clippy::collapsible_else_if)]
107 fn from_node(
108 node: ::tree_sitter::Node<'tree>,
109 src: &'tree [u8],
110 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
111 match node.kind() {
112 "assignment" => Ok(Self::Assignment(::std::boxed::Box::new(
113 <Assignment as ::treesitter_types::FromNode>::from_node(node, src)?,
114 ))),
115 "binary" => Ok(Self::Binary(::std::boxed::Box::new(
116 <Binary as ::treesitter_types::FromNode>::from_node(node, src)?,
117 ))),
118 "break" => Ok(Self::Break(::std::boxed::Box::new(
119 <Break as ::treesitter_types::FromNode>::from_node(node, src)?,
120 ))),
121 "call" => Ok(Self::Call(::std::boxed::Box::new(
122 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
123 ))),
124 "match_pattern" => Ok(Self::MatchPattern(::std::boxed::Box::new(
125 <MatchPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
126 ))),
127 "next" => Ok(Self::Next(::std::boxed::Box::new(
128 <Next as ::treesitter_types::FromNode>::from_node(node, src)?,
129 ))),
130 "operator_assignment" => Ok(Self::OperatorAssignment(::std::boxed::Box::new(
131 <OperatorAssignment as ::treesitter_types::FromNode>::from_node(node, src)?,
132 ))),
133 "return" => Ok(Self::Return(::std::boxed::Box::new(
134 <Return as ::treesitter_types::FromNode>::from_node(node, src)?,
135 ))),
136 "test_pattern" => Ok(Self::TestPattern(::std::boxed::Box::new(
137 <TestPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
138 ))),
139 "unary" => Ok(Self::Unary(::std::boxed::Box::new(
140 <Unary as ::treesitter_types::FromNode>::from_node(node, src)?,
141 ))),
142 "yield" => Ok(Self::Yield(::std::boxed::Box::new(
143 <Yield as ::treesitter_types::FromNode>::from_node(node, src)?,
144 ))),
145 _other => {
146 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
147 Ok(Self::Arg(::std::boxed::Box::new(v)))
148 } else {
149 Err(::treesitter_types::ParseError::unexpected_kind(
150 _other, node,
151 ))
152 }
153 }
154 }
155 }
156}
157impl ::treesitter_types::Spanned for Expression<'_> {
158 fn span(&self) -> ::treesitter_types::Span {
159 match self {
160 Self::Arg(inner) => inner.span(),
161 Self::Assignment(inner) => inner.span(),
162 Self::Binary(inner) => inner.span(),
163 Self::Break(inner) => inner.span(),
164 Self::Call(inner) => inner.span(),
165 Self::MatchPattern(inner) => inner.span(),
166 Self::Next(inner) => inner.span(),
167 Self::OperatorAssignment(inner) => inner.span(),
168 Self::Return(inner) => inner.span(),
169 Self::TestPattern(inner) => inner.span(),
170 Self::Unary(inner) => inner.span(),
171 Self::Yield(inner) => inner.span(),
172 }
173 }
174}
175#[derive(Debug, Clone, PartialEq, Eq)]
176pub enum Lhs<'tree> {
177 Variable(::std::boxed::Box<Variable<'tree>>),
178 Call(::std::boxed::Box<Call<'tree>>),
179 ElementReference(::std::boxed::Box<ElementReference<'tree>>),
180 False(::std::boxed::Box<False<'tree>>),
181 Nil(::std::boxed::Box<Nil<'tree>>),
182 ScopeResolution(::std::boxed::Box<ScopeResolution<'tree>>),
183 True(::std::boxed::Box<True<'tree>>),
184}
185impl<'tree> ::treesitter_types::FromNode<'tree> for Lhs<'tree> {
186 #[allow(clippy::collapsible_else_if)]
187 fn from_node(
188 node: ::tree_sitter::Node<'tree>,
189 src: &'tree [u8],
190 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
191 match node.kind() {
192 "call" => Ok(Self::Call(::std::boxed::Box::new(
193 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
194 ))),
195 "element_reference" => Ok(Self::ElementReference(::std::boxed::Box::new(
196 <ElementReference as ::treesitter_types::FromNode>::from_node(node, src)?,
197 ))),
198 "false" => Ok(Self::False(::std::boxed::Box::new(
199 <False as ::treesitter_types::FromNode>::from_node(node, src)?,
200 ))),
201 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
202 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
203 ))),
204 "scope_resolution" => Ok(Self::ScopeResolution(::std::boxed::Box::new(
205 <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)?,
206 ))),
207 "true" => Ok(Self::True(::std::boxed::Box::new(
208 <True as ::treesitter_types::FromNode>::from_node(node, src)?,
209 ))),
210 _other => {
211 if let Ok(v) = <Variable as ::treesitter_types::FromNode>::from_node(node, src) {
212 Ok(Self::Variable(::std::boxed::Box::new(v)))
213 } else {
214 Err(::treesitter_types::ParseError::unexpected_kind(
215 _other, node,
216 ))
217 }
218 }
219 }
220 }
221}
222impl ::treesitter_types::Spanned for Lhs<'_> {
223 fn span(&self) -> ::treesitter_types::Span {
224 match self {
225 Self::Variable(inner) => inner.span(),
226 Self::Call(inner) => inner.span(),
227 Self::ElementReference(inner) => inner.span(),
228 Self::False(inner) => inner.span(),
229 Self::Nil(inner) => inner.span(),
230 Self::ScopeResolution(inner) => inner.span(),
231 Self::True(inner) => inner.span(),
232 }
233 }
234}
235#[derive(Debug, Clone, PartialEq, Eq)]
236pub enum MethodName<'tree> {
237 NonlocalVariable(::std::boxed::Box<NonlocalVariable<'tree>>),
238 Constant(::std::boxed::Box<Constant<'tree>>),
239 DelimitedSymbol(::std::boxed::Box<DelimitedSymbol<'tree>>),
240 Identifier(::std::boxed::Box<Identifier<'tree>>),
241 Operator(::std::boxed::Box<Operator<'tree>>),
242 Setter(::std::boxed::Box<Setter<'tree>>),
243 SimpleSymbol(::std::boxed::Box<SimpleSymbol<'tree>>),
244}
245impl<'tree> ::treesitter_types::FromNode<'tree> for MethodName<'tree> {
246 #[allow(clippy::collapsible_else_if)]
247 fn from_node(
248 node: ::tree_sitter::Node<'tree>,
249 src: &'tree [u8],
250 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
251 match node.kind() {
252 "constant" => Ok(Self::Constant(::std::boxed::Box::new(
253 <Constant as ::treesitter_types::FromNode>::from_node(node, src)?,
254 ))),
255 "delimited_symbol" => Ok(Self::DelimitedSymbol(::std::boxed::Box::new(
256 <DelimitedSymbol as ::treesitter_types::FromNode>::from_node(node, src)?,
257 ))),
258 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
259 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
260 ))),
261 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
262 <Operator as ::treesitter_types::FromNode>::from_node(node, src)?,
263 ))),
264 "setter" => Ok(Self::Setter(::std::boxed::Box::new(
265 <Setter as ::treesitter_types::FromNode>::from_node(node, src)?,
266 ))),
267 "simple_symbol" => Ok(Self::SimpleSymbol(::std::boxed::Box::new(
268 <SimpleSymbol as ::treesitter_types::FromNode>::from_node(node, src)?,
269 ))),
270 _other => {
271 if let Ok(v) =
272 <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
273 {
274 Ok(Self::NonlocalVariable(::std::boxed::Box::new(v)))
275 } else {
276 Err(::treesitter_types::ParseError::unexpected_kind(
277 _other, node,
278 ))
279 }
280 }
281 }
282 }
283}
284impl ::treesitter_types::Spanned for MethodName<'_> {
285 fn span(&self) -> ::treesitter_types::Span {
286 match self {
287 Self::NonlocalVariable(inner) => inner.span(),
288 Self::Constant(inner) => inner.span(),
289 Self::DelimitedSymbol(inner) => inner.span(),
290 Self::Identifier(inner) => inner.span(),
291 Self::Operator(inner) => inner.span(),
292 Self::Setter(inner) => inner.span(),
293 Self::SimpleSymbol(inner) => inner.span(),
294 }
295 }
296}
297#[derive(Debug, Clone, PartialEq, Eq)]
298pub enum NonlocalVariable<'tree> {
299 ClassVariable(::std::boxed::Box<ClassVariable<'tree>>),
300 GlobalVariable(::std::boxed::Box<GlobalVariable<'tree>>),
301 InstanceVariable(::std::boxed::Box<InstanceVariable<'tree>>),
302}
303impl<'tree> ::treesitter_types::FromNode<'tree> for NonlocalVariable<'tree> {
304 #[allow(clippy::collapsible_else_if)]
305 fn from_node(
306 node: ::tree_sitter::Node<'tree>,
307 src: &'tree [u8],
308 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
309 match node.kind() {
310 "class_variable" => Ok(Self::ClassVariable(::std::boxed::Box::new(
311 <ClassVariable as ::treesitter_types::FromNode>::from_node(node, src)?,
312 ))),
313 "global_variable" => Ok(Self::GlobalVariable(::std::boxed::Box::new(
314 <GlobalVariable as ::treesitter_types::FromNode>::from_node(node, src)?,
315 ))),
316 "instance_variable" => Ok(Self::InstanceVariable(::std::boxed::Box::new(
317 <InstanceVariable as ::treesitter_types::FromNode>::from_node(node, src)?,
318 ))),
319 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
320 }
321 }
322}
323impl ::treesitter_types::Spanned for NonlocalVariable<'_> {
324 fn span(&self) -> ::treesitter_types::Span {
325 match self {
326 Self::ClassVariable(inner) => inner.span(),
327 Self::GlobalVariable(inner) => inner.span(),
328 Self::InstanceVariable(inner) => inner.span(),
329 }
330 }
331}
332#[derive(Debug, Clone, PartialEq, Eq)]
333pub enum PatternConstant<'tree> {
334 Constant(::std::boxed::Box<Constant<'tree>>),
335 ScopeResolution(::std::boxed::Box<ScopeResolution<'tree>>),
336}
337impl<'tree> ::treesitter_types::FromNode<'tree> for PatternConstant<'tree> {
338 #[allow(clippy::collapsible_else_if)]
339 fn from_node(
340 node: ::tree_sitter::Node<'tree>,
341 src: &'tree [u8],
342 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
343 match node.kind() {
344 "constant" => Ok(Self::Constant(::std::boxed::Box::new(
345 <Constant as ::treesitter_types::FromNode>::from_node(node, src)?,
346 ))),
347 "scope_resolution" => Ok(Self::ScopeResolution(::std::boxed::Box::new(
348 <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)?,
349 ))),
350 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
351 }
352 }
353}
354impl ::treesitter_types::Spanned for PatternConstant<'_> {
355 fn span(&self) -> ::treesitter_types::Span {
356 match self {
357 Self::Constant(inner) => inner.span(),
358 Self::ScopeResolution(inner) => inner.span(),
359 }
360 }
361}
362#[derive(Debug, Clone, PartialEq, Eq)]
363pub enum PatternExpr<'tree> {
364 PatternExprBasic(::std::boxed::Box<PatternExprBasic<'tree>>),
365 AlternativePattern(::std::boxed::Box<AlternativePattern<'tree>>),
366 AsPattern(::std::boxed::Box<AsPattern<'tree>>),
367}
368impl<'tree> ::treesitter_types::FromNode<'tree> for PatternExpr<'tree> {
369 #[allow(clippy::collapsible_else_if)]
370 fn from_node(
371 node: ::tree_sitter::Node<'tree>,
372 src: &'tree [u8],
373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
374 match node.kind() {
375 "alternative_pattern" => Ok(Self::AlternativePattern(::std::boxed::Box::new(
376 <AlternativePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
377 ))),
378 "as_pattern" => Ok(Self::AsPattern(::std::boxed::Box::new(
379 <AsPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
380 ))),
381 _other => {
382 if let Ok(v) =
383 <PatternExprBasic as ::treesitter_types::FromNode>::from_node(node, src)
384 {
385 Ok(Self::PatternExprBasic(::std::boxed::Box::new(v)))
386 } else {
387 Err(::treesitter_types::ParseError::unexpected_kind(
388 _other, node,
389 ))
390 }
391 }
392 }
393 }
394}
395impl ::treesitter_types::Spanned for PatternExpr<'_> {
396 fn span(&self) -> ::treesitter_types::Span {
397 match self {
398 Self::PatternExprBasic(inner) => inner.span(),
399 Self::AlternativePattern(inner) => inner.span(),
400 Self::AsPattern(inner) => inner.span(),
401 }
402 }
403}
404#[derive(Debug, Clone, PartialEq, Eq)]
405pub enum PatternExprBasic<'tree> {
406 PatternConstant(::std::boxed::Box<PatternConstant<'tree>>),
407 PatternPrimitive(::std::boxed::Box<PatternPrimitive<'tree>>),
408 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
409 ExpressionReferencePattern(::std::boxed::Box<ExpressionReferencePattern<'tree>>),
410 FindPattern(::std::boxed::Box<FindPattern<'tree>>),
411 HashPattern(::std::boxed::Box<HashPattern<'tree>>),
412 Identifier(::std::boxed::Box<Identifier<'tree>>),
413 ParenthesizedPattern(::std::boxed::Box<ParenthesizedPattern<'tree>>),
414 Range(::std::boxed::Box<Range<'tree>>),
415 VariableReferencePattern(::std::boxed::Box<VariableReferencePattern<'tree>>),
416}
417impl<'tree> ::treesitter_types::FromNode<'tree> for PatternExprBasic<'tree> {
418 #[allow(clippy::collapsible_else_if)]
419 fn from_node(
420 node: ::tree_sitter::Node<'tree>,
421 src: &'tree [u8],
422 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
423 match node.kind() {
424 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
425 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
426 ))),
427 "expression_reference_pattern" => {
428 Ok(Self::ExpressionReferencePattern(::std::boxed::Box::new(
429 <ExpressionReferencePattern as ::treesitter_types::FromNode>::from_node(
430 node, src,
431 )?,
432 )))
433 }
434 "find_pattern" => Ok(Self::FindPattern(::std::boxed::Box::new(
435 <FindPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
436 ))),
437 "hash_pattern" => Ok(Self::HashPattern(::std::boxed::Box::new(
438 <HashPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
439 ))),
440 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
441 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
442 ))),
443 "parenthesized_pattern" => Ok(Self::ParenthesizedPattern(::std::boxed::Box::new(
444 <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
445 ))),
446 "range" => Ok(Self::Range(::std::boxed::Box::new(
447 <Range as ::treesitter_types::FromNode>::from_node(node, src)?,
448 ))),
449 "variable_reference_pattern" => {
450 Ok(Self::VariableReferencePattern(::std::boxed::Box::new(
451 <VariableReferencePattern as ::treesitter_types::FromNode>::from_node(
452 node, src,
453 )?,
454 )))
455 }
456 _other => {
457 if let Ok(v) =
458 <PatternConstant as ::treesitter_types::FromNode>::from_node(node, src)
459 {
460 Ok(Self::PatternConstant(::std::boxed::Box::new(v)))
461 } else {
462 if let Ok(v) =
463 <PatternPrimitive as ::treesitter_types::FromNode>::from_node(node, src)
464 {
465 Ok(Self::PatternPrimitive(::std::boxed::Box::new(v)))
466 } else {
467 Err(::treesitter_types::ParseError::unexpected_kind(
468 _other, node,
469 ))
470 }
471 }
472 }
473 }
474 }
475}
476impl ::treesitter_types::Spanned for PatternExprBasic<'_> {
477 fn span(&self) -> ::treesitter_types::Span {
478 match self {
479 Self::PatternConstant(inner) => inner.span(),
480 Self::PatternPrimitive(inner) => inner.span(),
481 Self::ArrayPattern(inner) => inner.span(),
482 Self::ExpressionReferencePattern(inner) => inner.span(),
483 Self::FindPattern(inner) => inner.span(),
484 Self::HashPattern(inner) => inner.span(),
485 Self::Identifier(inner) => inner.span(),
486 Self::ParenthesizedPattern(inner) => inner.span(),
487 Self::Range(inner) => inner.span(),
488 Self::VariableReferencePattern(inner) => inner.span(),
489 }
490 }
491}
492#[derive(Debug, Clone, PartialEq, Eq)]
493pub enum PatternPrimitive<'tree> {
494 SimpleNumeric(::std::boxed::Box<SimpleNumeric<'tree>>),
495 DelimitedSymbol(::std::boxed::Box<DelimitedSymbol<'tree>>),
496 Encoding(::std::boxed::Box<Encoding<'tree>>),
497 False(::std::boxed::Box<False<'tree>>),
498 File(::std::boxed::Box<File<'tree>>),
499 HeredocBeginning(::std::boxed::Box<HeredocBeginning<'tree>>),
500 Lambda(::std::boxed::Box<Lambda<'tree>>),
501 Line(::std::boxed::Box<Line<'tree>>),
502 Nil(::std::boxed::Box<Nil<'tree>>),
503 Regex(::std::boxed::Box<Regex<'tree>>),
504 SelfType(::std::boxed::Box<SelfType<'tree>>),
505 SimpleSymbol(::std::boxed::Box<SimpleSymbol<'tree>>),
506 String(::std::boxed::Box<String<'tree>>),
507 StringArray(::std::boxed::Box<StringArray<'tree>>),
508 Subshell(::std::boxed::Box<Subshell<'tree>>),
509 SymbolArray(::std::boxed::Box<SymbolArray<'tree>>),
510 True(::std::boxed::Box<True<'tree>>),
511 Unary(::std::boxed::Box<Unary<'tree>>),
512}
513impl<'tree> ::treesitter_types::FromNode<'tree> for PatternPrimitive<'tree> {
514 #[allow(clippy::collapsible_else_if)]
515 fn from_node(
516 node: ::tree_sitter::Node<'tree>,
517 src: &'tree [u8],
518 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
519 match node.kind() {
520 "delimited_symbol" => Ok(Self::DelimitedSymbol(::std::boxed::Box::new(
521 <DelimitedSymbol as ::treesitter_types::FromNode>::from_node(node, src)?,
522 ))),
523 "encoding" => Ok(Self::Encoding(::std::boxed::Box::new(
524 <Encoding as ::treesitter_types::FromNode>::from_node(node, src)?,
525 ))),
526 "false" => Ok(Self::False(::std::boxed::Box::new(
527 <False as ::treesitter_types::FromNode>::from_node(node, src)?,
528 ))),
529 "file" => Ok(Self::File(::std::boxed::Box::new(
530 <File as ::treesitter_types::FromNode>::from_node(node, src)?,
531 ))),
532 "heredoc_beginning" => Ok(Self::HeredocBeginning(::std::boxed::Box::new(
533 <HeredocBeginning as ::treesitter_types::FromNode>::from_node(node, src)?,
534 ))),
535 "lambda" => Ok(Self::Lambda(::std::boxed::Box::new(
536 <Lambda as ::treesitter_types::FromNode>::from_node(node, src)?,
537 ))),
538 "line" => Ok(Self::Line(::std::boxed::Box::new(
539 <Line as ::treesitter_types::FromNode>::from_node(node, src)?,
540 ))),
541 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
542 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
543 ))),
544 "regex" => Ok(Self::Regex(::std::boxed::Box::new(
545 <Regex as ::treesitter_types::FromNode>::from_node(node, src)?,
546 ))),
547 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
548 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
549 ))),
550 "simple_symbol" => Ok(Self::SimpleSymbol(::std::boxed::Box::new(
551 <SimpleSymbol as ::treesitter_types::FromNode>::from_node(node, src)?,
552 ))),
553 "string" => Ok(Self::String(::std::boxed::Box::new(
554 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
555 ))),
556 "string_array" => Ok(Self::StringArray(::std::boxed::Box::new(
557 <StringArray as ::treesitter_types::FromNode>::from_node(node, src)?,
558 ))),
559 "subshell" => Ok(Self::Subshell(::std::boxed::Box::new(
560 <Subshell as ::treesitter_types::FromNode>::from_node(node, src)?,
561 ))),
562 "symbol_array" => Ok(Self::SymbolArray(::std::boxed::Box::new(
563 <SymbolArray as ::treesitter_types::FromNode>::from_node(node, src)?,
564 ))),
565 "true" => Ok(Self::True(::std::boxed::Box::new(
566 <True as ::treesitter_types::FromNode>::from_node(node, src)?,
567 ))),
568 "unary" => Ok(Self::Unary(::std::boxed::Box::new(
569 <Unary as ::treesitter_types::FromNode>::from_node(node, src)?,
570 ))),
571 _other => {
572 if let Ok(v) = <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src)
573 {
574 Ok(Self::SimpleNumeric(::std::boxed::Box::new(v)))
575 } else {
576 Err(::treesitter_types::ParseError::unexpected_kind(
577 _other, node,
578 ))
579 }
580 }
581 }
582 }
583}
584impl ::treesitter_types::Spanned for PatternPrimitive<'_> {
585 fn span(&self) -> ::treesitter_types::Span {
586 match self {
587 Self::SimpleNumeric(inner) => inner.span(),
588 Self::DelimitedSymbol(inner) => inner.span(),
589 Self::Encoding(inner) => inner.span(),
590 Self::False(inner) => inner.span(),
591 Self::File(inner) => inner.span(),
592 Self::HeredocBeginning(inner) => inner.span(),
593 Self::Lambda(inner) => inner.span(),
594 Self::Line(inner) => inner.span(),
595 Self::Nil(inner) => inner.span(),
596 Self::Regex(inner) => inner.span(),
597 Self::SelfType(inner) => inner.span(),
598 Self::SimpleSymbol(inner) => inner.span(),
599 Self::String(inner) => inner.span(),
600 Self::StringArray(inner) => inner.span(),
601 Self::Subshell(inner) => inner.span(),
602 Self::SymbolArray(inner) => inner.span(),
603 Self::True(inner) => inner.span(),
604 Self::Unary(inner) => inner.span(),
605 }
606 }
607}
608#[derive(Debug, Clone, PartialEq, Eq)]
609pub enum PatternTopExprBody<'tree> {
610 PatternExpr(::std::boxed::Box<PatternExpr<'tree>>),
611 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
612 FindPattern(::std::boxed::Box<FindPattern<'tree>>),
613 HashPattern(::std::boxed::Box<HashPattern<'tree>>),
614}
615impl<'tree> ::treesitter_types::FromNode<'tree> for PatternTopExprBody<'tree> {
616 #[allow(clippy::collapsible_else_if)]
617 fn from_node(
618 node: ::tree_sitter::Node<'tree>,
619 src: &'tree [u8],
620 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
621 match node.kind() {
622 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
623 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
624 ))),
625 "find_pattern" => Ok(Self::FindPattern(::std::boxed::Box::new(
626 <FindPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
627 ))),
628 "hash_pattern" => Ok(Self::HashPattern(::std::boxed::Box::new(
629 <HashPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
630 ))),
631 _other => {
632 if let Ok(v) = <PatternExpr as ::treesitter_types::FromNode>::from_node(node, src) {
633 Ok(Self::PatternExpr(::std::boxed::Box::new(v)))
634 } else {
635 Err(::treesitter_types::ParseError::unexpected_kind(
636 _other, node,
637 ))
638 }
639 }
640 }
641 }
642}
643impl ::treesitter_types::Spanned for PatternTopExprBody<'_> {
644 fn span(&self) -> ::treesitter_types::Span {
645 match self {
646 Self::PatternExpr(inner) => inner.span(),
647 Self::ArrayPattern(inner) => inner.span(),
648 Self::FindPattern(inner) => inner.span(),
649 Self::HashPattern(inner) => inner.span(),
650 }
651 }
652}
653#[derive(Debug, Clone, PartialEq, Eq)]
654pub enum Primary<'tree> {
655 Lhs(::std::boxed::Box<Lhs<'tree>>),
656 SimpleNumeric(::std::boxed::Box<SimpleNumeric<'tree>>),
657 Array(::std::boxed::Box<Array<'tree>>),
658 Begin(::std::boxed::Box<Begin<'tree>>),
659 Break(::std::boxed::Box<Break<'tree>>),
660 Call(::std::boxed::Box<Call<'tree>>),
661 Case(::std::boxed::Box<Case<'tree>>),
662 CaseMatch(::std::boxed::Box<CaseMatch<'tree>>),
663 ChainedString(::std::boxed::Box<ChainedString<'tree>>),
664 Character(::std::boxed::Box<Character<'tree>>),
665 Class(::std::boxed::Box<Class<'tree>>),
666 DelimitedSymbol(::std::boxed::Box<DelimitedSymbol<'tree>>),
667 For(::std::boxed::Box<For<'tree>>),
668 Hash(::std::boxed::Box<Hash<'tree>>),
669 HeredocBeginning(::std::boxed::Box<HeredocBeginning<'tree>>),
670 If(::std::boxed::Box<If<'tree>>),
671 Lambda(::std::boxed::Box<Lambda<'tree>>),
672 Method(::std::boxed::Box<Method<'tree>>),
673 Module(::std::boxed::Box<Module<'tree>>),
674 Next(::std::boxed::Box<Next<'tree>>),
675 ParenthesizedStatements(::std::boxed::Box<ParenthesizedStatements<'tree>>),
676 Redo(::std::boxed::Box<Redo<'tree>>),
677 Regex(::std::boxed::Box<Regex<'tree>>),
678 Retry(::std::boxed::Box<Retry<'tree>>),
679 Return(::std::boxed::Box<Return<'tree>>),
680 SimpleSymbol(::std::boxed::Box<SimpleSymbol<'tree>>),
681 SingletonClass(::std::boxed::Box<SingletonClass<'tree>>),
682 SingletonMethod(::std::boxed::Box<SingletonMethod<'tree>>),
683 String(::std::boxed::Box<String<'tree>>),
684 StringArray(::std::boxed::Box<StringArray<'tree>>),
685 Subshell(::std::boxed::Box<Subshell<'tree>>),
686 SymbolArray(::std::boxed::Box<SymbolArray<'tree>>),
687 Unary(::std::boxed::Box<Unary<'tree>>),
688 Unless(::std::boxed::Box<Unless<'tree>>),
689 Until(::std::boxed::Box<Until<'tree>>),
690 While(::std::boxed::Box<While<'tree>>),
691 Yield(::std::boxed::Box<Yield<'tree>>),
692}
693impl<'tree> ::treesitter_types::FromNode<'tree> for Primary<'tree> {
694 #[allow(clippy::collapsible_else_if)]
695 fn from_node(
696 node: ::tree_sitter::Node<'tree>,
697 src: &'tree [u8],
698 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
699 match node.kind() {
700 "array" => Ok(Self::Array(::std::boxed::Box::new(
701 <Array as ::treesitter_types::FromNode>::from_node(node, src)?,
702 ))),
703 "begin" => Ok(Self::Begin(::std::boxed::Box::new(
704 <Begin as ::treesitter_types::FromNode>::from_node(node, src)?,
705 ))),
706 "break" => Ok(Self::Break(::std::boxed::Box::new(
707 <Break as ::treesitter_types::FromNode>::from_node(node, src)?,
708 ))),
709 "call" => Ok(Self::Call(::std::boxed::Box::new(
710 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
711 ))),
712 "case" => Ok(Self::Case(::std::boxed::Box::new(
713 <Case as ::treesitter_types::FromNode>::from_node(node, src)?,
714 ))),
715 "case_match" => Ok(Self::CaseMatch(::std::boxed::Box::new(
716 <CaseMatch as ::treesitter_types::FromNode>::from_node(node, src)?,
717 ))),
718 "chained_string" => Ok(Self::ChainedString(::std::boxed::Box::new(
719 <ChainedString as ::treesitter_types::FromNode>::from_node(node, src)?,
720 ))),
721 "character" => Ok(Self::Character(::std::boxed::Box::new(
722 <Character as ::treesitter_types::FromNode>::from_node(node, src)?,
723 ))),
724 "class" => Ok(Self::Class(::std::boxed::Box::new(
725 <Class as ::treesitter_types::FromNode>::from_node(node, src)?,
726 ))),
727 "delimited_symbol" => Ok(Self::DelimitedSymbol(::std::boxed::Box::new(
728 <DelimitedSymbol as ::treesitter_types::FromNode>::from_node(node, src)?,
729 ))),
730 "for" => Ok(Self::For(::std::boxed::Box::new(
731 <For as ::treesitter_types::FromNode>::from_node(node, src)?,
732 ))),
733 "hash" => Ok(Self::Hash(::std::boxed::Box::new(
734 <Hash as ::treesitter_types::FromNode>::from_node(node, src)?,
735 ))),
736 "heredoc_beginning" => Ok(Self::HeredocBeginning(::std::boxed::Box::new(
737 <HeredocBeginning as ::treesitter_types::FromNode>::from_node(node, src)?,
738 ))),
739 "if" => Ok(Self::If(::std::boxed::Box::new(
740 <If as ::treesitter_types::FromNode>::from_node(node, src)?,
741 ))),
742 "lambda" => Ok(Self::Lambda(::std::boxed::Box::new(
743 <Lambda as ::treesitter_types::FromNode>::from_node(node, src)?,
744 ))),
745 "method" => Ok(Self::Method(::std::boxed::Box::new(
746 <Method as ::treesitter_types::FromNode>::from_node(node, src)?,
747 ))),
748 "module" => Ok(Self::Module(::std::boxed::Box::new(
749 <Module as ::treesitter_types::FromNode>::from_node(node, src)?,
750 ))),
751 "next" => Ok(Self::Next(::std::boxed::Box::new(
752 <Next as ::treesitter_types::FromNode>::from_node(node, src)?,
753 ))),
754 "parenthesized_statements" => {
755 Ok(Self::ParenthesizedStatements(::std::boxed::Box::new(
756 <ParenthesizedStatements as ::treesitter_types::FromNode>::from_node(
757 node, src,
758 )?,
759 )))
760 }
761 "redo" => Ok(Self::Redo(::std::boxed::Box::new(
762 <Redo as ::treesitter_types::FromNode>::from_node(node, src)?,
763 ))),
764 "regex" => Ok(Self::Regex(::std::boxed::Box::new(
765 <Regex as ::treesitter_types::FromNode>::from_node(node, src)?,
766 ))),
767 "retry" => Ok(Self::Retry(::std::boxed::Box::new(
768 <Retry as ::treesitter_types::FromNode>::from_node(node, src)?,
769 ))),
770 "return" => Ok(Self::Return(::std::boxed::Box::new(
771 <Return as ::treesitter_types::FromNode>::from_node(node, src)?,
772 ))),
773 "simple_symbol" => Ok(Self::SimpleSymbol(::std::boxed::Box::new(
774 <SimpleSymbol as ::treesitter_types::FromNode>::from_node(node, src)?,
775 ))),
776 "singleton_class" => Ok(Self::SingletonClass(::std::boxed::Box::new(
777 <SingletonClass as ::treesitter_types::FromNode>::from_node(node, src)?,
778 ))),
779 "singleton_method" => Ok(Self::SingletonMethod(::std::boxed::Box::new(
780 <SingletonMethod as ::treesitter_types::FromNode>::from_node(node, src)?,
781 ))),
782 "string" => Ok(Self::String(::std::boxed::Box::new(
783 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
784 ))),
785 "string_array" => Ok(Self::StringArray(::std::boxed::Box::new(
786 <StringArray as ::treesitter_types::FromNode>::from_node(node, src)?,
787 ))),
788 "subshell" => Ok(Self::Subshell(::std::boxed::Box::new(
789 <Subshell as ::treesitter_types::FromNode>::from_node(node, src)?,
790 ))),
791 "symbol_array" => Ok(Self::SymbolArray(::std::boxed::Box::new(
792 <SymbolArray as ::treesitter_types::FromNode>::from_node(node, src)?,
793 ))),
794 "unary" => Ok(Self::Unary(::std::boxed::Box::new(
795 <Unary as ::treesitter_types::FromNode>::from_node(node, src)?,
796 ))),
797 "unless" => Ok(Self::Unless(::std::boxed::Box::new(
798 <Unless as ::treesitter_types::FromNode>::from_node(node, src)?,
799 ))),
800 "until" => Ok(Self::Until(::std::boxed::Box::new(
801 <Until as ::treesitter_types::FromNode>::from_node(node, src)?,
802 ))),
803 "while" => Ok(Self::While(::std::boxed::Box::new(
804 <While as ::treesitter_types::FromNode>::from_node(node, src)?,
805 ))),
806 "yield" => Ok(Self::Yield(::std::boxed::Box::new(
807 <Yield as ::treesitter_types::FromNode>::from_node(node, src)?,
808 ))),
809 _other => {
810 if let Ok(v) = <Lhs as ::treesitter_types::FromNode>::from_node(node, src) {
811 Ok(Self::Lhs(::std::boxed::Box::new(v)))
812 } else {
813 if let Ok(v) =
814 <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src)
815 {
816 Ok(Self::SimpleNumeric(::std::boxed::Box::new(v)))
817 } else {
818 Err(::treesitter_types::ParseError::unexpected_kind(
819 _other, node,
820 ))
821 }
822 }
823 }
824 }
825 }
826}
827impl ::treesitter_types::Spanned for Primary<'_> {
828 fn span(&self) -> ::treesitter_types::Span {
829 match self {
830 Self::Lhs(inner) => inner.span(),
831 Self::SimpleNumeric(inner) => inner.span(),
832 Self::Array(inner) => inner.span(),
833 Self::Begin(inner) => inner.span(),
834 Self::Break(inner) => inner.span(),
835 Self::Call(inner) => inner.span(),
836 Self::Case(inner) => inner.span(),
837 Self::CaseMatch(inner) => inner.span(),
838 Self::ChainedString(inner) => inner.span(),
839 Self::Character(inner) => inner.span(),
840 Self::Class(inner) => inner.span(),
841 Self::DelimitedSymbol(inner) => inner.span(),
842 Self::For(inner) => inner.span(),
843 Self::Hash(inner) => inner.span(),
844 Self::HeredocBeginning(inner) => inner.span(),
845 Self::If(inner) => inner.span(),
846 Self::Lambda(inner) => inner.span(),
847 Self::Method(inner) => inner.span(),
848 Self::Module(inner) => inner.span(),
849 Self::Next(inner) => inner.span(),
850 Self::ParenthesizedStatements(inner) => inner.span(),
851 Self::Redo(inner) => inner.span(),
852 Self::Regex(inner) => inner.span(),
853 Self::Retry(inner) => inner.span(),
854 Self::Return(inner) => inner.span(),
855 Self::SimpleSymbol(inner) => inner.span(),
856 Self::SingletonClass(inner) => inner.span(),
857 Self::SingletonMethod(inner) => inner.span(),
858 Self::String(inner) => inner.span(),
859 Self::StringArray(inner) => inner.span(),
860 Self::Subshell(inner) => inner.span(),
861 Self::SymbolArray(inner) => inner.span(),
862 Self::Unary(inner) => inner.span(),
863 Self::Unless(inner) => inner.span(),
864 Self::Until(inner) => inner.span(),
865 Self::While(inner) => inner.span(),
866 Self::Yield(inner) => inner.span(),
867 }
868 }
869}
870#[derive(Debug, Clone, PartialEq, Eq)]
871pub enum SimpleNumeric<'tree> {
872 Complex(::std::boxed::Box<Complex<'tree>>),
873 Float(::std::boxed::Box<Float<'tree>>),
874 Integer(::std::boxed::Box<Integer<'tree>>),
875 Rational(::std::boxed::Box<Rational<'tree>>),
876}
877impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleNumeric<'tree> {
878 #[allow(clippy::collapsible_else_if)]
879 fn from_node(
880 node: ::tree_sitter::Node<'tree>,
881 src: &'tree [u8],
882 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
883 match node.kind() {
884 "complex" => Ok(Self::Complex(::std::boxed::Box::new(
885 <Complex as ::treesitter_types::FromNode>::from_node(node, src)?,
886 ))),
887 "float" => Ok(Self::Float(::std::boxed::Box::new(
888 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
889 ))),
890 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
891 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
892 ))),
893 "rational" => Ok(Self::Rational(::std::boxed::Box::new(
894 <Rational as ::treesitter_types::FromNode>::from_node(node, src)?,
895 ))),
896 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
897 }
898 }
899}
900impl ::treesitter_types::Spanned for SimpleNumeric<'_> {
901 fn span(&self) -> ::treesitter_types::Span {
902 match self {
903 Self::Complex(inner) => inner.span(),
904 Self::Float(inner) => inner.span(),
905 Self::Integer(inner) => inner.span(),
906 Self::Rational(inner) => inner.span(),
907 }
908 }
909}
910#[derive(Debug, Clone, PartialEq, Eq)]
911pub enum Statement<'tree> {
912 Expression(::std::boxed::Box<Expression<'tree>>),
913 Alias(::std::boxed::Box<Alias<'tree>>),
914 BeginBlock(::std::boxed::Box<BeginBlock<'tree>>),
915 EndBlock(::std::boxed::Box<EndBlock<'tree>>),
916 IfModifier(::std::boxed::Box<IfModifier<'tree>>),
917 RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
918 Undef(::std::boxed::Box<Undef<'tree>>),
919 UnlessModifier(::std::boxed::Box<UnlessModifier<'tree>>),
920 UntilModifier(::std::boxed::Box<UntilModifier<'tree>>),
921 WhileModifier(::std::boxed::Box<WhileModifier<'tree>>),
922}
923impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
924 #[allow(clippy::collapsible_else_if)]
925 fn from_node(
926 node: ::tree_sitter::Node<'tree>,
927 src: &'tree [u8],
928 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
929 match node.kind() {
930 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
931 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
932 ))),
933 "begin_block" => Ok(Self::BeginBlock(::std::boxed::Box::new(
934 <BeginBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
935 ))),
936 "end_block" => Ok(Self::EndBlock(::std::boxed::Box::new(
937 <EndBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
938 ))),
939 "if_modifier" => Ok(Self::IfModifier(::std::boxed::Box::new(
940 <IfModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
941 ))),
942 "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
943 <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
944 ))),
945 "undef" => Ok(Self::Undef(::std::boxed::Box::new(
946 <Undef as ::treesitter_types::FromNode>::from_node(node, src)?,
947 ))),
948 "unless_modifier" => Ok(Self::UnlessModifier(::std::boxed::Box::new(
949 <UnlessModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
950 ))),
951 "until_modifier" => Ok(Self::UntilModifier(::std::boxed::Box::new(
952 <UntilModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
953 ))),
954 "while_modifier" => Ok(Self::WhileModifier(::std::boxed::Box::new(
955 <WhileModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
956 ))),
957 _other => {
958 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
959 Ok(Self::Expression(::std::boxed::Box::new(v)))
960 } else {
961 Err(::treesitter_types::ParseError::unexpected_kind(
962 _other, node,
963 ))
964 }
965 }
966 }
967 }
968}
969impl ::treesitter_types::Spanned for Statement<'_> {
970 fn span(&self) -> ::treesitter_types::Span {
971 match self {
972 Self::Expression(inner) => inner.span(),
973 Self::Alias(inner) => inner.span(),
974 Self::BeginBlock(inner) => inner.span(),
975 Self::EndBlock(inner) => inner.span(),
976 Self::IfModifier(inner) => inner.span(),
977 Self::RescueModifier(inner) => inner.span(),
978 Self::Undef(inner) => inner.span(),
979 Self::UnlessModifier(inner) => inner.span(),
980 Self::UntilModifier(inner) => inner.span(),
981 Self::WhileModifier(inner) => inner.span(),
982 }
983 }
984}
985#[derive(Debug, Clone, PartialEq, Eq)]
986pub enum Variable<'tree> {
987 NonlocalVariable(::std::boxed::Box<NonlocalVariable<'tree>>),
988 Constant(::std::boxed::Box<Constant<'tree>>),
989 Identifier(::std::boxed::Box<Identifier<'tree>>),
990 SelfType(::std::boxed::Box<SelfType<'tree>>),
991 Super(::std::boxed::Box<Super<'tree>>),
992}
993impl<'tree> ::treesitter_types::FromNode<'tree> for Variable<'tree> {
994 #[allow(clippy::collapsible_else_if)]
995 fn from_node(
996 node: ::tree_sitter::Node<'tree>,
997 src: &'tree [u8],
998 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
999 match node.kind() {
1000 "constant" => Ok(Self::Constant(::std::boxed::Box::new(
1001 <Constant as ::treesitter_types::FromNode>::from_node(node, src)?,
1002 ))),
1003 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
1004 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
1005 ))),
1006 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
1007 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
1008 ))),
1009 "super" => Ok(Self::Super(::std::boxed::Box::new(
1010 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
1011 ))),
1012 _other => {
1013 if let Ok(v) =
1014 <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
1015 {
1016 Ok(Self::NonlocalVariable(::std::boxed::Box::new(v)))
1017 } else {
1018 Err(::treesitter_types::ParseError::unexpected_kind(
1019 _other, node,
1020 ))
1021 }
1022 }
1023 }
1024 }
1025}
1026impl ::treesitter_types::Spanned for Variable<'_> {
1027 fn span(&self) -> ::treesitter_types::Span {
1028 match self {
1029 Self::NonlocalVariable(inner) => inner.span(),
1030 Self::Constant(inner) => inner.span(),
1031 Self::Identifier(inner) => inner.span(),
1032 Self::SelfType(inner) => inner.span(),
1033 Self::Super(inner) => inner.span(),
1034 }
1035 }
1036}
1037#[derive(Debug, Clone, PartialEq, Eq)]
1038pub struct Alias<'tree> {
1039 pub span: ::treesitter_types::Span,
1040 pub alias: MethodName<'tree>,
1041 pub name: MethodName<'tree>,
1042}
1043impl<'tree> ::treesitter_types::FromNode<'tree> for Alias<'tree> {
1044 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1045 fn from_node(
1046 node: ::tree_sitter::Node<'tree>,
1047 src: &'tree [u8],
1048 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1049 debug_assert_eq!(node.kind(), "alias");
1050 Ok(Self {
1051 span: ::treesitter_types::Span::from(node),
1052 alias: {
1053 let child = node
1054 .child_by_field_name("alias")
1055 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
1056 <MethodName as ::treesitter_types::FromNode>::from_node(child, src)?
1057 },
1058 name: {
1059 let child = node
1060 .child_by_field_name("name")
1061 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1062 <MethodName as ::treesitter_types::FromNode>::from_node(child, src)?
1063 },
1064 })
1065 }
1066}
1067impl ::treesitter_types::Spanned for Alias<'_> {
1068 fn span(&self) -> ::treesitter_types::Span {
1069 self.span
1070 }
1071}
1072#[derive(Debug, Clone, PartialEq, Eq)]
1073pub struct AlternativePattern<'tree> {
1074 pub span: ::treesitter_types::Span,
1075 pub alternatives: ::std::vec::Vec<PatternExprBasic<'tree>>,
1076}
1077impl<'tree> ::treesitter_types::FromNode<'tree> for AlternativePattern<'tree> {
1078 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1079 fn from_node(
1080 node: ::tree_sitter::Node<'tree>,
1081 src: &'tree [u8],
1082 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1083 debug_assert_eq!(node.kind(), "alternative_pattern");
1084 Ok(Self {
1085 span: ::treesitter_types::Span::from(node),
1086 alternatives: {
1087 let mut cursor = node.walk();
1088 let mut items = ::std::vec::Vec::new();
1089 for child in node.children_by_field_name("alternatives", &mut cursor) {
1090 items.push(
1091 <PatternExprBasic as ::treesitter_types::FromNode>::from_node(child, src)?,
1092 );
1093 }
1094 items
1095 },
1096 })
1097 }
1098}
1099impl ::treesitter_types::Spanned for AlternativePattern<'_> {
1100 fn span(&self) -> ::treesitter_types::Span {
1101 self.span
1102 }
1103}
1104#[derive(Debug, Clone, PartialEq, Eq)]
1105pub struct ArgumentList<'tree> {
1106 pub span: ::treesitter_types::Span,
1107 pub children: ::std::vec::Vec<ArgumentListChildren<'tree>>,
1108}
1109impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
1110 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1111 fn from_node(
1112 node: ::tree_sitter::Node<'tree>,
1113 src: &'tree [u8],
1114 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1115 debug_assert_eq!(node.kind(), "argument_list");
1116 Ok(Self {
1117 span: ::treesitter_types::Span::from(node),
1118 children: {
1119 #[allow(clippy::suspicious_else_formatting)]
1120 let non_field_children = {
1121 let mut cursor = node.walk();
1122 let mut result = ::std::vec::Vec::new();
1123 if cursor.goto_first_child() {
1124 loop {
1125 if cursor.field_name().is_none()
1126 && cursor.node().is_named()
1127 && !cursor.node().is_extra()
1128 {
1129 result.push(cursor.node());
1130 }
1131 if !cursor.goto_next_sibling() {
1132 break;
1133 }
1134 }
1135 }
1136 result
1137 };
1138 let mut items = ::std::vec::Vec::new();
1139 for child in non_field_children {
1140 items.push(
1141 <ArgumentListChildren as ::treesitter_types::FromNode>::from_node(
1142 child, src,
1143 )?,
1144 );
1145 }
1146 items
1147 },
1148 })
1149 }
1150}
1151impl ::treesitter_types::Spanned for ArgumentList<'_> {
1152 fn span(&self) -> ::treesitter_types::Span {
1153 self.span
1154 }
1155}
1156#[derive(Debug, Clone, PartialEq, Eq)]
1157pub struct Array<'tree> {
1158 pub span: ::treesitter_types::Span,
1159 pub children: ::std::vec::Vec<ArrayChildren<'tree>>,
1160}
1161impl<'tree> ::treesitter_types::FromNode<'tree> for Array<'tree> {
1162 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1163 fn from_node(
1164 node: ::tree_sitter::Node<'tree>,
1165 src: &'tree [u8],
1166 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1167 debug_assert_eq!(node.kind(), "array");
1168 Ok(Self {
1169 span: ::treesitter_types::Span::from(node),
1170 children: {
1171 #[allow(clippy::suspicious_else_formatting)]
1172 let non_field_children = {
1173 let mut cursor = node.walk();
1174 let mut result = ::std::vec::Vec::new();
1175 if cursor.goto_first_child() {
1176 loop {
1177 if cursor.field_name().is_none()
1178 && cursor.node().is_named()
1179 && !cursor.node().is_extra()
1180 {
1181 result.push(cursor.node());
1182 }
1183 if !cursor.goto_next_sibling() {
1184 break;
1185 }
1186 }
1187 }
1188 result
1189 };
1190 let mut items = ::std::vec::Vec::new();
1191 for child in non_field_children {
1192 items.push(<ArrayChildren as ::treesitter_types::FromNode>::from_node(
1193 child, src,
1194 )?);
1195 }
1196 items
1197 },
1198 })
1199 }
1200}
1201impl ::treesitter_types::Spanned for Array<'_> {
1202 fn span(&self) -> ::treesitter_types::Span {
1203 self.span
1204 }
1205}
1206#[derive(Debug, Clone, PartialEq, Eq)]
1207pub struct ArrayPattern<'tree> {
1208 pub span: ::treesitter_types::Span,
1209 pub class: ::core::option::Option<PatternConstant<'tree>>,
1210 pub children: ::std::vec::Vec<ArrayPatternChildren<'tree>>,
1211}
1212impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPattern<'tree> {
1213 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1214 fn from_node(
1215 node: ::tree_sitter::Node<'tree>,
1216 src: &'tree [u8],
1217 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1218 debug_assert_eq!(node.kind(), "array_pattern");
1219 Ok(Self {
1220 span: ::treesitter_types::Span::from(node),
1221 class: match node.child_by_field_name("class") {
1222 Some(child) => {
1223 Some(<PatternConstant as ::treesitter_types::FromNode>::from_node(child, src)?)
1224 }
1225 None => None,
1226 },
1227 children: {
1228 #[allow(clippy::suspicious_else_formatting)]
1229 let non_field_children = {
1230 let mut cursor = node.walk();
1231 let mut result = ::std::vec::Vec::new();
1232 if cursor.goto_first_child() {
1233 loop {
1234 if cursor.field_name().is_none()
1235 && cursor.node().is_named()
1236 && !cursor.node().is_extra()
1237 {
1238 result.push(cursor.node());
1239 }
1240 if !cursor.goto_next_sibling() {
1241 break;
1242 }
1243 }
1244 }
1245 result
1246 };
1247 let mut items = ::std::vec::Vec::new();
1248 for child in non_field_children {
1249 items.push(
1250 <ArrayPatternChildren as ::treesitter_types::FromNode>::from_node(
1251 child, src,
1252 )?,
1253 );
1254 }
1255 items
1256 },
1257 })
1258 }
1259}
1260impl ::treesitter_types::Spanned for ArrayPattern<'_> {
1261 fn span(&self) -> ::treesitter_types::Span {
1262 self.span
1263 }
1264}
1265#[derive(Debug, Clone, PartialEq, Eq)]
1266pub struct AsPattern<'tree> {
1267 pub span: ::treesitter_types::Span,
1268 pub name: Identifier<'tree>,
1269 pub value: PatternExpr<'tree>,
1270}
1271impl<'tree> ::treesitter_types::FromNode<'tree> for AsPattern<'tree> {
1272 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1273 fn from_node(
1274 node: ::tree_sitter::Node<'tree>,
1275 src: &'tree [u8],
1276 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1277 debug_assert_eq!(node.kind(), "as_pattern");
1278 Ok(Self {
1279 span: ::treesitter_types::Span::from(node),
1280 name: {
1281 let child = node
1282 .child_by_field_name("name")
1283 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1284 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
1285 },
1286 value: {
1287 let child = node
1288 .child_by_field_name("value")
1289 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1290 <PatternExpr as ::treesitter_types::FromNode>::from_node(child, src)?
1291 },
1292 })
1293 }
1294}
1295impl ::treesitter_types::Spanned for AsPattern<'_> {
1296 fn span(&self) -> ::treesitter_types::Span {
1297 self.span
1298 }
1299}
1300#[derive(Debug, Clone, PartialEq, Eq)]
1301pub struct Assignment<'tree> {
1302 pub span: ::treesitter_types::Span,
1303 pub left: AssignmentLeft<'tree>,
1304 pub right: AssignmentRight<'tree>,
1305}
1306impl<'tree> ::treesitter_types::FromNode<'tree> for Assignment<'tree> {
1307 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1308 fn from_node(
1309 node: ::tree_sitter::Node<'tree>,
1310 src: &'tree [u8],
1311 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1312 debug_assert_eq!(node.kind(), "assignment");
1313 Ok(Self {
1314 span: ::treesitter_types::Span::from(node),
1315 left: {
1316 let child = node
1317 .child_by_field_name("left")
1318 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1319 <AssignmentLeft as ::treesitter_types::FromNode>::from_node(child, src)?
1320 },
1321 right: {
1322 let child = node
1323 .child_by_field_name("right")
1324 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1325 <AssignmentRight as ::treesitter_types::FromNode>::from_node(child, src)?
1326 },
1327 })
1328 }
1329}
1330impl ::treesitter_types::Spanned for Assignment<'_> {
1331 fn span(&self) -> ::treesitter_types::Span {
1332 self.span
1333 }
1334}
1335#[derive(Debug, Clone, PartialEq, Eq)]
1336pub struct BareString<'tree> {
1337 pub span: ::treesitter_types::Span,
1338 pub children: ::std::vec::Vec<BareStringChildren<'tree>>,
1339}
1340impl<'tree> ::treesitter_types::FromNode<'tree> for BareString<'tree> {
1341 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1342 fn from_node(
1343 node: ::tree_sitter::Node<'tree>,
1344 src: &'tree [u8],
1345 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1346 debug_assert_eq!(node.kind(), "bare_string");
1347 Ok(Self {
1348 span: ::treesitter_types::Span::from(node),
1349 children: {
1350 #[allow(clippy::suspicious_else_formatting)]
1351 let non_field_children = {
1352 let mut cursor = node.walk();
1353 let mut result = ::std::vec::Vec::new();
1354 if cursor.goto_first_child() {
1355 loop {
1356 if cursor.field_name().is_none()
1357 && cursor.node().is_named()
1358 && !cursor.node().is_extra()
1359 {
1360 result.push(cursor.node());
1361 }
1362 if !cursor.goto_next_sibling() {
1363 break;
1364 }
1365 }
1366 }
1367 result
1368 };
1369 let mut items = ::std::vec::Vec::new();
1370 for child in non_field_children {
1371 items.push(
1372 <BareStringChildren as ::treesitter_types::FromNode>::from_node(
1373 child, src,
1374 )?,
1375 );
1376 }
1377 items
1378 },
1379 })
1380 }
1381}
1382impl ::treesitter_types::Spanned for BareString<'_> {
1383 fn span(&self) -> ::treesitter_types::Span {
1384 self.span
1385 }
1386}
1387#[derive(Debug, Clone, PartialEq, Eq)]
1388pub struct BareSymbol<'tree> {
1389 pub span: ::treesitter_types::Span,
1390 pub children: ::std::vec::Vec<BareSymbolChildren<'tree>>,
1391}
1392impl<'tree> ::treesitter_types::FromNode<'tree> for BareSymbol<'tree> {
1393 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1394 fn from_node(
1395 node: ::tree_sitter::Node<'tree>,
1396 src: &'tree [u8],
1397 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1398 debug_assert_eq!(node.kind(), "bare_symbol");
1399 Ok(Self {
1400 span: ::treesitter_types::Span::from(node),
1401 children: {
1402 #[allow(clippy::suspicious_else_formatting)]
1403 let non_field_children = {
1404 let mut cursor = node.walk();
1405 let mut result = ::std::vec::Vec::new();
1406 if cursor.goto_first_child() {
1407 loop {
1408 if cursor.field_name().is_none()
1409 && cursor.node().is_named()
1410 && !cursor.node().is_extra()
1411 {
1412 result.push(cursor.node());
1413 }
1414 if !cursor.goto_next_sibling() {
1415 break;
1416 }
1417 }
1418 }
1419 result
1420 };
1421 let mut items = ::std::vec::Vec::new();
1422 for child in non_field_children {
1423 items.push(
1424 <BareSymbolChildren as ::treesitter_types::FromNode>::from_node(
1425 child, src,
1426 )?,
1427 );
1428 }
1429 items
1430 },
1431 })
1432 }
1433}
1434impl ::treesitter_types::Spanned for BareSymbol<'_> {
1435 fn span(&self) -> ::treesitter_types::Span {
1436 self.span
1437 }
1438}
1439#[derive(Debug, Clone, PartialEq, Eq)]
1440pub struct Begin<'tree> {
1441 pub span: ::treesitter_types::Span,
1442 pub children: ::std::vec::Vec<BeginChildren<'tree>>,
1443}
1444impl<'tree> ::treesitter_types::FromNode<'tree> for Begin<'tree> {
1445 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1446 fn from_node(
1447 node: ::tree_sitter::Node<'tree>,
1448 src: &'tree [u8],
1449 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1450 debug_assert_eq!(node.kind(), "begin");
1451 Ok(Self {
1452 span: ::treesitter_types::Span::from(node),
1453 children: {
1454 #[allow(clippy::suspicious_else_formatting)]
1455 let non_field_children = {
1456 let mut cursor = node.walk();
1457 let mut result = ::std::vec::Vec::new();
1458 if cursor.goto_first_child() {
1459 loop {
1460 if cursor.field_name().is_none()
1461 && cursor.node().is_named()
1462 && !cursor.node().is_extra()
1463 {
1464 result.push(cursor.node());
1465 }
1466 if !cursor.goto_next_sibling() {
1467 break;
1468 }
1469 }
1470 }
1471 result
1472 };
1473 let mut items = ::std::vec::Vec::new();
1474 for child in non_field_children {
1475 items.push(<BeginChildren as ::treesitter_types::FromNode>::from_node(
1476 child, src,
1477 )?);
1478 }
1479 items
1480 },
1481 })
1482 }
1483}
1484impl ::treesitter_types::Spanned for Begin<'_> {
1485 fn span(&self) -> ::treesitter_types::Span {
1486 self.span
1487 }
1488}
1489#[derive(Debug, Clone, PartialEq, Eq)]
1490pub struct BeginBlock<'tree> {
1491 pub span: ::treesitter_types::Span,
1492 pub children: ::std::vec::Vec<BeginBlockChildren<'tree>>,
1493}
1494impl<'tree> ::treesitter_types::FromNode<'tree> for BeginBlock<'tree> {
1495 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1496 fn from_node(
1497 node: ::tree_sitter::Node<'tree>,
1498 src: &'tree [u8],
1499 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1500 debug_assert_eq!(node.kind(), "begin_block");
1501 Ok(Self {
1502 span: ::treesitter_types::Span::from(node),
1503 children: {
1504 #[allow(clippy::suspicious_else_formatting)]
1505 let non_field_children = {
1506 let mut cursor = node.walk();
1507 let mut result = ::std::vec::Vec::new();
1508 if cursor.goto_first_child() {
1509 loop {
1510 if cursor.field_name().is_none()
1511 && cursor.node().is_named()
1512 && !cursor.node().is_extra()
1513 {
1514 result.push(cursor.node());
1515 }
1516 if !cursor.goto_next_sibling() {
1517 break;
1518 }
1519 }
1520 }
1521 result
1522 };
1523 let mut items = ::std::vec::Vec::new();
1524 for child in non_field_children {
1525 items.push(
1526 <BeginBlockChildren as ::treesitter_types::FromNode>::from_node(
1527 child, src,
1528 )?,
1529 );
1530 }
1531 items
1532 },
1533 })
1534 }
1535}
1536impl ::treesitter_types::Spanned for BeginBlock<'_> {
1537 fn span(&self) -> ::treesitter_types::Span {
1538 self.span
1539 }
1540}
1541#[derive(Debug, Clone, PartialEq, Eq)]
1542pub struct Binary<'tree> {
1543 pub span: ::treesitter_types::Span,
1544 pub left: BinaryLeft<'tree>,
1545 pub operator: BinaryOperator,
1546 pub right: Expression<'tree>,
1547}
1548impl<'tree> ::treesitter_types::FromNode<'tree> for Binary<'tree> {
1549 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1550 fn from_node(
1551 node: ::tree_sitter::Node<'tree>,
1552 src: &'tree [u8],
1553 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1554 debug_assert_eq!(node.kind(), "binary");
1555 Ok(Self {
1556 span: ::treesitter_types::Span::from(node),
1557 left: {
1558 let child = node
1559 .child_by_field_name("left")
1560 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1561 <BinaryLeft as ::treesitter_types::FromNode>::from_node(child, src)?
1562 },
1563 operator: {
1564 let child = node.child_by_field_name("operator").ok_or_else(|| {
1565 ::treesitter_types::ParseError::missing_field("operator", node)
1566 })?;
1567 <BinaryOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1568 },
1569 right: {
1570 let child = node
1571 .child_by_field_name("right")
1572 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1573 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1574 },
1575 })
1576 }
1577}
1578impl ::treesitter_types::Spanned for Binary<'_> {
1579 fn span(&self) -> ::treesitter_types::Span {
1580 self.span
1581 }
1582}
1583#[derive(Debug, Clone, PartialEq, Eq)]
1584pub struct Block<'tree> {
1585 pub span: ::treesitter_types::Span,
1586 pub body: ::core::option::Option<BlockBody<'tree>>,
1587 pub parameters: ::core::option::Option<BlockParameters<'tree>>,
1588}
1589impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
1590 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1591 fn from_node(
1592 node: ::tree_sitter::Node<'tree>,
1593 src: &'tree [u8],
1594 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1595 debug_assert_eq!(node.kind(), "block");
1596 Ok(Self {
1597 span: ::treesitter_types::Span::from(node),
1598 body: match node.child_by_field_name("body") {
1599 Some(child) => Some(<BlockBody as ::treesitter_types::FromNode>::from_node(
1600 child, src,
1601 )?),
1602 None => None,
1603 },
1604 parameters: match node.child_by_field_name("parameters") {
1605 Some(child) => {
1606 Some(<BlockParameters as ::treesitter_types::FromNode>::from_node(child, src)?)
1607 }
1608 None => None,
1609 },
1610 })
1611 }
1612}
1613impl ::treesitter_types::Spanned for Block<'_> {
1614 fn span(&self) -> ::treesitter_types::Span {
1615 self.span
1616 }
1617}
1618#[derive(Debug, Clone, PartialEq, Eq)]
1619pub struct BlockArgument<'tree> {
1620 pub span: ::treesitter_types::Span,
1621 pub children: ::core::option::Option<Arg<'tree>>,
1622}
1623impl<'tree> ::treesitter_types::FromNode<'tree> for BlockArgument<'tree> {
1624 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1625 fn from_node(
1626 node: ::tree_sitter::Node<'tree>,
1627 src: &'tree [u8],
1628 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1629 debug_assert_eq!(node.kind(), "block_argument");
1630 Ok(Self {
1631 span: ::treesitter_types::Span::from(node),
1632 children: {
1633 #[allow(clippy::suspicious_else_formatting)]
1634 let non_field_children = {
1635 let mut cursor = node.walk();
1636 let mut result = ::std::vec::Vec::new();
1637 if cursor.goto_first_child() {
1638 loop {
1639 if cursor.field_name().is_none()
1640 && cursor.node().is_named()
1641 && !cursor.node().is_extra()
1642 {
1643 result.push(cursor.node());
1644 }
1645 if !cursor.goto_next_sibling() {
1646 break;
1647 }
1648 }
1649 }
1650 result
1651 };
1652 match non_field_children.first() {
1653 Some(&child) => Some(<Arg as ::treesitter_types::FromNode>::from_node(
1654 child, src,
1655 )?),
1656 None => None,
1657 }
1658 },
1659 })
1660 }
1661}
1662impl ::treesitter_types::Spanned for BlockArgument<'_> {
1663 fn span(&self) -> ::treesitter_types::Span {
1664 self.span
1665 }
1666}
1667#[derive(Debug, Clone, PartialEq, Eq)]
1668pub struct BlockBody<'tree> {
1669 pub span: ::treesitter_types::Span,
1670 pub children: ::std::vec::Vec<BlockBodyChildren<'tree>>,
1671}
1672impl<'tree> ::treesitter_types::FromNode<'tree> for BlockBody<'tree> {
1673 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1674 fn from_node(
1675 node: ::tree_sitter::Node<'tree>,
1676 src: &'tree [u8],
1677 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1678 debug_assert_eq!(node.kind(), "block_body");
1679 Ok(Self {
1680 span: ::treesitter_types::Span::from(node),
1681 children: {
1682 #[allow(clippy::suspicious_else_formatting)]
1683 let non_field_children = {
1684 let mut cursor = node.walk();
1685 let mut result = ::std::vec::Vec::new();
1686 if cursor.goto_first_child() {
1687 loop {
1688 if cursor.field_name().is_none()
1689 && cursor.node().is_named()
1690 && !cursor.node().is_extra()
1691 {
1692 result.push(cursor.node());
1693 }
1694 if !cursor.goto_next_sibling() {
1695 break;
1696 }
1697 }
1698 }
1699 result
1700 };
1701 let mut items = ::std::vec::Vec::new();
1702 for child in non_field_children {
1703 items.push(
1704 <BlockBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
1705 );
1706 }
1707 items
1708 },
1709 })
1710 }
1711}
1712impl ::treesitter_types::Spanned for BlockBody<'_> {
1713 fn span(&self) -> ::treesitter_types::Span {
1714 self.span
1715 }
1716}
1717#[derive(Debug, Clone, PartialEq, Eq)]
1718pub struct BlockParameter<'tree> {
1719 pub span: ::treesitter_types::Span,
1720 pub name: ::core::option::Option<Identifier<'tree>>,
1721}
1722impl<'tree> ::treesitter_types::FromNode<'tree> for BlockParameter<'tree> {
1723 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1724 fn from_node(
1725 node: ::tree_sitter::Node<'tree>,
1726 src: &'tree [u8],
1727 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1728 debug_assert_eq!(node.kind(), "block_parameter");
1729 Ok(Self {
1730 span: ::treesitter_types::Span::from(node),
1731 name: match node.child_by_field_name("name") {
1732 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
1733 child, src,
1734 )?),
1735 None => None,
1736 },
1737 })
1738 }
1739}
1740impl ::treesitter_types::Spanned for BlockParameter<'_> {
1741 fn span(&self) -> ::treesitter_types::Span {
1742 self.span
1743 }
1744}
1745#[derive(Debug, Clone, PartialEq, Eq)]
1746pub struct BlockParameters<'tree> {
1747 pub span: ::treesitter_types::Span,
1748 pub locals: ::std::vec::Vec<Identifier<'tree>>,
1749 pub children: ::std::vec::Vec<BlockParametersChildren<'tree>>,
1750}
1751impl<'tree> ::treesitter_types::FromNode<'tree> for BlockParameters<'tree> {
1752 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1753 fn from_node(
1754 node: ::tree_sitter::Node<'tree>,
1755 src: &'tree [u8],
1756 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1757 debug_assert_eq!(node.kind(), "block_parameters");
1758 Ok(Self {
1759 span: ::treesitter_types::Span::from(node),
1760 locals: {
1761 let mut cursor = node.walk();
1762 let mut items = ::std::vec::Vec::new();
1763 for child in node.children_by_field_name("locals", &mut cursor) {
1764 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
1765 child, src,
1766 )?);
1767 }
1768 items
1769 },
1770 children: {
1771 #[allow(clippy::suspicious_else_formatting)]
1772 let non_field_children = {
1773 let mut cursor = node.walk();
1774 let mut result = ::std::vec::Vec::new();
1775 if cursor.goto_first_child() {
1776 loop {
1777 if cursor.field_name().is_none()
1778 && cursor.node().is_named()
1779 && !cursor.node().is_extra()
1780 {
1781 result.push(cursor.node());
1782 }
1783 if !cursor.goto_next_sibling() {
1784 break;
1785 }
1786 }
1787 }
1788 result
1789 };
1790 let mut items = ::std::vec::Vec::new();
1791 for child in non_field_children {
1792 items.push(
1793 <BlockParametersChildren as ::treesitter_types::FromNode>::from_node(
1794 child, src,
1795 )?,
1796 );
1797 }
1798 items
1799 },
1800 })
1801 }
1802}
1803impl ::treesitter_types::Spanned for BlockParameters<'_> {
1804 fn span(&self) -> ::treesitter_types::Span {
1805 self.span
1806 }
1807}
1808#[derive(Debug, Clone, PartialEq, Eq)]
1809pub struct BodyStatement<'tree> {
1810 pub span: ::treesitter_types::Span,
1811 pub children: ::std::vec::Vec<BodyStatementChildren<'tree>>,
1812}
1813impl<'tree> ::treesitter_types::FromNode<'tree> for BodyStatement<'tree> {
1814 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1815 fn from_node(
1816 node: ::tree_sitter::Node<'tree>,
1817 src: &'tree [u8],
1818 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1819 debug_assert_eq!(node.kind(), "body_statement");
1820 Ok(Self {
1821 span: ::treesitter_types::Span::from(node),
1822 children: {
1823 #[allow(clippy::suspicious_else_formatting)]
1824 let non_field_children = {
1825 let mut cursor = node.walk();
1826 let mut result = ::std::vec::Vec::new();
1827 if cursor.goto_first_child() {
1828 loop {
1829 if cursor.field_name().is_none()
1830 && cursor.node().is_named()
1831 && !cursor.node().is_extra()
1832 {
1833 result.push(cursor.node());
1834 }
1835 if !cursor.goto_next_sibling() {
1836 break;
1837 }
1838 }
1839 }
1840 result
1841 };
1842 let mut items = ::std::vec::Vec::new();
1843 for child in non_field_children {
1844 items.push(
1845 <BodyStatementChildren as ::treesitter_types::FromNode>::from_node(
1846 child, src,
1847 )?,
1848 );
1849 }
1850 items
1851 },
1852 })
1853 }
1854}
1855impl ::treesitter_types::Spanned for BodyStatement<'_> {
1856 fn span(&self) -> ::treesitter_types::Span {
1857 self.span
1858 }
1859}
1860#[derive(Debug, Clone, PartialEq, Eq)]
1861pub struct Break<'tree> {
1862 pub span: ::treesitter_types::Span,
1863 pub children: ::core::option::Option<ArgumentList<'tree>>,
1864}
1865impl<'tree> ::treesitter_types::FromNode<'tree> for Break<'tree> {
1866 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1867 fn from_node(
1868 node: ::tree_sitter::Node<'tree>,
1869 src: &'tree [u8],
1870 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1871 debug_assert_eq!(node.kind(), "break");
1872 Ok(Self {
1873 span: ::treesitter_types::Span::from(node),
1874 children: {
1875 #[allow(clippy::suspicious_else_formatting)]
1876 let non_field_children = {
1877 let mut cursor = node.walk();
1878 let mut result = ::std::vec::Vec::new();
1879 if cursor.goto_first_child() {
1880 loop {
1881 if cursor.field_name().is_none()
1882 && cursor.node().is_named()
1883 && !cursor.node().is_extra()
1884 {
1885 result.push(cursor.node());
1886 }
1887 if !cursor.goto_next_sibling() {
1888 break;
1889 }
1890 }
1891 }
1892 result
1893 };
1894 match non_field_children.first() {
1895 Some(&child) => Some(
1896 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?,
1897 ),
1898 None => None,
1899 }
1900 },
1901 })
1902 }
1903}
1904impl ::treesitter_types::Spanned for Break<'_> {
1905 fn span(&self) -> ::treesitter_types::Span {
1906 self.span
1907 }
1908}
1909#[derive(Debug, Clone, PartialEq, Eq)]
1910pub struct Call<'tree> {
1911 pub span: ::treesitter_types::Span,
1912 pub arguments: ::core::option::Option<ArgumentList<'tree>>,
1913 pub block: ::core::option::Option<CallBlock<'tree>>,
1914 pub method: ::core::option::Option<CallMethod<'tree>>,
1915 pub operator: ::core::option::Option<CallOperator>,
1916 pub receiver: ::core::option::Option<Primary<'tree>>,
1917}
1918impl<'tree> ::treesitter_types::FromNode<'tree> for Call<'tree> {
1919 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1920 fn from_node(
1921 node: ::tree_sitter::Node<'tree>,
1922 src: &'tree [u8],
1923 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1924 debug_assert_eq!(node.kind(), "call");
1925 Ok(Self {
1926 span: ::treesitter_types::Span::from(node),
1927 arguments: match node.child_by_field_name("arguments") {
1928 Some(child) => Some(<ArgumentList as ::treesitter_types::FromNode>::from_node(
1929 child, src,
1930 )?),
1931 None => None,
1932 },
1933 block: match node.child_by_field_name("block") {
1934 Some(child) => Some(<CallBlock as ::treesitter_types::FromNode>::from_node(
1935 child, src,
1936 )?),
1937 None => None,
1938 },
1939 method: match node.child_by_field_name("method") {
1940 Some(child) => Some(<CallMethod as ::treesitter_types::FromNode>::from_node(
1941 child, src,
1942 )?),
1943 None => None,
1944 },
1945 operator: match node.child_by_field_name("operator") {
1946 Some(child) => Some(<CallOperator as ::treesitter_types::FromNode>::from_node(
1947 child, src,
1948 )?),
1949 None => None,
1950 },
1951 receiver: match node.child_by_field_name("receiver") {
1952 Some(child) => Some(<Primary as ::treesitter_types::FromNode>::from_node(
1953 child, src,
1954 )?),
1955 None => None,
1956 },
1957 })
1958 }
1959}
1960impl ::treesitter_types::Spanned for Call<'_> {
1961 fn span(&self) -> ::treesitter_types::Span {
1962 self.span
1963 }
1964}
1965#[derive(Debug, Clone, PartialEq, Eq)]
1966pub struct Case<'tree> {
1967 pub span: ::treesitter_types::Span,
1968 pub value: ::core::option::Option<Statement<'tree>>,
1969 pub children: ::std::vec::Vec<CaseChildren<'tree>>,
1970}
1971impl<'tree> ::treesitter_types::FromNode<'tree> for Case<'tree> {
1972 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1973 fn from_node(
1974 node: ::tree_sitter::Node<'tree>,
1975 src: &'tree [u8],
1976 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1977 debug_assert_eq!(node.kind(), "case");
1978 Ok(Self {
1979 span: ::treesitter_types::Span::from(node),
1980 value: match node.child_by_field_name("value") {
1981 Some(child) => Some(<Statement as ::treesitter_types::FromNode>::from_node(
1982 child, src,
1983 )?),
1984 None => None,
1985 },
1986 children: {
1987 #[allow(clippy::suspicious_else_formatting)]
1988 let non_field_children = {
1989 let mut cursor = node.walk();
1990 let mut result = ::std::vec::Vec::new();
1991 if cursor.goto_first_child() {
1992 loop {
1993 if cursor.field_name().is_none()
1994 && cursor.node().is_named()
1995 && !cursor.node().is_extra()
1996 {
1997 result.push(cursor.node());
1998 }
1999 if !cursor.goto_next_sibling() {
2000 break;
2001 }
2002 }
2003 }
2004 result
2005 };
2006 let mut items = ::std::vec::Vec::new();
2007 for child in non_field_children {
2008 items.push(<CaseChildren as ::treesitter_types::FromNode>::from_node(
2009 child, src,
2010 )?);
2011 }
2012 items
2013 },
2014 })
2015 }
2016}
2017impl ::treesitter_types::Spanned for Case<'_> {
2018 fn span(&self) -> ::treesitter_types::Span {
2019 self.span
2020 }
2021}
2022#[derive(Debug, Clone, PartialEq, Eq)]
2023pub struct CaseMatch<'tree> {
2024 pub span: ::treesitter_types::Span,
2025 pub clauses: ::std::vec::Vec<InClause<'tree>>,
2026 pub r#else: ::core::option::Option<Else<'tree>>,
2027 pub value: Statement<'tree>,
2028}
2029impl<'tree> ::treesitter_types::FromNode<'tree> for CaseMatch<'tree> {
2030 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2031 fn from_node(
2032 node: ::tree_sitter::Node<'tree>,
2033 src: &'tree [u8],
2034 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2035 debug_assert_eq!(node.kind(), "case_match");
2036 Ok(Self {
2037 span: ::treesitter_types::Span::from(node),
2038 clauses: {
2039 let mut cursor = node.walk();
2040 let mut items = ::std::vec::Vec::new();
2041 for child in node.children_by_field_name("clauses", &mut cursor) {
2042 items.push(<InClause as ::treesitter_types::FromNode>::from_node(
2043 child, src,
2044 )?);
2045 }
2046 items
2047 },
2048 r#else: match node.child_by_field_name("else") {
2049 Some(child) => Some(<Else as ::treesitter_types::FromNode>::from_node(
2050 child, src,
2051 )?),
2052 None => None,
2053 },
2054 value: {
2055 let child = node
2056 .child_by_field_name("value")
2057 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2058 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2059 },
2060 })
2061 }
2062}
2063impl ::treesitter_types::Spanned for CaseMatch<'_> {
2064 fn span(&self) -> ::treesitter_types::Span {
2065 self.span
2066 }
2067}
2068#[derive(Debug, Clone, PartialEq, Eq)]
2069pub struct ChainedString<'tree> {
2070 pub span: ::treesitter_types::Span,
2071 pub children: ::std::vec::Vec<String<'tree>>,
2072}
2073impl<'tree> ::treesitter_types::FromNode<'tree> for ChainedString<'tree> {
2074 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2075 fn from_node(
2076 node: ::tree_sitter::Node<'tree>,
2077 src: &'tree [u8],
2078 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2079 debug_assert_eq!(node.kind(), "chained_string");
2080 Ok(Self {
2081 span: ::treesitter_types::Span::from(node),
2082 children: {
2083 #[allow(clippy::suspicious_else_formatting)]
2084 let non_field_children = {
2085 let mut cursor = node.walk();
2086 let mut result = ::std::vec::Vec::new();
2087 if cursor.goto_first_child() {
2088 loop {
2089 if cursor.field_name().is_none()
2090 && cursor.node().is_named()
2091 && !cursor.node().is_extra()
2092 {
2093 result.push(cursor.node());
2094 }
2095 if !cursor.goto_next_sibling() {
2096 break;
2097 }
2098 }
2099 }
2100 result
2101 };
2102 let mut items = ::std::vec::Vec::new();
2103 for child in non_field_children {
2104 items.push(<String as ::treesitter_types::FromNode>::from_node(
2105 child, src,
2106 )?);
2107 }
2108 items
2109 },
2110 })
2111 }
2112}
2113impl ::treesitter_types::Spanned for ChainedString<'_> {
2114 fn span(&self) -> ::treesitter_types::Span {
2115 self.span
2116 }
2117}
2118#[derive(Debug, Clone, PartialEq, Eq)]
2119pub struct Class<'tree> {
2120 pub span: ::treesitter_types::Span,
2121 pub body: ::core::option::Option<BodyStatement<'tree>>,
2122 pub name: ClassName<'tree>,
2123 pub superclass: ::core::option::Option<Superclass<'tree>>,
2124}
2125impl<'tree> ::treesitter_types::FromNode<'tree> for Class<'tree> {
2126 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2127 fn from_node(
2128 node: ::tree_sitter::Node<'tree>,
2129 src: &'tree [u8],
2130 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2131 debug_assert_eq!(node.kind(), "class");
2132 Ok(Self {
2133 span: ::treesitter_types::Span::from(node),
2134 body: match node.child_by_field_name("body") {
2135 Some(child) => Some(<BodyStatement as ::treesitter_types::FromNode>::from_node(
2136 child, src,
2137 )?),
2138 None => None,
2139 },
2140 name: {
2141 let child = node
2142 .child_by_field_name("name")
2143 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2144 <ClassName as ::treesitter_types::FromNode>::from_node(child, src)?
2145 },
2146 superclass: match node.child_by_field_name("superclass") {
2147 Some(child) => Some(<Superclass as ::treesitter_types::FromNode>::from_node(
2148 child, src,
2149 )?),
2150 None => None,
2151 },
2152 })
2153 }
2154}
2155impl ::treesitter_types::Spanned for Class<'_> {
2156 fn span(&self) -> ::treesitter_types::Span {
2157 self.span
2158 }
2159}
2160#[derive(Debug, Clone, PartialEq, Eq)]
2161pub struct Complex<'tree> {
2162 pub span: ::treesitter_types::Span,
2163 pub children: ComplexChildren<'tree>,
2164}
2165impl<'tree> ::treesitter_types::FromNode<'tree> for Complex<'tree> {
2166 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2167 fn from_node(
2168 node: ::tree_sitter::Node<'tree>,
2169 src: &'tree [u8],
2170 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2171 debug_assert_eq!(node.kind(), "complex");
2172 Ok(Self {
2173 span: ::treesitter_types::Span::from(node),
2174 children: {
2175 #[allow(clippy::suspicious_else_formatting)]
2176 let non_field_children = {
2177 let mut cursor = node.walk();
2178 let mut result = ::std::vec::Vec::new();
2179 if cursor.goto_first_child() {
2180 loop {
2181 if cursor.field_name().is_none()
2182 && cursor.node().is_named()
2183 && !cursor.node().is_extra()
2184 {
2185 result.push(cursor.node());
2186 }
2187 if !cursor.goto_next_sibling() {
2188 break;
2189 }
2190 }
2191 }
2192 result
2193 };
2194 let child = if let Some(&c) = non_field_children.first() {
2195 c
2196 } else {
2197 let mut fallback_cursor = node.walk();
2198 let mut fallback_child = None;
2199 if fallback_cursor.goto_first_child() {
2200 loop {
2201 if fallback_cursor.field_name().is_none()
2202 && !fallback_cursor.node().is_extra()
2203 {
2204 let candidate = fallback_cursor.node();
2205 #[allow(clippy::needless_question_mark)]
2206 if (|| -> ::core::result::Result<
2207 _,
2208 ::treesitter_types::ParseError,
2209 > {
2210 let child = candidate;
2211 Ok(
2212 <ComplexChildren as ::treesitter_types::FromNode>::from_node(
2213 child,
2214 src,
2215 )?,
2216 )
2217 })()
2218 .is_ok()
2219 {
2220 fallback_child = Some(candidate);
2221 break;
2222 }
2223 }
2224 if !fallback_cursor.goto_next_sibling() {
2225 break;
2226 }
2227 }
2228 }
2229 if fallback_child.is_none() {
2230 let mut cursor2 = node.walk();
2231 if cursor2.goto_first_child() {
2232 loop {
2233 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2234 let candidate = cursor2.node();
2235 #[allow(clippy::needless_question_mark)]
2236 if (|| -> ::core::result::Result<
2237 _,
2238 ::treesitter_types::ParseError,
2239 > {
2240 let child = candidate;
2241 Ok(
2242 <ComplexChildren as ::treesitter_types::FromNode>::from_node(
2243 child,
2244 src,
2245 )?,
2246 )
2247 })()
2248 .is_ok()
2249 {
2250 fallback_child = Some(candidate);
2251 break;
2252 }
2253 }
2254 if !cursor2.goto_next_sibling() {
2255 break;
2256 }
2257 }
2258 }
2259 }
2260 fallback_child.ok_or_else(|| {
2261 ::treesitter_types::ParseError::missing_field("children", node)
2262 })?
2263 };
2264 <ComplexChildren as ::treesitter_types::FromNode>::from_node(child, src)?
2265 },
2266 })
2267 }
2268}
2269impl ::treesitter_types::Spanned for Complex<'_> {
2270 fn span(&self) -> ::treesitter_types::Span {
2271 self.span
2272 }
2273}
2274#[derive(Debug, Clone, PartialEq, Eq)]
2275pub struct Conditional<'tree> {
2276 pub span: ::treesitter_types::Span,
2277 pub alternative: Arg<'tree>,
2278 pub condition: Arg<'tree>,
2279 pub consequence: Arg<'tree>,
2280}
2281impl<'tree> ::treesitter_types::FromNode<'tree> for Conditional<'tree> {
2282 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2283 fn from_node(
2284 node: ::tree_sitter::Node<'tree>,
2285 src: &'tree [u8],
2286 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2287 debug_assert_eq!(node.kind(), "conditional");
2288 Ok(Self {
2289 span: ::treesitter_types::Span::from(node),
2290 alternative: {
2291 let child = node.child_by_field_name("alternative").ok_or_else(|| {
2292 ::treesitter_types::ParseError::missing_field("alternative", node)
2293 })?;
2294 <Arg as ::treesitter_types::FromNode>::from_node(child, src)?
2295 },
2296 condition: {
2297 let child = node.child_by_field_name("condition").ok_or_else(|| {
2298 ::treesitter_types::ParseError::missing_field("condition", node)
2299 })?;
2300 <Arg as ::treesitter_types::FromNode>::from_node(child, src)?
2301 },
2302 consequence: {
2303 let child = node.child_by_field_name("consequence").ok_or_else(|| {
2304 ::treesitter_types::ParseError::missing_field("consequence", node)
2305 })?;
2306 <Arg as ::treesitter_types::FromNode>::from_node(child, src)?
2307 },
2308 })
2309 }
2310}
2311impl ::treesitter_types::Spanned for Conditional<'_> {
2312 fn span(&self) -> ::treesitter_types::Span {
2313 self.span
2314 }
2315}
2316#[derive(Debug, Clone, PartialEq, Eq)]
2317pub struct Constant<'tree> {
2318 pub span: ::treesitter_types::Span,
2319 text: &'tree str,
2320}
2321impl<'tree> ::treesitter_types::FromNode<'tree> for Constant<'tree> {
2322 fn from_node(
2323 node: ::tree_sitter::Node<'tree>,
2324 src: &'tree [u8],
2325 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2326 debug_assert_eq!(node.kind(), "constant");
2327 Ok(Self {
2328 span: ::treesitter_types::Span::from(node),
2329 text: node.utf8_text(src)?,
2330 })
2331 }
2332}
2333impl<'tree> ::treesitter_types::LeafNode<'tree> for Constant<'tree> {
2334 fn text(&self) -> &'tree str {
2335 self.text
2336 }
2337}
2338impl ::treesitter_types::Spanned for Constant<'_> {
2339 fn span(&self) -> ::treesitter_types::Span {
2340 self.span
2341 }
2342}
2343#[derive(Debug, Clone, PartialEq, Eq)]
2344pub struct DelimitedSymbol<'tree> {
2345 pub span: ::treesitter_types::Span,
2346 pub children: ::std::vec::Vec<DelimitedSymbolChildren<'tree>>,
2347}
2348impl<'tree> ::treesitter_types::FromNode<'tree> for DelimitedSymbol<'tree> {
2349 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2350 fn from_node(
2351 node: ::tree_sitter::Node<'tree>,
2352 src: &'tree [u8],
2353 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2354 debug_assert_eq!(node.kind(), "delimited_symbol");
2355 Ok(Self {
2356 span: ::treesitter_types::Span::from(node),
2357 children: {
2358 #[allow(clippy::suspicious_else_formatting)]
2359 let non_field_children = {
2360 let mut cursor = node.walk();
2361 let mut result = ::std::vec::Vec::new();
2362 if cursor.goto_first_child() {
2363 loop {
2364 if cursor.field_name().is_none()
2365 && cursor.node().is_named()
2366 && !cursor.node().is_extra()
2367 {
2368 result.push(cursor.node());
2369 }
2370 if !cursor.goto_next_sibling() {
2371 break;
2372 }
2373 }
2374 }
2375 result
2376 };
2377 let mut items = ::std::vec::Vec::new();
2378 for child in non_field_children {
2379 items.push(
2380 <DelimitedSymbolChildren as ::treesitter_types::FromNode>::from_node(
2381 child, src,
2382 )?,
2383 );
2384 }
2385 items
2386 },
2387 })
2388 }
2389}
2390impl ::treesitter_types::Spanned for DelimitedSymbol<'_> {
2391 fn span(&self) -> ::treesitter_types::Span {
2392 self.span
2393 }
2394}
2395#[derive(Debug, Clone, PartialEq, Eq)]
2396pub struct DestructuredLeftAssignment<'tree> {
2397 pub span: ::treesitter_types::Span,
2398 pub children: ::std::vec::Vec<DestructuredLeftAssignmentChildren<'tree>>,
2399}
2400impl<'tree> ::treesitter_types::FromNode<'tree> for DestructuredLeftAssignment<'tree> {
2401 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2402 fn from_node(
2403 node: ::tree_sitter::Node<'tree>,
2404 src: &'tree [u8],
2405 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2406 debug_assert_eq!(node.kind(), "destructured_left_assignment");
2407 Ok(Self {
2408 span: ::treesitter_types::Span::from(node),
2409 children: {
2410 #[allow(clippy::suspicious_else_formatting)]
2411 let non_field_children = {
2412 let mut cursor = node.walk();
2413 let mut result = ::std::vec::Vec::new();
2414 if cursor.goto_first_child() {
2415 loop {
2416 if cursor.field_name().is_none()
2417 && cursor.node().is_named()
2418 && !cursor.node().is_extra()
2419 {
2420 result.push(cursor.node());
2421 }
2422 if !cursor.goto_next_sibling() {
2423 break;
2424 }
2425 }
2426 }
2427 result
2428 };
2429 let mut items = ::std::vec::Vec::new();
2430 for child in non_field_children {
2431 items
2432 .push(
2433 <DestructuredLeftAssignmentChildren as ::treesitter_types::FromNode>::from_node(
2434 child,
2435 src,
2436 )?,
2437 );
2438 }
2439 items
2440 },
2441 })
2442 }
2443}
2444impl ::treesitter_types::Spanned for DestructuredLeftAssignment<'_> {
2445 fn span(&self) -> ::treesitter_types::Span {
2446 self.span
2447 }
2448}
2449#[derive(Debug, Clone, PartialEq, Eq)]
2450pub struct DestructuredParameter<'tree> {
2451 pub span: ::treesitter_types::Span,
2452 pub children: ::std::vec::Vec<DestructuredParameterChildren<'tree>>,
2453}
2454impl<'tree> ::treesitter_types::FromNode<'tree> for DestructuredParameter<'tree> {
2455 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2456 fn from_node(
2457 node: ::tree_sitter::Node<'tree>,
2458 src: &'tree [u8],
2459 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2460 debug_assert_eq!(node.kind(), "destructured_parameter");
2461 Ok(Self {
2462 span: ::treesitter_types::Span::from(node),
2463 children: {
2464 #[allow(clippy::suspicious_else_formatting)]
2465 let non_field_children = {
2466 let mut cursor = node.walk();
2467 let mut result = ::std::vec::Vec::new();
2468 if cursor.goto_first_child() {
2469 loop {
2470 if cursor.field_name().is_none()
2471 && cursor.node().is_named()
2472 && !cursor.node().is_extra()
2473 {
2474 result.push(cursor.node());
2475 }
2476 if !cursor.goto_next_sibling() {
2477 break;
2478 }
2479 }
2480 }
2481 result
2482 };
2483 let mut items = ::std::vec::Vec::new();
2484 for child in non_field_children {
2485 items.push(
2486 <DestructuredParameterChildren as ::treesitter_types::FromNode>::from_node(
2487 child, src,
2488 )?,
2489 );
2490 }
2491 items
2492 },
2493 })
2494 }
2495}
2496impl ::treesitter_types::Spanned for DestructuredParameter<'_> {
2497 fn span(&self) -> ::treesitter_types::Span {
2498 self.span
2499 }
2500}
2501#[derive(Debug, Clone, PartialEq, Eq)]
2502pub struct Do<'tree> {
2503 pub span: ::treesitter_types::Span,
2504 pub children: ::std::vec::Vec<DoChildren<'tree>>,
2505}
2506impl<'tree> ::treesitter_types::FromNode<'tree> for Do<'tree> {
2507 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2508 fn from_node(
2509 node: ::tree_sitter::Node<'tree>,
2510 src: &'tree [u8],
2511 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2512 debug_assert_eq!(node.kind(), "do");
2513 Ok(Self {
2514 span: ::treesitter_types::Span::from(node),
2515 children: {
2516 #[allow(clippy::suspicious_else_formatting)]
2517 let non_field_children = {
2518 let mut cursor = node.walk();
2519 let mut result = ::std::vec::Vec::new();
2520 if cursor.goto_first_child() {
2521 loop {
2522 if cursor.field_name().is_none()
2523 && cursor.node().is_named()
2524 && !cursor.node().is_extra()
2525 {
2526 result.push(cursor.node());
2527 }
2528 if !cursor.goto_next_sibling() {
2529 break;
2530 }
2531 }
2532 }
2533 result
2534 };
2535 let mut items = ::std::vec::Vec::new();
2536 for child in non_field_children {
2537 items.push(<DoChildren as ::treesitter_types::FromNode>::from_node(
2538 child, src,
2539 )?);
2540 }
2541 items
2542 },
2543 })
2544 }
2545}
2546impl ::treesitter_types::Spanned for Do<'_> {
2547 fn span(&self) -> ::treesitter_types::Span {
2548 self.span
2549 }
2550}
2551#[derive(Debug, Clone, PartialEq, Eq)]
2552pub struct DoBlock<'tree> {
2553 pub span: ::treesitter_types::Span,
2554 pub body: ::core::option::Option<BodyStatement<'tree>>,
2555 pub parameters: ::core::option::Option<BlockParameters<'tree>>,
2556}
2557impl<'tree> ::treesitter_types::FromNode<'tree> for DoBlock<'tree> {
2558 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2559 fn from_node(
2560 node: ::tree_sitter::Node<'tree>,
2561 src: &'tree [u8],
2562 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2563 debug_assert_eq!(node.kind(), "do_block");
2564 Ok(Self {
2565 span: ::treesitter_types::Span::from(node),
2566 body: match node.child_by_field_name("body") {
2567 Some(child) => Some(<BodyStatement as ::treesitter_types::FromNode>::from_node(
2568 child, src,
2569 )?),
2570 None => None,
2571 },
2572 parameters: match node.child_by_field_name("parameters") {
2573 Some(child) => {
2574 Some(<BlockParameters as ::treesitter_types::FromNode>::from_node(child, src)?)
2575 }
2576 None => None,
2577 },
2578 })
2579 }
2580}
2581impl ::treesitter_types::Spanned for DoBlock<'_> {
2582 fn span(&self) -> ::treesitter_types::Span {
2583 self.span
2584 }
2585}
2586#[derive(Debug, Clone, PartialEq, Eq)]
2587pub struct ElementReference<'tree> {
2588 pub span: ::treesitter_types::Span,
2589 pub block: ::core::option::Option<ElementReferenceBlock<'tree>>,
2590 pub object: Primary<'tree>,
2591 pub children: ::std::vec::Vec<ElementReferenceChildren<'tree>>,
2592}
2593impl<'tree> ::treesitter_types::FromNode<'tree> for ElementReference<'tree> {
2594 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2595 fn from_node(
2596 node: ::tree_sitter::Node<'tree>,
2597 src: &'tree [u8],
2598 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2599 debug_assert_eq!(node.kind(), "element_reference");
2600 Ok(Self {
2601 span: ::treesitter_types::Span::from(node),
2602 block: match node.child_by_field_name("block") {
2603 Some(child) => Some(
2604 <ElementReferenceBlock as ::treesitter_types::FromNode>::from_node(child, src)?,
2605 ),
2606 None => None,
2607 },
2608 object: {
2609 let child = node
2610 .child_by_field_name("object")
2611 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
2612 <Primary as ::treesitter_types::FromNode>::from_node(child, src)?
2613 },
2614 children: {
2615 #[allow(clippy::suspicious_else_formatting)]
2616 let non_field_children = {
2617 let mut cursor = node.walk();
2618 let mut result = ::std::vec::Vec::new();
2619 if cursor.goto_first_child() {
2620 loop {
2621 if cursor.field_name().is_none()
2622 && cursor.node().is_named()
2623 && !cursor.node().is_extra()
2624 {
2625 result.push(cursor.node());
2626 }
2627 if !cursor.goto_next_sibling() {
2628 break;
2629 }
2630 }
2631 }
2632 result
2633 };
2634 let mut items = ::std::vec::Vec::new();
2635 for child in non_field_children {
2636 items.push(
2637 <ElementReferenceChildren as ::treesitter_types::FromNode>::from_node(
2638 child, src,
2639 )?,
2640 );
2641 }
2642 items
2643 },
2644 })
2645 }
2646}
2647impl ::treesitter_types::Spanned for ElementReference<'_> {
2648 fn span(&self) -> ::treesitter_types::Span {
2649 self.span
2650 }
2651}
2652#[derive(Debug, Clone, PartialEq, Eq)]
2653pub struct Else<'tree> {
2654 pub span: ::treesitter_types::Span,
2655 pub children: ::std::vec::Vec<ElseChildren<'tree>>,
2656}
2657impl<'tree> ::treesitter_types::FromNode<'tree> for Else<'tree> {
2658 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2659 fn from_node(
2660 node: ::tree_sitter::Node<'tree>,
2661 src: &'tree [u8],
2662 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2663 debug_assert_eq!(node.kind(), "else");
2664 Ok(Self {
2665 span: ::treesitter_types::Span::from(node),
2666 children: {
2667 #[allow(clippy::suspicious_else_formatting)]
2668 let non_field_children = {
2669 let mut cursor = node.walk();
2670 let mut result = ::std::vec::Vec::new();
2671 if cursor.goto_first_child() {
2672 loop {
2673 if cursor.field_name().is_none()
2674 && cursor.node().is_named()
2675 && !cursor.node().is_extra()
2676 {
2677 result.push(cursor.node());
2678 }
2679 if !cursor.goto_next_sibling() {
2680 break;
2681 }
2682 }
2683 }
2684 result
2685 };
2686 let mut items = ::std::vec::Vec::new();
2687 for child in non_field_children {
2688 items.push(<ElseChildren as ::treesitter_types::FromNode>::from_node(
2689 child, src,
2690 )?);
2691 }
2692 items
2693 },
2694 })
2695 }
2696}
2697impl ::treesitter_types::Spanned for Else<'_> {
2698 fn span(&self) -> ::treesitter_types::Span {
2699 self.span
2700 }
2701}
2702#[derive(Debug, Clone, PartialEq, Eq)]
2703pub struct Elsif<'tree> {
2704 pub span: ::treesitter_types::Span,
2705 pub alternative: ::core::option::Option<ElsifAlternative<'tree>>,
2706 pub condition: Statement<'tree>,
2707 pub consequence: ::core::option::Option<Then<'tree>>,
2708}
2709impl<'tree> ::treesitter_types::FromNode<'tree> for Elsif<'tree> {
2710 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2711 fn from_node(
2712 node: ::tree_sitter::Node<'tree>,
2713 src: &'tree [u8],
2714 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2715 debug_assert_eq!(node.kind(), "elsif");
2716 Ok(Self {
2717 span: ::treesitter_types::Span::from(node),
2718 alternative: match node.child_by_field_name("alternative") {
2719 Some(child) => {
2720 Some(<ElsifAlternative as ::treesitter_types::FromNode>::from_node(child, src)?)
2721 }
2722 None => None,
2723 },
2724 condition: {
2725 let child = node.child_by_field_name("condition").ok_or_else(|| {
2726 ::treesitter_types::ParseError::missing_field("condition", node)
2727 })?;
2728 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2729 },
2730 consequence: match node.child_by_field_name("consequence") {
2731 Some(child) => Some(<Then as ::treesitter_types::FromNode>::from_node(
2732 child, src,
2733 )?),
2734 None => None,
2735 },
2736 })
2737 }
2738}
2739impl ::treesitter_types::Spanned for Elsif<'_> {
2740 fn span(&self) -> ::treesitter_types::Span {
2741 self.span
2742 }
2743}
2744#[derive(Debug, Clone, PartialEq, Eq)]
2745pub struct EmptyStatement<'tree> {
2746 pub span: ::treesitter_types::Span,
2747 text: &'tree str,
2748}
2749impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
2750 fn from_node(
2751 node: ::tree_sitter::Node<'tree>,
2752 src: &'tree [u8],
2753 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2754 debug_assert_eq!(node.kind(), "empty_statement");
2755 Ok(Self {
2756 span: ::treesitter_types::Span::from(node),
2757 text: node.utf8_text(src)?,
2758 })
2759 }
2760}
2761impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
2762 fn text(&self) -> &'tree str {
2763 self.text
2764 }
2765}
2766impl ::treesitter_types::Spanned for EmptyStatement<'_> {
2767 fn span(&self) -> ::treesitter_types::Span {
2768 self.span
2769 }
2770}
2771#[derive(Debug, Clone, PartialEq, Eq)]
2772pub struct EndBlock<'tree> {
2773 pub span: ::treesitter_types::Span,
2774 pub children: ::std::vec::Vec<EndBlockChildren<'tree>>,
2775}
2776impl<'tree> ::treesitter_types::FromNode<'tree> for EndBlock<'tree> {
2777 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2778 fn from_node(
2779 node: ::tree_sitter::Node<'tree>,
2780 src: &'tree [u8],
2781 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2782 debug_assert_eq!(node.kind(), "end_block");
2783 Ok(Self {
2784 span: ::treesitter_types::Span::from(node),
2785 children: {
2786 #[allow(clippy::suspicious_else_formatting)]
2787 let non_field_children = {
2788 let mut cursor = node.walk();
2789 let mut result = ::std::vec::Vec::new();
2790 if cursor.goto_first_child() {
2791 loop {
2792 if cursor.field_name().is_none()
2793 && cursor.node().is_named()
2794 && !cursor.node().is_extra()
2795 {
2796 result.push(cursor.node());
2797 }
2798 if !cursor.goto_next_sibling() {
2799 break;
2800 }
2801 }
2802 }
2803 result
2804 };
2805 let mut items = ::std::vec::Vec::new();
2806 for child in non_field_children {
2807 items.push(
2808 <EndBlockChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
2809 );
2810 }
2811 items
2812 },
2813 })
2814 }
2815}
2816impl ::treesitter_types::Spanned for EndBlock<'_> {
2817 fn span(&self) -> ::treesitter_types::Span {
2818 self.span
2819 }
2820}
2821#[derive(Debug, Clone, PartialEq, Eq)]
2822pub struct Ensure<'tree> {
2823 pub span: ::treesitter_types::Span,
2824 pub children: ::std::vec::Vec<EnsureChildren<'tree>>,
2825}
2826impl<'tree> ::treesitter_types::FromNode<'tree> for Ensure<'tree> {
2827 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2828 fn from_node(
2829 node: ::tree_sitter::Node<'tree>,
2830 src: &'tree [u8],
2831 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2832 debug_assert_eq!(node.kind(), "ensure");
2833 Ok(Self {
2834 span: ::treesitter_types::Span::from(node),
2835 children: {
2836 #[allow(clippy::suspicious_else_formatting)]
2837 let non_field_children = {
2838 let mut cursor = node.walk();
2839 let mut result = ::std::vec::Vec::new();
2840 if cursor.goto_first_child() {
2841 loop {
2842 if cursor.field_name().is_none()
2843 && cursor.node().is_named()
2844 && !cursor.node().is_extra()
2845 {
2846 result.push(cursor.node());
2847 }
2848 if !cursor.goto_next_sibling() {
2849 break;
2850 }
2851 }
2852 }
2853 result
2854 };
2855 let mut items = ::std::vec::Vec::new();
2856 for child in non_field_children {
2857 items.push(<EnsureChildren as ::treesitter_types::FromNode>::from_node(
2858 child, src,
2859 )?);
2860 }
2861 items
2862 },
2863 })
2864 }
2865}
2866impl ::treesitter_types::Spanned for Ensure<'_> {
2867 fn span(&self) -> ::treesitter_types::Span {
2868 self.span
2869 }
2870}
2871#[derive(Debug, Clone, PartialEq, Eq)]
2872pub struct ExceptionVariable<'tree> {
2873 pub span: ::treesitter_types::Span,
2874 pub children: Lhs<'tree>,
2875}
2876impl<'tree> ::treesitter_types::FromNode<'tree> for ExceptionVariable<'tree> {
2877 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2878 fn from_node(
2879 node: ::tree_sitter::Node<'tree>,
2880 src: &'tree [u8],
2881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2882 debug_assert_eq!(node.kind(), "exception_variable");
2883 Ok(Self {
2884 span: ::treesitter_types::Span::from(node),
2885 children: {
2886 #[allow(clippy::suspicious_else_formatting)]
2887 let non_field_children = {
2888 let mut cursor = node.walk();
2889 let mut result = ::std::vec::Vec::new();
2890 if cursor.goto_first_child() {
2891 loop {
2892 if cursor.field_name().is_none()
2893 && cursor.node().is_named()
2894 && !cursor.node().is_extra()
2895 {
2896 result.push(cursor.node());
2897 }
2898 if !cursor.goto_next_sibling() {
2899 break;
2900 }
2901 }
2902 }
2903 result
2904 };
2905 let child = if let Some(&c) = non_field_children.first() {
2906 c
2907 } else {
2908 let mut fallback_cursor = node.walk();
2909 let mut fallback_child = None;
2910 if fallback_cursor.goto_first_child() {
2911 loop {
2912 if fallback_cursor.field_name().is_none()
2913 && !fallback_cursor.node().is_extra()
2914 {
2915 let candidate = fallback_cursor.node();
2916 #[allow(clippy::needless_question_mark)]
2917 if (|| -> ::core::result::Result<
2918 _,
2919 ::treesitter_types::ParseError,
2920 > {
2921 let child = candidate;
2922 Ok(
2923 <Lhs as ::treesitter_types::FromNode>::from_node(
2924 child,
2925 src,
2926 )?,
2927 )
2928 })()
2929 .is_ok()
2930 {
2931 fallback_child = Some(candidate);
2932 break;
2933 }
2934 }
2935 if !fallback_cursor.goto_next_sibling() {
2936 break;
2937 }
2938 }
2939 }
2940 if fallback_child.is_none() {
2941 let mut cursor2 = node.walk();
2942 if cursor2.goto_first_child() {
2943 loop {
2944 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2945 let candidate = cursor2.node();
2946 #[allow(clippy::needless_question_mark)]
2947 if (|| -> ::core::result::Result<
2948 _,
2949 ::treesitter_types::ParseError,
2950 > {
2951 let child = candidate;
2952 Ok(
2953 <Lhs as ::treesitter_types::FromNode>::from_node(
2954 child,
2955 src,
2956 )?,
2957 )
2958 })()
2959 .is_ok()
2960 {
2961 fallback_child = Some(candidate);
2962 break;
2963 }
2964 }
2965 if !cursor2.goto_next_sibling() {
2966 break;
2967 }
2968 }
2969 }
2970 }
2971 fallback_child.ok_or_else(|| {
2972 ::treesitter_types::ParseError::missing_field("children", node)
2973 })?
2974 };
2975 <Lhs as ::treesitter_types::FromNode>::from_node(child, src)?
2976 },
2977 })
2978 }
2979}
2980impl ::treesitter_types::Spanned for ExceptionVariable<'_> {
2981 fn span(&self) -> ::treesitter_types::Span {
2982 self.span
2983 }
2984}
2985#[derive(Debug, Clone, PartialEq, Eq)]
2986pub struct Exceptions<'tree> {
2987 pub span: ::treesitter_types::Span,
2988 pub children: ::std::vec::Vec<ExceptionsChildren<'tree>>,
2989}
2990impl<'tree> ::treesitter_types::FromNode<'tree> for Exceptions<'tree> {
2991 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2992 fn from_node(
2993 node: ::tree_sitter::Node<'tree>,
2994 src: &'tree [u8],
2995 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2996 debug_assert_eq!(node.kind(), "exceptions");
2997 Ok(Self {
2998 span: ::treesitter_types::Span::from(node),
2999 children: {
3000 #[allow(clippy::suspicious_else_formatting)]
3001 let non_field_children = {
3002 let mut cursor = node.walk();
3003 let mut result = ::std::vec::Vec::new();
3004 if cursor.goto_first_child() {
3005 loop {
3006 if cursor.field_name().is_none()
3007 && cursor.node().is_named()
3008 && !cursor.node().is_extra()
3009 {
3010 result.push(cursor.node());
3011 }
3012 if !cursor.goto_next_sibling() {
3013 break;
3014 }
3015 }
3016 }
3017 result
3018 };
3019 let mut items = ::std::vec::Vec::new();
3020 for child in non_field_children {
3021 items.push(
3022 <ExceptionsChildren as ::treesitter_types::FromNode>::from_node(
3023 child, src,
3024 )?,
3025 );
3026 }
3027 items
3028 },
3029 })
3030 }
3031}
3032impl ::treesitter_types::Spanned for Exceptions<'_> {
3033 fn span(&self) -> ::treesitter_types::Span {
3034 self.span
3035 }
3036}
3037#[derive(Debug, Clone, PartialEq, Eq)]
3038pub struct ExpressionReferencePattern<'tree> {
3039 pub span: ::treesitter_types::Span,
3040 pub value: Expression<'tree>,
3041}
3042impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionReferencePattern<'tree> {
3043 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3044 fn from_node(
3045 node: ::tree_sitter::Node<'tree>,
3046 src: &'tree [u8],
3047 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3048 debug_assert_eq!(node.kind(), "expression_reference_pattern");
3049 Ok(Self {
3050 span: ::treesitter_types::Span::from(node),
3051 value: {
3052 let child = node
3053 .child_by_field_name("value")
3054 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3055 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3056 },
3057 })
3058 }
3059}
3060impl ::treesitter_types::Spanned for ExpressionReferencePattern<'_> {
3061 fn span(&self) -> ::treesitter_types::Span {
3062 self.span
3063 }
3064}
3065#[derive(Debug, Clone, PartialEq, Eq)]
3066pub struct FindPattern<'tree> {
3067 pub span: ::treesitter_types::Span,
3068 pub class: ::core::option::Option<PatternConstant<'tree>>,
3069 pub children: ::std::vec::Vec<FindPatternChildren<'tree>>,
3070}
3071impl<'tree> ::treesitter_types::FromNode<'tree> for FindPattern<'tree> {
3072 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3073 fn from_node(
3074 node: ::tree_sitter::Node<'tree>,
3075 src: &'tree [u8],
3076 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3077 debug_assert_eq!(node.kind(), "find_pattern");
3078 Ok(Self {
3079 span: ::treesitter_types::Span::from(node),
3080 class: match node.child_by_field_name("class") {
3081 Some(child) => {
3082 Some(<PatternConstant as ::treesitter_types::FromNode>::from_node(child, src)?)
3083 }
3084 None => None,
3085 },
3086 children: {
3087 #[allow(clippy::suspicious_else_formatting)]
3088 let non_field_children = {
3089 let mut cursor = node.walk();
3090 let mut result = ::std::vec::Vec::new();
3091 if cursor.goto_first_child() {
3092 loop {
3093 if cursor.field_name().is_none()
3094 && cursor.node().is_named()
3095 && !cursor.node().is_extra()
3096 {
3097 result.push(cursor.node());
3098 }
3099 if !cursor.goto_next_sibling() {
3100 break;
3101 }
3102 }
3103 }
3104 result
3105 };
3106 let mut items = ::std::vec::Vec::new();
3107 for child in non_field_children {
3108 items.push(
3109 <FindPatternChildren as ::treesitter_types::FromNode>::from_node(
3110 child, src,
3111 )?,
3112 );
3113 }
3114 items
3115 },
3116 })
3117 }
3118}
3119impl ::treesitter_types::Spanned for FindPattern<'_> {
3120 fn span(&self) -> ::treesitter_types::Span {
3121 self.span
3122 }
3123}
3124#[derive(Debug, Clone, PartialEq, Eq)]
3125pub struct For<'tree> {
3126 pub span: ::treesitter_types::Span,
3127 pub body: Do<'tree>,
3128 pub pattern: ForPattern<'tree>,
3129 pub value: In<'tree>,
3130}
3131impl<'tree> ::treesitter_types::FromNode<'tree> for For<'tree> {
3132 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3133 fn from_node(
3134 node: ::tree_sitter::Node<'tree>,
3135 src: &'tree [u8],
3136 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3137 debug_assert_eq!(node.kind(), "for");
3138 Ok(Self {
3139 span: ::treesitter_types::Span::from(node),
3140 body: {
3141 let child = node
3142 .child_by_field_name("body")
3143 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3144 <Do as ::treesitter_types::FromNode>::from_node(child, src)?
3145 },
3146 pattern: {
3147 let child = node.child_by_field_name("pattern").ok_or_else(|| {
3148 ::treesitter_types::ParseError::missing_field("pattern", node)
3149 })?;
3150 <ForPattern as ::treesitter_types::FromNode>::from_node(child, src)?
3151 },
3152 value: {
3153 let child = node
3154 .child_by_field_name("value")
3155 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3156 <In as ::treesitter_types::FromNode>::from_node(child, src)?
3157 },
3158 })
3159 }
3160}
3161impl ::treesitter_types::Spanned for For<'_> {
3162 fn span(&self) -> ::treesitter_types::Span {
3163 self.span
3164 }
3165}
3166#[derive(Debug, Clone, PartialEq, Eq)]
3167pub struct ForwardArgument<'tree> {
3168 pub span: ::treesitter_types::Span,
3169 text: &'tree str,
3170}
3171impl<'tree> ::treesitter_types::FromNode<'tree> for ForwardArgument<'tree> {
3172 fn from_node(
3173 node: ::tree_sitter::Node<'tree>,
3174 src: &'tree [u8],
3175 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3176 debug_assert_eq!(node.kind(), "forward_argument");
3177 Ok(Self {
3178 span: ::treesitter_types::Span::from(node),
3179 text: node.utf8_text(src)?,
3180 })
3181 }
3182}
3183impl<'tree> ::treesitter_types::LeafNode<'tree> for ForwardArgument<'tree> {
3184 fn text(&self) -> &'tree str {
3185 self.text
3186 }
3187}
3188impl ::treesitter_types::Spanned for ForwardArgument<'_> {
3189 fn span(&self) -> ::treesitter_types::Span {
3190 self.span
3191 }
3192}
3193#[derive(Debug, Clone, PartialEq, Eq)]
3194pub struct ForwardParameter<'tree> {
3195 pub span: ::treesitter_types::Span,
3196 text: &'tree str,
3197}
3198impl<'tree> ::treesitter_types::FromNode<'tree> for ForwardParameter<'tree> {
3199 fn from_node(
3200 node: ::tree_sitter::Node<'tree>,
3201 src: &'tree [u8],
3202 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3203 debug_assert_eq!(node.kind(), "forward_parameter");
3204 Ok(Self {
3205 span: ::treesitter_types::Span::from(node),
3206 text: node.utf8_text(src)?,
3207 })
3208 }
3209}
3210impl<'tree> ::treesitter_types::LeafNode<'tree> for ForwardParameter<'tree> {
3211 fn text(&self) -> &'tree str {
3212 self.text
3213 }
3214}
3215impl ::treesitter_types::Spanned for ForwardParameter<'_> {
3216 fn span(&self) -> ::treesitter_types::Span {
3217 self.span
3218 }
3219}
3220#[derive(Debug, Clone, PartialEq, Eq)]
3221pub struct Hash<'tree> {
3222 pub span: ::treesitter_types::Span,
3223 pub children: ::std::vec::Vec<HashChildren<'tree>>,
3224}
3225impl<'tree> ::treesitter_types::FromNode<'tree> for Hash<'tree> {
3226 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3227 fn from_node(
3228 node: ::tree_sitter::Node<'tree>,
3229 src: &'tree [u8],
3230 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3231 debug_assert_eq!(node.kind(), "hash");
3232 Ok(Self {
3233 span: ::treesitter_types::Span::from(node),
3234 children: {
3235 #[allow(clippy::suspicious_else_formatting)]
3236 let non_field_children = {
3237 let mut cursor = node.walk();
3238 let mut result = ::std::vec::Vec::new();
3239 if cursor.goto_first_child() {
3240 loop {
3241 if cursor.field_name().is_none()
3242 && cursor.node().is_named()
3243 && !cursor.node().is_extra()
3244 {
3245 result.push(cursor.node());
3246 }
3247 if !cursor.goto_next_sibling() {
3248 break;
3249 }
3250 }
3251 }
3252 result
3253 };
3254 let mut items = ::std::vec::Vec::new();
3255 for child in non_field_children {
3256 items.push(<HashChildren as ::treesitter_types::FromNode>::from_node(
3257 child, src,
3258 )?);
3259 }
3260 items
3261 },
3262 })
3263 }
3264}
3265impl ::treesitter_types::Spanned for Hash<'_> {
3266 fn span(&self) -> ::treesitter_types::Span {
3267 self.span
3268 }
3269}
3270#[derive(Debug, Clone, PartialEq, Eq)]
3271pub struct HashKeySymbol<'tree> {
3272 pub span: ::treesitter_types::Span,
3273 text: &'tree str,
3274}
3275impl<'tree> ::treesitter_types::FromNode<'tree> for HashKeySymbol<'tree> {
3276 fn from_node(
3277 node: ::tree_sitter::Node<'tree>,
3278 src: &'tree [u8],
3279 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3280 debug_assert_eq!(node.kind(), "hash_key_symbol");
3281 Ok(Self {
3282 span: ::treesitter_types::Span::from(node),
3283 text: node.utf8_text(src)?,
3284 })
3285 }
3286}
3287impl<'tree> ::treesitter_types::LeafNode<'tree> for HashKeySymbol<'tree> {
3288 fn text(&self) -> &'tree str {
3289 self.text
3290 }
3291}
3292impl ::treesitter_types::Spanned for HashKeySymbol<'_> {
3293 fn span(&self) -> ::treesitter_types::Span {
3294 self.span
3295 }
3296}
3297#[derive(Debug, Clone, PartialEq, Eq)]
3298pub struct HashPattern<'tree> {
3299 pub span: ::treesitter_types::Span,
3300 pub class: ::core::option::Option<PatternConstant<'tree>>,
3301 pub children: ::std::vec::Vec<HashPatternChildren<'tree>>,
3302}
3303impl<'tree> ::treesitter_types::FromNode<'tree> for HashPattern<'tree> {
3304 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3305 fn from_node(
3306 node: ::tree_sitter::Node<'tree>,
3307 src: &'tree [u8],
3308 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3309 debug_assert_eq!(node.kind(), "hash_pattern");
3310 Ok(Self {
3311 span: ::treesitter_types::Span::from(node),
3312 class: match node.child_by_field_name("class") {
3313 Some(child) => {
3314 Some(<PatternConstant as ::treesitter_types::FromNode>::from_node(child, src)?)
3315 }
3316 None => None,
3317 },
3318 children: {
3319 #[allow(clippy::suspicious_else_formatting)]
3320 let non_field_children = {
3321 let mut cursor = node.walk();
3322 let mut result = ::std::vec::Vec::new();
3323 if cursor.goto_first_child() {
3324 loop {
3325 if cursor.field_name().is_none()
3326 && cursor.node().is_named()
3327 && !cursor.node().is_extra()
3328 {
3329 result.push(cursor.node());
3330 }
3331 if !cursor.goto_next_sibling() {
3332 break;
3333 }
3334 }
3335 }
3336 result
3337 };
3338 let mut items = ::std::vec::Vec::new();
3339 for child in non_field_children {
3340 items.push(
3341 <HashPatternChildren as ::treesitter_types::FromNode>::from_node(
3342 child, src,
3343 )?,
3344 );
3345 }
3346 items
3347 },
3348 })
3349 }
3350}
3351impl ::treesitter_types::Spanned for HashPattern<'_> {
3352 fn span(&self) -> ::treesitter_types::Span {
3353 self.span
3354 }
3355}
3356#[derive(Debug, Clone, PartialEq, Eq)]
3357pub struct HashSplatArgument<'tree> {
3358 pub span: ::treesitter_types::Span,
3359 pub children: ::core::option::Option<Arg<'tree>>,
3360}
3361impl<'tree> ::treesitter_types::FromNode<'tree> for HashSplatArgument<'tree> {
3362 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3363 fn from_node(
3364 node: ::tree_sitter::Node<'tree>,
3365 src: &'tree [u8],
3366 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3367 debug_assert_eq!(node.kind(), "hash_splat_argument");
3368 Ok(Self {
3369 span: ::treesitter_types::Span::from(node),
3370 children: {
3371 #[allow(clippy::suspicious_else_formatting)]
3372 let non_field_children = {
3373 let mut cursor = node.walk();
3374 let mut result = ::std::vec::Vec::new();
3375 if cursor.goto_first_child() {
3376 loop {
3377 if cursor.field_name().is_none()
3378 && cursor.node().is_named()
3379 && !cursor.node().is_extra()
3380 {
3381 result.push(cursor.node());
3382 }
3383 if !cursor.goto_next_sibling() {
3384 break;
3385 }
3386 }
3387 }
3388 result
3389 };
3390 match non_field_children.first() {
3391 Some(&child) => Some(<Arg as ::treesitter_types::FromNode>::from_node(
3392 child, src,
3393 )?),
3394 None => None,
3395 }
3396 },
3397 })
3398 }
3399}
3400impl ::treesitter_types::Spanned for HashSplatArgument<'_> {
3401 fn span(&self) -> ::treesitter_types::Span {
3402 self.span
3403 }
3404}
3405#[derive(Debug, Clone, PartialEq, Eq)]
3406pub struct HashSplatNil<'tree> {
3407 pub span: ::treesitter_types::Span,
3408 text: &'tree str,
3409}
3410impl<'tree> ::treesitter_types::FromNode<'tree> for HashSplatNil<'tree> {
3411 fn from_node(
3412 node: ::tree_sitter::Node<'tree>,
3413 src: &'tree [u8],
3414 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3415 debug_assert_eq!(node.kind(), "hash_splat_nil");
3416 Ok(Self {
3417 span: ::treesitter_types::Span::from(node),
3418 text: node.utf8_text(src)?,
3419 })
3420 }
3421}
3422impl<'tree> ::treesitter_types::LeafNode<'tree> for HashSplatNil<'tree> {
3423 fn text(&self) -> &'tree str {
3424 self.text
3425 }
3426}
3427impl ::treesitter_types::Spanned for HashSplatNil<'_> {
3428 fn span(&self) -> ::treesitter_types::Span {
3429 self.span
3430 }
3431}
3432#[derive(Debug, Clone, PartialEq, Eq)]
3433pub struct HashSplatParameter<'tree> {
3434 pub span: ::treesitter_types::Span,
3435 pub name: ::core::option::Option<Identifier<'tree>>,
3436}
3437impl<'tree> ::treesitter_types::FromNode<'tree> for HashSplatParameter<'tree> {
3438 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3439 fn from_node(
3440 node: ::tree_sitter::Node<'tree>,
3441 src: &'tree [u8],
3442 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3443 debug_assert_eq!(node.kind(), "hash_splat_parameter");
3444 Ok(Self {
3445 span: ::treesitter_types::Span::from(node),
3446 name: match node.child_by_field_name("name") {
3447 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
3448 child, src,
3449 )?),
3450 None => None,
3451 },
3452 })
3453 }
3454}
3455impl ::treesitter_types::Spanned for HashSplatParameter<'_> {
3456 fn span(&self) -> ::treesitter_types::Span {
3457 self.span
3458 }
3459}
3460#[derive(Debug, Clone, PartialEq, Eq)]
3461pub struct HeredocBody<'tree> {
3462 pub span: ::treesitter_types::Span,
3463 pub children: ::std::vec::Vec<HeredocBodyChildren<'tree>>,
3464}
3465impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBody<'tree> {
3466 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3467 fn from_node(
3468 node: ::tree_sitter::Node<'tree>,
3469 src: &'tree [u8],
3470 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3471 debug_assert_eq!(node.kind(), "heredoc_body");
3472 Ok(Self {
3473 span: ::treesitter_types::Span::from(node),
3474 children: {
3475 #[allow(clippy::suspicious_else_formatting)]
3476 let non_field_children = {
3477 let mut cursor = node.walk();
3478 let mut result = ::std::vec::Vec::new();
3479 if cursor.goto_first_child() {
3480 loop {
3481 if cursor.field_name().is_none()
3482 && cursor.node().is_named()
3483 && !cursor.node().is_extra()
3484 {
3485 result.push(cursor.node());
3486 }
3487 if !cursor.goto_next_sibling() {
3488 break;
3489 }
3490 }
3491 }
3492 result
3493 };
3494 let mut items = ::std::vec::Vec::new();
3495 for child in non_field_children {
3496 items.push(
3497 <HeredocBodyChildren as ::treesitter_types::FromNode>::from_node(
3498 child, src,
3499 )?,
3500 );
3501 }
3502 items
3503 },
3504 })
3505 }
3506}
3507impl ::treesitter_types::Spanned for HeredocBody<'_> {
3508 fn span(&self) -> ::treesitter_types::Span {
3509 self.span
3510 }
3511}
3512#[derive(Debug, Clone, PartialEq, Eq)]
3513pub struct Identifier<'tree> {
3514 pub span: ::treesitter_types::Span,
3515 text: &'tree str,
3516}
3517impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
3518 fn from_node(
3519 node: ::tree_sitter::Node<'tree>,
3520 src: &'tree [u8],
3521 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3522 debug_assert_eq!(node.kind(), "identifier");
3523 Ok(Self {
3524 span: ::treesitter_types::Span::from(node),
3525 text: node.utf8_text(src)?,
3526 })
3527 }
3528}
3529impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
3530 fn text(&self) -> &'tree str {
3531 self.text
3532 }
3533}
3534impl ::treesitter_types::Spanned for Identifier<'_> {
3535 fn span(&self) -> ::treesitter_types::Span {
3536 self.span
3537 }
3538}
3539#[derive(Debug, Clone, PartialEq, Eq)]
3540pub struct If<'tree> {
3541 pub span: ::treesitter_types::Span,
3542 pub alternative: ::core::option::Option<IfAlternative<'tree>>,
3543 pub condition: Statement<'tree>,
3544 pub consequence: ::core::option::Option<Then<'tree>>,
3545}
3546impl<'tree> ::treesitter_types::FromNode<'tree> for If<'tree> {
3547 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3548 fn from_node(
3549 node: ::tree_sitter::Node<'tree>,
3550 src: &'tree [u8],
3551 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3552 debug_assert_eq!(node.kind(), "if");
3553 Ok(Self {
3554 span: ::treesitter_types::Span::from(node),
3555 alternative: match node.child_by_field_name("alternative") {
3556 Some(child) => Some(<IfAlternative as ::treesitter_types::FromNode>::from_node(
3557 child, src,
3558 )?),
3559 None => None,
3560 },
3561 condition: {
3562 let child = node.child_by_field_name("condition").ok_or_else(|| {
3563 ::treesitter_types::ParseError::missing_field("condition", node)
3564 })?;
3565 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3566 },
3567 consequence: match node.child_by_field_name("consequence") {
3568 Some(child) => Some(<Then as ::treesitter_types::FromNode>::from_node(
3569 child, src,
3570 )?),
3571 None => None,
3572 },
3573 })
3574 }
3575}
3576impl ::treesitter_types::Spanned for If<'_> {
3577 fn span(&self) -> ::treesitter_types::Span {
3578 self.span
3579 }
3580}
3581#[derive(Debug, Clone, PartialEq, Eq)]
3582pub struct IfGuard<'tree> {
3583 pub span: ::treesitter_types::Span,
3584 pub condition: Expression<'tree>,
3585}
3586impl<'tree> ::treesitter_types::FromNode<'tree> for IfGuard<'tree> {
3587 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3588 fn from_node(
3589 node: ::tree_sitter::Node<'tree>,
3590 src: &'tree [u8],
3591 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3592 debug_assert_eq!(node.kind(), "if_guard");
3593 Ok(Self {
3594 span: ::treesitter_types::Span::from(node),
3595 condition: {
3596 let child = node.child_by_field_name("condition").ok_or_else(|| {
3597 ::treesitter_types::ParseError::missing_field("condition", node)
3598 })?;
3599 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3600 },
3601 })
3602 }
3603}
3604impl ::treesitter_types::Spanned for IfGuard<'_> {
3605 fn span(&self) -> ::treesitter_types::Span {
3606 self.span
3607 }
3608}
3609#[derive(Debug, Clone, PartialEq, Eq)]
3610pub struct IfModifier<'tree> {
3611 pub span: ::treesitter_types::Span,
3612 pub body: Statement<'tree>,
3613 pub condition: Expression<'tree>,
3614}
3615impl<'tree> ::treesitter_types::FromNode<'tree> for IfModifier<'tree> {
3616 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3617 fn from_node(
3618 node: ::tree_sitter::Node<'tree>,
3619 src: &'tree [u8],
3620 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3621 debug_assert_eq!(node.kind(), "if_modifier");
3622 Ok(Self {
3623 span: ::treesitter_types::Span::from(node),
3624 body: {
3625 let child = node
3626 .child_by_field_name("body")
3627 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3628 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3629 },
3630 condition: {
3631 let child = node.child_by_field_name("condition").ok_or_else(|| {
3632 ::treesitter_types::ParseError::missing_field("condition", node)
3633 })?;
3634 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3635 },
3636 })
3637 }
3638}
3639impl ::treesitter_types::Spanned for IfModifier<'_> {
3640 fn span(&self) -> ::treesitter_types::Span {
3641 self.span
3642 }
3643}
3644#[derive(Debug, Clone, PartialEq, Eq)]
3645pub struct In<'tree> {
3646 pub span: ::treesitter_types::Span,
3647 pub children: Arg<'tree>,
3648}
3649impl<'tree> ::treesitter_types::FromNode<'tree> for In<'tree> {
3650 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3651 fn from_node(
3652 node: ::tree_sitter::Node<'tree>,
3653 src: &'tree [u8],
3654 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3655 debug_assert_eq!(node.kind(), "in");
3656 Ok(Self {
3657 span: ::treesitter_types::Span::from(node),
3658 children: {
3659 #[allow(clippy::suspicious_else_formatting)]
3660 let non_field_children = {
3661 let mut cursor = node.walk();
3662 let mut result = ::std::vec::Vec::new();
3663 if cursor.goto_first_child() {
3664 loop {
3665 if cursor.field_name().is_none()
3666 && cursor.node().is_named()
3667 && !cursor.node().is_extra()
3668 {
3669 result.push(cursor.node());
3670 }
3671 if !cursor.goto_next_sibling() {
3672 break;
3673 }
3674 }
3675 }
3676 result
3677 };
3678 let child = if let Some(&c) = non_field_children.first() {
3679 c
3680 } else {
3681 let mut fallback_cursor = node.walk();
3682 let mut fallback_child = None;
3683 if fallback_cursor.goto_first_child() {
3684 loop {
3685 if fallback_cursor.field_name().is_none()
3686 && !fallback_cursor.node().is_extra()
3687 {
3688 let candidate = fallback_cursor.node();
3689 #[allow(clippy::needless_question_mark)]
3690 if (|| -> ::core::result::Result<
3691 _,
3692 ::treesitter_types::ParseError,
3693 > {
3694 let child = candidate;
3695 Ok(
3696 <Arg as ::treesitter_types::FromNode>::from_node(
3697 child,
3698 src,
3699 )?,
3700 )
3701 })()
3702 .is_ok()
3703 {
3704 fallback_child = Some(candidate);
3705 break;
3706 }
3707 }
3708 if !fallback_cursor.goto_next_sibling() {
3709 break;
3710 }
3711 }
3712 }
3713 if fallback_child.is_none() {
3714 let mut cursor2 = node.walk();
3715 if cursor2.goto_first_child() {
3716 loop {
3717 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3718 let candidate = cursor2.node();
3719 #[allow(clippy::needless_question_mark)]
3720 if (|| -> ::core::result::Result<
3721 _,
3722 ::treesitter_types::ParseError,
3723 > {
3724 let child = candidate;
3725 Ok(
3726 <Arg as ::treesitter_types::FromNode>::from_node(
3727 child,
3728 src,
3729 )?,
3730 )
3731 })()
3732 .is_ok()
3733 {
3734 fallback_child = Some(candidate);
3735 break;
3736 }
3737 }
3738 if !cursor2.goto_next_sibling() {
3739 break;
3740 }
3741 }
3742 }
3743 }
3744 fallback_child.ok_or_else(|| {
3745 ::treesitter_types::ParseError::missing_field("children", node)
3746 })?
3747 };
3748 <Arg as ::treesitter_types::FromNode>::from_node(child, src)?
3749 },
3750 })
3751 }
3752}
3753impl ::treesitter_types::Spanned for In<'_> {
3754 fn span(&self) -> ::treesitter_types::Span {
3755 self.span
3756 }
3757}
3758#[derive(Debug, Clone, PartialEq, Eq)]
3759pub struct InClause<'tree> {
3760 pub span: ::treesitter_types::Span,
3761 pub body: ::core::option::Option<Then<'tree>>,
3762 pub guard: ::core::option::Option<InClauseGuard<'tree>>,
3763 pub pattern: PatternTopExprBody<'tree>,
3764}
3765impl<'tree> ::treesitter_types::FromNode<'tree> for InClause<'tree> {
3766 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3767 fn from_node(
3768 node: ::tree_sitter::Node<'tree>,
3769 src: &'tree [u8],
3770 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3771 debug_assert_eq!(node.kind(), "in_clause");
3772 Ok(Self {
3773 span: ::treesitter_types::Span::from(node),
3774 body: match node.child_by_field_name("body") {
3775 Some(child) => Some(<Then as ::treesitter_types::FromNode>::from_node(
3776 child, src,
3777 )?),
3778 None => None,
3779 },
3780 guard: match node.child_by_field_name("guard") {
3781 Some(child) => Some(<InClauseGuard as ::treesitter_types::FromNode>::from_node(
3782 child, src,
3783 )?),
3784 None => None,
3785 },
3786 pattern: {
3787 let child = node.child_by_field_name("pattern").ok_or_else(|| {
3788 ::treesitter_types::ParseError::missing_field("pattern", node)
3789 })?;
3790 <PatternTopExprBody as ::treesitter_types::FromNode>::from_node(child, src)?
3791 },
3792 })
3793 }
3794}
3795impl ::treesitter_types::Spanned for InClause<'_> {
3796 fn span(&self) -> ::treesitter_types::Span {
3797 self.span
3798 }
3799}
3800#[derive(Debug, Clone, PartialEq, Eq)]
3801pub struct Interpolation<'tree> {
3802 pub span: ::treesitter_types::Span,
3803 pub children: ::std::vec::Vec<InterpolationChildren<'tree>>,
3804}
3805impl<'tree> ::treesitter_types::FromNode<'tree> for Interpolation<'tree> {
3806 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3807 fn from_node(
3808 node: ::tree_sitter::Node<'tree>,
3809 src: &'tree [u8],
3810 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3811 debug_assert_eq!(node.kind(), "interpolation");
3812 Ok(Self {
3813 span: ::treesitter_types::Span::from(node),
3814 children: {
3815 #[allow(clippy::suspicious_else_formatting)]
3816 let non_field_children = {
3817 let mut cursor = node.walk();
3818 let mut result = ::std::vec::Vec::new();
3819 if cursor.goto_first_child() {
3820 loop {
3821 if cursor.field_name().is_none()
3822 && cursor.node().is_named()
3823 && !cursor.node().is_extra()
3824 {
3825 result.push(cursor.node());
3826 }
3827 if !cursor.goto_next_sibling() {
3828 break;
3829 }
3830 }
3831 }
3832 result
3833 };
3834 let mut items = ::std::vec::Vec::new();
3835 for child in non_field_children {
3836 items.push(
3837 <InterpolationChildren as ::treesitter_types::FromNode>::from_node(
3838 child, src,
3839 )?,
3840 );
3841 }
3842 items
3843 },
3844 })
3845 }
3846}
3847impl ::treesitter_types::Spanned for Interpolation<'_> {
3848 fn span(&self) -> ::treesitter_types::Span {
3849 self.span
3850 }
3851}
3852#[derive(Debug, Clone, PartialEq, Eq)]
3853pub struct KeywordParameter<'tree> {
3854 pub span: ::treesitter_types::Span,
3855 pub name: Identifier<'tree>,
3856 pub value: ::core::option::Option<Arg<'tree>>,
3857}
3858impl<'tree> ::treesitter_types::FromNode<'tree> for KeywordParameter<'tree> {
3859 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3860 fn from_node(
3861 node: ::tree_sitter::Node<'tree>,
3862 src: &'tree [u8],
3863 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3864 debug_assert_eq!(node.kind(), "keyword_parameter");
3865 Ok(Self {
3866 span: ::treesitter_types::Span::from(node),
3867 name: {
3868 let child = node
3869 .child_by_field_name("name")
3870 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3871 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3872 },
3873 value: match node.child_by_field_name("value") {
3874 Some(child) => Some(<Arg as ::treesitter_types::FromNode>::from_node(
3875 child, src,
3876 )?),
3877 None => None,
3878 },
3879 })
3880 }
3881}
3882impl ::treesitter_types::Spanned for KeywordParameter<'_> {
3883 fn span(&self) -> ::treesitter_types::Span {
3884 self.span
3885 }
3886}
3887#[derive(Debug, Clone, PartialEq, Eq)]
3888pub struct KeywordPattern<'tree> {
3889 pub span: ::treesitter_types::Span,
3890 pub key: KeywordPatternKey<'tree>,
3891 pub value: ::core::option::Option<PatternExpr<'tree>>,
3892}
3893impl<'tree> ::treesitter_types::FromNode<'tree> for KeywordPattern<'tree> {
3894 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3895 fn from_node(
3896 node: ::tree_sitter::Node<'tree>,
3897 src: &'tree [u8],
3898 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3899 debug_assert_eq!(node.kind(), "keyword_pattern");
3900 Ok(Self {
3901 span: ::treesitter_types::Span::from(node),
3902 key: {
3903 let child = node
3904 .child_by_field_name("key")
3905 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
3906 <KeywordPatternKey as ::treesitter_types::FromNode>::from_node(child, src)?
3907 },
3908 value: match node.child_by_field_name("value") {
3909 Some(child) => Some(<PatternExpr as ::treesitter_types::FromNode>::from_node(
3910 child, src,
3911 )?),
3912 None => None,
3913 },
3914 })
3915 }
3916}
3917impl ::treesitter_types::Spanned for KeywordPattern<'_> {
3918 fn span(&self) -> ::treesitter_types::Span {
3919 self.span
3920 }
3921}
3922#[derive(Debug, Clone, PartialEq, Eq)]
3923pub struct Lambda<'tree> {
3924 pub span: ::treesitter_types::Span,
3925 pub body: LambdaBody<'tree>,
3926 pub parameters: ::core::option::Option<LambdaParameters<'tree>>,
3927}
3928impl<'tree> ::treesitter_types::FromNode<'tree> for Lambda<'tree> {
3929 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3930 fn from_node(
3931 node: ::tree_sitter::Node<'tree>,
3932 src: &'tree [u8],
3933 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3934 debug_assert_eq!(node.kind(), "lambda");
3935 Ok(Self {
3936 span: ::treesitter_types::Span::from(node),
3937 body: {
3938 let child = node
3939 .child_by_field_name("body")
3940 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3941 <LambdaBody as ::treesitter_types::FromNode>::from_node(child, src)?
3942 },
3943 parameters: match node.child_by_field_name("parameters") {
3944 Some(child) => {
3945 Some(<LambdaParameters as ::treesitter_types::FromNode>::from_node(child, src)?)
3946 }
3947 None => None,
3948 },
3949 })
3950 }
3951}
3952impl ::treesitter_types::Spanned for Lambda<'_> {
3953 fn span(&self) -> ::treesitter_types::Span {
3954 self.span
3955 }
3956}
3957#[derive(Debug, Clone, PartialEq, Eq)]
3958pub struct LambdaParameters<'tree> {
3959 pub span: ::treesitter_types::Span,
3960 pub children: ::std::vec::Vec<LambdaParametersChildren<'tree>>,
3961}
3962impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaParameters<'tree> {
3963 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3964 fn from_node(
3965 node: ::tree_sitter::Node<'tree>,
3966 src: &'tree [u8],
3967 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3968 debug_assert_eq!(node.kind(), "lambda_parameters");
3969 Ok(Self {
3970 span: ::treesitter_types::Span::from(node),
3971 children: {
3972 #[allow(clippy::suspicious_else_formatting)]
3973 let non_field_children = {
3974 let mut cursor = node.walk();
3975 let mut result = ::std::vec::Vec::new();
3976 if cursor.goto_first_child() {
3977 loop {
3978 if cursor.field_name().is_none()
3979 && cursor.node().is_named()
3980 && !cursor.node().is_extra()
3981 {
3982 result.push(cursor.node());
3983 }
3984 if !cursor.goto_next_sibling() {
3985 break;
3986 }
3987 }
3988 }
3989 result
3990 };
3991 let mut items = ::std::vec::Vec::new();
3992 for child in non_field_children {
3993 items.push(
3994 <LambdaParametersChildren as ::treesitter_types::FromNode>::from_node(
3995 child, src,
3996 )?,
3997 );
3998 }
3999 items
4000 },
4001 })
4002 }
4003}
4004impl ::treesitter_types::Spanned for LambdaParameters<'_> {
4005 fn span(&self) -> ::treesitter_types::Span {
4006 self.span
4007 }
4008}
4009#[derive(Debug, Clone, PartialEq, Eq)]
4010pub struct LeftAssignmentList<'tree> {
4011 pub span: ::treesitter_types::Span,
4012 pub children: ::std::vec::Vec<LeftAssignmentListChildren<'tree>>,
4013}
4014impl<'tree> ::treesitter_types::FromNode<'tree> for LeftAssignmentList<'tree> {
4015 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4016 fn from_node(
4017 node: ::tree_sitter::Node<'tree>,
4018 src: &'tree [u8],
4019 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4020 debug_assert_eq!(node.kind(), "left_assignment_list");
4021 Ok(Self {
4022 span: ::treesitter_types::Span::from(node),
4023 children: {
4024 #[allow(clippy::suspicious_else_formatting)]
4025 let non_field_children = {
4026 let mut cursor = node.walk();
4027 let mut result = ::std::vec::Vec::new();
4028 if cursor.goto_first_child() {
4029 loop {
4030 if cursor.field_name().is_none()
4031 && cursor.node().is_named()
4032 && !cursor.node().is_extra()
4033 {
4034 result.push(cursor.node());
4035 }
4036 if !cursor.goto_next_sibling() {
4037 break;
4038 }
4039 }
4040 }
4041 result
4042 };
4043 let mut items = ::std::vec::Vec::new();
4044 for child in non_field_children {
4045 items.push(
4046 <LeftAssignmentListChildren as ::treesitter_types::FromNode>::from_node(
4047 child, src,
4048 )?,
4049 );
4050 }
4051 items
4052 },
4053 })
4054 }
4055}
4056impl ::treesitter_types::Spanned for LeftAssignmentList<'_> {
4057 fn span(&self) -> ::treesitter_types::Span {
4058 self.span
4059 }
4060}
4061#[derive(Debug, Clone, PartialEq, Eq)]
4062pub struct MatchPattern<'tree> {
4063 pub span: ::treesitter_types::Span,
4064 pub pattern: PatternTopExprBody<'tree>,
4065 pub value: Arg<'tree>,
4066}
4067impl<'tree> ::treesitter_types::FromNode<'tree> for MatchPattern<'tree> {
4068 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4069 fn from_node(
4070 node: ::tree_sitter::Node<'tree>,
4071 src: &'tree [u8],
4072 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4073 debug_assert_eq!(node.kind(), "match_pattern");
4074 Ok(Self {
4075 span: ::treesitter_types::Span::from(node),
4076 pattern: {
4077 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4078 ::treesitter_types::ParseError::missing_field("pattern", node)
4079 })?;
4080 <PatternTopExprBody as ::treesitter_types::FromNode>::from_node(child, src)?
4081 },
4082 value: {
4083 let child = node
4084 .child_by_field_name("value")
4085 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4086 <Arg as ::treesitter_types::FromNode>::from_node(child, src)?
4087 },
4088 })
4089 }
4090}
4091impl ::treesitter_types::Spanned for MatchPattern<'_> {
4092 fn span(&self) -> ::treesitter_types::Span {
4093 self.span
4094 }
4095}
4096#[derive(Debug, Clone, PartialEq, Eq)]
4097pub struct Method<'tree> {
4098 pub span: ::treesitter_types::Span,
4099 pub body: ::core::option::Option<MethodBody<'tree>>,
4100 pub name: MethodName<'tree>,
4101 pub parameters: ::core::option::Option<MethodParameters<'tree>>,
4102}
4103impl<'tree> ::treesitter_types::FromNode<'tree> for Method<'tree> {
4104 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4105 fn from_node(
4106 node: ::tree_sitter::Node<'tree>,
4107 src: &'tree [u8],
4108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4109 debug_assert_eq!(node.kind(), "method");
4110 Ok(Self {
4111 span: ::treesitter_types::Span::from(node),
4112 body: match node.child_by_field_name("body") {
4113 Some(child) => Some(<MethodBody as ::treesitter_types::FromNode>::from_node(
4114 child, src,
4115 )?),
4116 None => None,
4117 },
4118 name: {
4119 let child = node
4120 .child_by_field_name("name")
4121 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4122 <MethodName as ::treesitter_types::FromNode>::from_node(child, src)?
4123 },
4124 parameters: match node.child_by_field_name("parameters") {
4125 Some(child) => {
4126 Some(<MethodParameters as ::treesitter_types::FromNode>::from_node(child, src)?)
4127 }
4128 None => None,
4129 },
4130 })
4131 }
4132}
4133impl ::treesitter_types::Spanned for Method<'_> {
4134 fn span(&self) -> ::treesitter_types::Span {
4135 self.span
4136 }
4137}
4138#[derive(Debug, Clone, PartialEq, Eq)]
4139pub struct MethodParameters<'tree> {
4140 pub span: ::treesitter_types::Span,
4141 pub children: ::std::vec::Vec<MethodParametersChildren<'tree>>,
4142}
4143impl<'tree> ::treesitter_types::FromNode<'tree> for MethodParameters<'tree> {
4144 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4145 fn from_node(
4146 node: ::tree_sitter::Node<'tree>,
4147 src: &'tree [u8],
4148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4149 debug_assert_eq!(node.kind(), "method_parameters");
4150 Ok(Self {
4151 span: ::treesitter_types::Span::from(node),
4152 children: {
4153 #[allow(clippy::suspicious_else_formatting)]
4154 let non_field_children = {
4155 let mut cursor = node.walk();
4156 let mut result = ::std::vec::Vec::new();
4157 if cursor.goto_first_child() {
4158 loop {
4159 if cursor.field_name().is_none()
4160 && cursor.node().is_named()
4161 && !cursor.node().is_extra()
4162 {
4163 result.push(cursor.node());
4164 }
4165 if !cursor.goto_next_sibling() {
4166 break;
4167 }
4168 }
4169 }
4170 result
4171 };
4172 let mut items = ::std::vec::Vec::new();
4173 for child in non_field_children {
4174 items.push(
4175 <MethodParametersChildren as ::treesitter_types::FromNode>::from_node(
4176 child, src,
4177 )?,
4178 );
4179 }
4180 items
4181 },
4182 })
4183 }
4184}
4185impl ::treesitter_types::Spanned for MethodParameters<'_> {
4186 fn span(&self) -> ::treesitter_types::Span {
4187 self.span
4188 }
4189}
4190#[derive(Debug, Clone, PartialEq, Eq)]
4191pub struct Module<'tree> {
4192 pub span: ::treesitter_types::Span,
4193 pub body: ::core::option::Option<BodyStatement<'tree>>,
4194 pub name: ModuleName<'tree>,
4195}
4196impl<'tree> ::treesitter_types::FromNode<'tree> for Module<'tree> {
4197 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4198 fn from_node(
4199 node: ::tree_sitter::Node<'tree>,
4200 src: &'tree [u8],
4201 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4202 debug_assert_eq!(node.kind(), "module");
4203 Ok(Self {
4204 span: ::treesitter_types::Span::from(node),
4205 body: match node.child_by_field_name("body") {
4206 Some(child) => Some(<BodyStatement as ::treesitter_types::FromNode>::from_node(
4207 child, src,
4208 )?),
4209 None => None,
4210 },
4211 name: {
4212 let child = node
4213 .child_by_field_name("name")
4214 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4215 <ModuleName as ::treesitter_types::FromNode>::from_node(child, src)?
4216 },
4217 })
4218 }
4219}
4220impl ::treesitter_types::Spanned for Module<'_> {
4221 fn span(&self) -> ::treesitter_types::Span {
4222 self.span
4223 }
4224}
4225#[derive(Debug, Clone, PartialEq, Eq)]
4226pub struct Next<'tree> {
4227 pub span: ::treesitter_types::Span,
4228 pub children: ::core::option::Option<ArgumentList<'tree>>,
4229}
4230impl<'tree> ::treesitter_types::FromNode<'tree> for Next<'tree> {
4231 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4232 fn from_node(
4233 node: ::tree_sitter::Node<'tree>,
4234 src: &'tree [u8],
4235 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4236 debug_assert_eq!(node.kind(), "next");
4237 Ok(Self {
4238 span: ::treesitter_types::Span::from(node),
4239 children: {
4240 #[allow(clippy::suspicious_else_formatting)]
4241 let non_field_children = {
4242 let mut cursor = node.walk();
4243 let mut result = ::std::vec::Vec::new();
4244 if cursor.goto_first_child() {
4245 loop {
4246 if cursor.field_name().is_none()
4247 && cursor.node().is_named()
4248 && !cursor.node().is_extra()
4249 {
4250 result.push(cursor.node());
4251 }
4252 if !cursor.goto_next_sibling() {
4253 break;
4254 }
4255 }
4256 }
4257 result
4258 };
4259 match non_field_children.first() {
4260 Some(&child) => Some(
4261 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?,
4262 ),
4263 None => None,
4264 }
4265 },
4266 })
4267 }
4268}
4269impl ::treesitter_types::Spanned for Next<'_> {
4270 fn span(&self) -> ::treesitter_types::Span {
4271 self.span
4272 }
4273}
4274#[derive(Debug, Clone, PartialEq, Eq)]
4275pub struct Nil<'tree> {
4276 pub span: ::treesitter_types::Span,
4277 text: &'tree str,
4278}
4279impl<'tree> ::treesitter_types::FromNode<'tree> for Nil<'tree> {
4280 fn from_node(
4281 node: ::tree_sitter::Node<'tree>,
4282 src: &'tree [u8],
4283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4284 debug_assert_eq!(node.kind(), "nil");
4285 Ok(Self {
4286 span: ::treesitter_types::Span::from(node),
4287 text: node.utf8_text(src)?,
4288 })
4289 }
4290}
4291impl<'tree> ::treesitter_types::LeafNode<'tree> for Nil<'tree> {
4292 fn text(&self) -> &'tree str {
4293 self.text
4294 }
4295}
4296impl ::treesitter_types::Spanned for Nil<'_> {
4297 fn span(&self) -> ::treesitter_types::Span {
4298 self.span
4299 }
4300}
4301#[derive(Debug, Clone, PartialEq, Eq)]
4302pub struct Operator<'tree> {
4303 pub span: ::treesitter_types::Span,
4304 text: &'tree str,
4305}
4306impl<'tree> ::treesitter_types::FromNode<'tree> for Operator<'tree> {
4307 fn from_node(
4308 node: ::tree_sitter::Node<'tree>,
4309 src: &'tree [u8],
4310 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4311 debug_assert_eq!(node.kind(), "operator");
4312 Ok(Self {
4313 span: ::treesitter_types::Span::from(node),
4314 text: node.utf8_text(src)?,
4315 })
4316 }
4317}
4318impl<'tree> ::treesitter_types::LeafNode<'tree> for Operator<'tree> {
4319 fn text(&self) -> &'tree str {
4320 self.text
4321 }
4322}
4323impl ::treesitter_types::Spanned for Operator<'_> {
4324 fn span(&self) -> ::treesitter_types::Span {
4325 self.span
4326 }
4327}
4328#[derive(Debug, Clone, PartialEq, Eq)]
4329pub struct OperatorAssignment<'tree> {
4330 pub span: ::treesitter_types::Span,
4331 pub left: Lhs<'tree>,
4332 pub operator: OperatorAssignmentOperator,
4333 pub right: OperatorAssignmentRight<'tree>,
4334}
4335impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorAssignment<'tree> {
4336 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4337 fn from_node(
4338 node: ::tree_sitter::Node<'tree>,
4339 src: &'tree [u8],
4340 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4341 debug_assert_eq!(node.kind(), "operator_assignment");
4342 Ok(Self {
4343 span: ::treesitter_types::Span::from(node),
4344 left: {
4345 let child = node
4346 .child_by_field_name("left")
4347 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
4348 <Lhs as ::treesitter_types::FromNode>::from_node(child, src)?
4349 },
4350 operator: {
4351 let child = node.child_by_field_name("operator").ok_or_else(|| {
4352 ::treesitter_types::ParseError::missing_field("operator", node)
4353 })?;
4354 <OperatorAssignmentOperator as ::treesitter_types::FromNode>::from_node(child, src)?
4355 },
4356 right: {
4357 let child = node
4358 .child_by_field_name("right")
4359 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
4360 <OperatorAssignmentRight as ::treesitter_types::FromNode>::from_node(child, src)?
4361 },
4362 })
4363 }
4364}
4365impl ::treesitter_types::Spanned for OperatorAssignment<'_> {
4366 fn span(&self) -> ::treesitter_types::Span {
4367 self.span
4368 }
4369}
4370#[derive(Debug, Clone, PartialEq, Eq)]
4371pub struct OptionalParameter<'tree> {
4372 pub span: ::treesitter_types::Span,
4373 pub name: Identifier<'tree>,
4374 pub value: Arg<'tree>,
4375}
4376impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameter<'tree> {
4377 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4378 fn from_node(
4379 node: ::tree_sitter::Node<'tree>,
4380 src: &'tree [u8],
4381 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4382 debug_assert_eq!(node.kind(), "optional_parameter");
4383 Ok(Self {
4384 span: ::treesitter_types::Span::from(node),
4385 name: {
4386 let child = node
4387 .child_by_field_name("name")
4388 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4389 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4390 },
4391 value: {
4392 let child = node
4393 .child_by_field_name("value")
4394 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4395 <Arg as ::treesitter_types::FromNode>::from_node(child, src)?
4396 },
4397 })
4398 }
4399}
4400impl ::treesitter_types::Spanned for OptionalParameter<'_> {
4401 fn span(&self) -> ::treesitter_types::Span {
4402 self.span
4403 }
4404}
4405#[derive(Debug, Clone, PartialEq, Eq)]
4406pub struct Pair<'tree> {
4407 pub span: ::treesitter_types::Span,
4408 pub key: PairKey<'tree>,
4409 pub value: ::core::option::Option<Arg<'tree>>,
4410}
4411impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
4412 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4413 fn from_node(
4414 node: ::tree_sitter::Node<'tree>,
4415 src: &'tree [u8],
4416 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4417 debug_assert_eq!(node.kind(), "pair");
4418 Ok(Self {
4419 span: ::treesitter_types::Span::from(node),
4420 key: {
4421 let child = node
4422 .child_by_field_name("key")
4423 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
4424 <PairKey as ::treesitter_types::FromNode>::from_node(child, src)?
4425 },
4426 value: match node.child_by_field_name("value") {
4427 Some(child) => Some(<Arg as ::treesitter_types::FromNode>::from_node(
4428 child, src,
4429 )?),
4430 None => None,
4431 },
4432 })
4433 }
4434}
4435impl ::treesitter_types::Spanned for Pair<'_> {
4436 fn span(&self) -> ::treesitter_types::Span {
4437 self.span
4438 }
4439}
4440#[derive(Debug, Clone, PartialEq, Eq)]
4441pub struct ParenthesizedPattern<'tree> {
4442 pub span: ::treesitter_types::Span,
4443 pub children: PatternExpr<'tree>,
4444}
4445impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedPattern<'tree> {
4446 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4447 fn from_node(
4448 node: ::tree_sitter::Node<'tree>,
4449 src: &'tree [u8],
4450 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4451 debug_assert_eq!(node.kind(), "parenthesized_pattern");
4452 Ok(Self {
4453 span: ::treesitter_types::Span::from(node),
4454 children: {
4455 #[allow(clippy::suspicious_else_formatting)]
4456 let non_field_children = {
4457 let mut cursor = node.walk();
4458 let mut result = ::std::vec::Vec::new();
4459 if cursor.goto_first_child() {
4460 loop {
4461 if cursor.field_name().is_none()
4462 && cursor.node().is_named()
4463 && !cursor.node().is_extra()
4464 {
4465 result.push(cursor.node());
4466 }
4467 if !cursor.goto_next_sibling() {
4468 break;
4469 }
4470 }
4471 }
4472 result
4473 };
4474 let child = if let Some(&c) = non_field_children.first() {
4475 c
4476 } else {
4477 let mut fallback_cursor = node.walk();
4478 let mut fallback_child = None;
4479 if fallback_cursor.goto_first_child() {
4480 loop {
4481 if fallback_cursor.field_name().is_none()
4482 && !fallback_cursor.node().is_extra()
4483 {
4484 let candidate = fallback_cursor.node();
4485 #[allow(clippy::needless_question_mark)]
4486 if (|| -> ::core::result::Result<
4487 _,
4488 ::treesitter_types::ParseError,
4489 > {
4490 let child = candidate;
4491 Ok(
4492 <PatternExpr as ::treesitter_types::FromNode>::from_node(
4493 child,
4494 src,
4495 )?,
4496 )
4497 })()
4498 .is_ok()
4499 {
4500 fallback_child = Some(candidate);
4501 break;
4502 }
4503 }
4504 if !fallback_cursor.goto_next_sibling() {
4505 break;
4506 }
4507 }
4508 }
4509 if fallback_child.is_none() {
4510 let mut cursor2 = node.walk();
4511 if cursor2.goto_first_child() {
4512 loop {
4513 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4514 let candidate = cursor2.node();
4515 #[allow(clippy::needless_question_mark)]
4516 if (|| -> ::core::result::Result<
4517 _,
4518 ::treesitter_types::ParseError,
4519 > {
4520 let child = candidate;
4521 Ok(
4522 <PatternExpr as ::treesitter_types::FromNode>::from_node(
4523 child,
4524 src,
4525 )?,
4526 )
4527 })()
4528 .is_ok()
4529 {
4530 fallback_child = Some(candidate);
4531 break;
4532 }
4533 }
4534 if !cursor2.goto_next_sibling() {
4535 break;
4536 }
4537 }
4538 }
4539 }
4540 fallback_child.ok_or_else(|| {
4541 ::treesitter_types::ParseError::missing_field("children", node)
4542 })?
4543 };
4544 <PatternExpr as ::treesitter_types::FromNode>::from_node(child, src)?
4545 },
4546 })
4547 }
4548}
4549impl ::treesitter_types::Spanned for ParenthesizedPattern<'_> {
4550 fn span(&self) -> ::treesitter_types::Span {
4551 self.span
4552 }
4553}
4554#[derive(Debug, Clone, PartialEq, Eq)]
4555pub struct ParenthesizedStatements<'tree> {
4556 pub span: ::treesitter_types::Span,
4557 pub children: ::std::vec::Vec<ParenthesizedStatementsChildren<'tree>>,
4558}
4559impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedStatements<'tree> {
4560 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4561 fn from_node(
4562 node: ::tree_sitter::Node<'tree>,
4563 src: &'tree [u8],
4564 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4565 debug_assert_eq!(node.kind(), "parenthesized_statements");
4566 Ok(Self {
4567 span: ::treesitter_types::Span::from(node),
4568 children: {
4569 #[allow(clippy::suspicious_else_formatting)]
4570 let non_field_children = {
4571 let mut cursor = node.walk();
4572 let mut result = ::std::vec::Vec::new();
4573 if cursor.goto_first_child() {
4574 loop {
4575 if cursor.field_name().is_none()
4576 && cursor.node().is_named()
4577 && !cursor.node().is_extra()
4578 {
4579 result.push(cursor.node());
4580 }
4581 if !cursor.goto_next_sibling() {
4582 break;
4583 }
4584 }
4585 }
4586 result
4587 };
4588 let mut items = ::std::vec::Vec::new();
4589 for child in non_field_children {
4590 items
4591 .push(
4592 <ParenthesizedStatementsChildren as ::treesitter_types::FromNode>::from_node(
4593 child,
4594 src,
4595 )?,
4596 );
4597 }
4598 items
4599 },
4600 })
4601 }
4602}
4603impl ::treesitter_types::Spanned for ParenthesizedStatements<'_> {
4604 fn span(&self) -> ::treesitter_types::Span {
4605 self.span
4606 }
4607}
4608#[derive(Debug, Clone, PartialEq, Eq)]
4609pub struct Pattern<'tree> {
4610 pub span: ::treesitter_types::Span,
4611 pub children: PatternChildren<'tree>,
4612}
4613impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
4614 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4615 fn from_node(
4616 node: ::tree_sitter::Node<'tree>,
4617 src: &'tree [u8],
4618 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4619 debug_assert_eq!(node.kind(), "pattern");
4620 Ok(Self {
4621 span: ::treesitter_types::Span::from(node),
4622 children: {
4623 #[allow(clippy::suspicious_else_formatting)]
4624 let non_field_children = {
4625 let mut cursor = node.walk();
4626 let mut result = ::std::vec::Vec::new();
4627 if cursor.goto_first_child() {
4628 loop {
4629 if cursor.field_name().is_none()
4630 && cursor.node().is_named()
4631 && !cursor.node().is_extra()
4632 {
4633 result.push(cursor.node());
4634 }
4635 if !cursor.goto_next_sibling() {
4636 break;
4637 }
4638 }
4639 }
4640 result
4641 };
4642 let child = if let Some(&c) = non_field_children.first() {
4643 c
4644 } else {
4645 let mut fallback_cursor = node.walk();
4646 let mut fallback_child = None;
4647 if fallback_cursor.goto_first_child() {
4648 loop {
4649 if fallback_cursor.field_name().is_none()
4650 && !fallback_cursor.node().is_extra()
4651 {
4652 let candidate = fallback_cursor.node();
4653 #[allow(clippy::needless_question_mark)]
4654 if (|| -> ::core::result::Result<
4655 _,
4656 ::treesitter_types::ParseError,
4657 > {
4658 let child = candidate;
4659 Ok(
4660 <PatternChildren as ::treesitter_types::FromNode>::from_node(
4661 child,
4662 src,
4663 )?,
4664 )
4665 })()
4666 .is_ok()
4667 {
4668 fallback_child = Some(candidate);
4669 break;
4670 }
4671 }
4672 if !fallback_cursor.goto_next_sibling() {
4673 break;
4674 }
4675 }
4676 }
4677 if fallback_child.is_none() {
4678 let mut cursor2 = node.walk();
4679 if cursor2.goto_first_child() {
4680 loop {
4681 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4682 let candidate = cursor2.node();
4683 #[allow(clippy::needless_question_mark)]
4684 if (|| -> ::core::result::Result<
4685 _,
4686 ::treesitter_types::ParseError,
4687 > {
4688 let child = candidate;
4689 Ok(
4690 <PatternChildren as ::treesitter_types::FromNode>::from_node(
4691 child,
4692 src,
4693 )?,
4694 )
4695 })()
4696 .is_ok()
4697 {
4698 fallback_child = Some(candidate);
4699 break;
4700 }
4701 }
4702 if !cursor2.goto_next_sibling() {
4703 break;
4704 }
4705 }
4706 }
4707 }
4708 fallback_child.ok_or_else(|| {
4709 ::treesitter_types::ParseError::missing_field("children", node)
4710 })?
4711 };
4712 <PatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4713 },
4714 })
4715 }
4716}
4717impl ::treesitter_types::Spanned for Pattern<'_> {
4718 fn span(&self) -> ::treesitter_types::Span {
4719 self.span
4720 }
4721}
4722#[derive(Debug, Clone, PartialEq, Eq)]
4723pub struct Program<'tree> {
4724 pub span: ::treesitter_types::Span,
4725 pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
4726}
4727impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
4728 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4729 fn from_node(
4730 node: ::tree_sitter::Node<'tree>,
4731 src: &'tree [u8],
4732 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4733 debug_assert_eq!(node.kind(), "program");
4734 Ok(Self {
4735 span: ::treesitter_types::Span::from(node),
4736 children: {
4737 #[allow(clippy::suspicious_else_formatting)]
4738 let non_field_children = {
4739 let mut cursor = node.walk();
4740 let mut result = ::std::vec::Vec::new();
4741 if cursor.goto_first_child() {
4742 loop {
4743 if cursor.field_name().is_none()
4744 && cursor.node().is_named()
4745 && !cursor.node().is_extra()
4746 {
4747 result.push(cursor.node());
4748 }
4749 if !cursor.goto_next_sibling() {
4750 break;
4751 }
4752 }
4753 }
4754 result
4755 };
4756 let mut items = ::std::vec::Vec::new();
4757 for child in non_field_children {
4758 items.push(
4759 <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
4760 );
4761 }
4762 items
4763 },
4764 })
4765 }
4766}
4767impl ::treesitter_types::Spanned for Program<'_> {
4768 fn span(&self) -> ::treesitter_types::Span {
4769 self.span
4770 }
4771}
4772#[derive(Debug, Clone, PartialEq, Eq)]
4773pub struct Range<'tree> {
4774 pub span: ::treesitter_types::Span,
4775 pub begin: ::core::option::Option<RangeBegin<'tree>>,
4776 pub end: ::core::option::Option<RangeEnd<'tree>>,
4777 pub operator: RangeOperator,
4778}
4779impl<'tree> ::treesitter_types::FromNode<'tree> for Range<'tree> {
4780 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4781 fn from_node(
4782 node: ::tree_sitter::Node<'tree>,
4783 src: &'tree [u8],
4784 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4785 debug_assert_eq!(node.kind(), "range");
4786 Ok(Self {
4787 span: ::treesitter_types::Span::from(node),
4788 begin: match node.child_by_field_name("begin") {
4789 Some(child) => Some(<RangeBegin as ::treesitter_types::FromNode>::from_node(
4790 child, src,
4791 )?),
4792 None => None,
4793 },
4794 end: match node.child_by_field_name("end") {
4795 Some(child) => Some(<RangeEnd as ::treesitter_types::FromNode>::from_node(
4796 child, src,
4797 )?),
4798 None => None,
4799 },
4800 operator: {
4801 let child = node.child_by_field_name("operator").ok_or_else(|| {
4802 ::treesitter_types::ParseError::missing_field("operator", node)
4803 })?;
4804 <RangeOperator as ::treesitter_types::FromNode>::from_node(child, src)?
4805 },
4806 })
4807 }
4808}
4809impl ::treesitter_types::Spanned for Range<'_> {
4810 fn span(&self) -> ::treesitter_types::Span {
4811 self.span
4812 }
4813}
4814#[derive(Debug, Clone, PartialEq, Eq)]
4815pub struct Rational<'tree> {
4816 pub span: ::treesitter_types::Span,
4817 pub children: RationalChildren<'tree>,
4818}
4819impl<'tree> ::treesitter_types::FromNode<'tree> for Rational<'tree> {
4820 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4821 fn from_node(
4822 node: ::tree_sitter::Node<'tree>,
4823 src: &'tree [u8],
4824 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4825 debug_assert_eq!(node.kind(), "rational");
4826 Ok(Self {
4827 span: ::treesitter_types::Span::from(node),
4828 children: {
4829 #[allow(clippy::suspicious_else_formatting)]
4830 let non_field_children = {
4831 let mut cursor = node.walk();
4832 let mut result = ::std::vec::Vec::new();
4833 if cursor.goto_first_child() {
4834 loop {
4835 if cursor.field_name().is_none()
4836 && cursor.node().is_named()
4837 && !cursor.node().is_extra()
4838 {
4839 result.push(cursor.node());
4840 }
4841 if !cursor.goto_next_sibling() {
4842 break;
4843 }
4844 }
4845 }
4846 result
4847 };
4848 let child = if let Some(&c) = non_field_children.first() {
4849 c
4850 } else {
4851 let mut fallback_cursor = node.walk();
4852 let mut fallback_child = None;
4853 if fallback_cursor.goto_first_child() {
4854 loop {
4855 if fallback_cursor.field_name().is_none()
4856 && !fallback_cursor.node().is_extra()
4857 {
4858 let candidate = fallback_cursor.node();
4859 #[allow(clippy::needless_question_mark)]
4860 if (|| -> ::core::result::Result<
4861 _,
4862 ::treesitter_types::ParseError,
4863 > {
4864 let child = candidate;
4865 Ok(
4866 <RationalChildren as ::treesitter_types::FromNode>::from_node(
4867 child,
4868 src,
4869 )?,
4870 )
4871 })()
4872 .is_ok()
4873 {
4874 fallback_child = Some(candidate);
4875 break;
4876 }
4877 }
4878 if !fallback_cursor.goto_next_sibling() {
4879 break;
4880 }
4881 }
4882 }
4883 if fallback_child.is_none() {
4884 let mut cursor2 = node.walk();
4885 if cursor2.goto_first_child() {
4886 loop {
4887 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4888 let candidate = cursor2.node();
4889 #[allow(clippy::needless_question_mark)]
4890 if (|| -> ::core::result::Result<
4891 _,
4892 ::treesitter_types::ParseError,
4893 > {
4894 let child = candidate;
4895 Ok(
4896 <RationalChildren as ::treesitter_types::FromNode>::from_node(
4897 child,
4898 src,
4899 )?,
4900 )
4901 })()
4902 .is_ok()
4903 {
4904 fallback_child = Some(candidate);
4905 break;
4906 }
4907 }
4908 if !cursor2.goto_next_sibling() {
4909 break;
4910 }
4911 }
4912 }
4913 }
4914 fallback_child.ok_or_else(|| {
4915 ::treesitter_types::ParseError::missing_field("children", node)
4916 })?
4917 };
4918 <RationalChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4919 },
4920 })
4921 }
4922}
4923impl ::treesitter_types::Spanned for Rational<'_> {
4924 fn span(&self) -> ::treesitter_types::Span {
4925 self.span
4926 }
4927}
4928#[derive(Debug, Clone, PartialEq, Eq)]
4929pub struct Redo<'tree> {
4930 pub span: ::treesitter_types::Span,
4931 pub children: ::core::option::Option<ArgumentList<'tree>>,
4932}
4933impl<'tree> ::treesitter_types::FromNode<'tree> for Redo<'tree> {
4934 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4935 fn from_node(
4936 node: ::tree_sitter::Node<'tree>,
4937 src: &'tree [u8],
4938 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4939 debug_assert_eq!(node.kind(), "redo");
4940 Ok(Self {
4941 span: ::treesitter_types::Span::from(node),
4942 children: {
4943 #[allow(clippy::suspicious_else_formatting)]
4944 let non_field_children = {
4945 let mut cursor = node.walk();
4946 let mut result = ::std::vec::Vec::new();
4947 if cursor.goto_first_child() {
4948 loop {
4949 if cursor.field_name().is_none()
4950 && cursor.node().is_named()
4951 && !cursor.node().is_extra()
4952 {
4953 result.push(cursor.node());
4954 }
4955 if !cursor.goto_next_sibling() {
4956 break;
4957 }
4958 }
4959 }
4960 result
4961 };
4962 match non_field_children.first() {
4963 Some(&child) => Some(
4964 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?,
4965 ),
4966 None => None,
4967 }
4968 },
4969 })
4970 }
4971}
4972impl ::treesitter_types::Spanned for Redo<'_> {
4973 fn span(&self) -> ::treesitter_types::Span {
4974 self.span
4975 }
4976}
4977#[derive(Debug, Clone, PartialEq, Eq)]
4978pub struct Regex<'tree> {
4979 pub span: ::treesitter_types::Span,
4980 pub children: ::std::vec::Vec<RegexChildren<'tree>>,
4981}
4982impl<'tree> ::treesitter_types::FromNode<'tree> for Regex<'tree> {
4983 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4984 fn from_node(
4985 node: ::tree_sitter::Node<'tree>,
4986 src: &'tree [u8],
4987 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4988 debug_assert_eq!(node.kind(), "regex");
4989 Ok(Self {
4990 span: ::treesitter_types::Span::from(node),
4991 children: {
4992 #[allow(clippy::suspicious_else_formatting)]
4993 let non_field_children = {
4994 let mut cursor = node.walk();
4995 let mut result = ::std::vec::Vec::new();
4996 if cursor.goto_first_child() {
4997 loop {
4998 if cursor.field_name().is_none()
4999 && cursor.node().is_named()
5000 && !cursor.node().is_extra()
5001 {
5002 result.push(cursor.node());
5003 }
5004 if !cursor.goto_next_sibling() {
5005 break;
5006 }
5007 }
5008 }
5009 result
5010 };
5011 let mut items = ::std::vec::Vec::new();
5012 for child in non_field_children {
5013 items.push(<RegexChildren as ::treesitter_types::FromNode>::from_node(
5014 child, src,
5015 )?);
5016 }
5017 items
5018 },
5019 })
5020 }
5021}
5022impl ::treesitter_types::Spanned for Regex<'_> {
5023 fn span(&self) -> ::treesitter_types::Span {
5024 self.span
5025 }
5026}
5027#[derive(Debug, Clone, PartialEq, Eq)]
5028pub struct Rescue<'tree> {
5029 pub span: ::treesitter_types::Span,
5030 pub body: ::core::option::Option<Then<'tree>>,
5031 pub exceptions: ::core::option::Option<Exceptions<'tree>>,
5032 pub variable: ::core::option::Option<ExceptionVariable<'tree>>,
5033}
5034impl<'tree> ::treesitter_types::FromNode<'tree> for Rescue<'tree> {
5035 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5036 fn from_node(
5037 node: ::tree_sitter::Node<'tree>,
5038 src: &'tree [u8],
5039 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5040 debug_assert_eq!(node.kind(), "rescue");
5041 Ok(Self {
5042 span: ::treesitter_types::Span::from(node),
5043 body: match node.child_by_field_name("body") {
5044 Some(child) => Some(<Then as ::treesitter_types::FromNode>::from_node(
5045 child, src,
5046 )?),
5047 None => None,
5048 },
5049 exceptions: match node.child_by_field_name("exceptions") {
5050 Some(child) => Some(<Exceptions as ::treesitter_types::FromNode>::from_node(
5051 child, src,
5052 )?),
5053 None => None,
5054 },
5055 variable: match node.child_by_field_name("variable") {
5056 Some(child) => Some(
5057 <ExceptionVariable as ::treesitter_types::FromNode>::from_node(child, src)?,
5058 ),
5059 None => None,
5060 },
5061 })
5062 }
5063}
5064impl ::treesitter_types::Spanned for Rescue<'_> {
5065 fn span(&self) -> ::treesitter_types::Span {
5066 self.span
5067 }
5068}
5069#[derive(Debug, Clone, PartialEq, Eq)]
5070pub struct RescueModifier<'tree> {
5071 pub span: ::treesitter_types::Span,
5072 pub body: RescueModifierBody<'tree>,
5073 pub handler: Expression<'tree>,
5074}
5075impl<'tree> ::treesitter_types::FromNode<'tree> for RescueModifier<'tree> {
5076 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5077 fn from_node(
5078 node: ::tree_sitter::Node<'tree>,
5079 src: &'tree [u8],
5080 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5081 debug_assert_eq!(node.kind(), "rescue_modifier");
5082 Ok(Self {
5083 span: ::treesitter_types::Span::from(node),
5084 body: {
5085 let child = node
5086 .child_by_field_name("body")
5087 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5088 <RescueModifierBody as ::treesitter_types::FromNode>::from_node(child, src)?
5089 },
5090 handler: {
5091 let child = node.child_by_field_name("handler").ok_or_else(|| {
5092 ::treesitter_types::ParseError::missing_field("handler", node)
5093 })?;
5094 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5095 },
5096 })
5097 }
5098}
5099impl ::treesitter_types::Spanned for RescueModifier<'_> {
5100 fn span(&self) -> ::treesitter_types::Span {
5101 self.span
5102 }
5103}
5104#[derive(Debug, Clone, PartialEq, Eq)]
5105pub struct RestAssignment<'tree> {
5106 pub span: ::treesitter_types::Span,
5107 pub children: ::core::option::Option<Lhs<'tree>>,
5108}
5109impl<'tree> ::treesitter_types::FromNode<'tree> for RestAssignment<'tree> {
5110 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5111 fn from_node(
5112 node: ::tree_sitter::Node<'tree>,
5113 src: &'tree [u8],
5114 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5115 debug_assert_eq!(node.kind(), "rest_assignment");
5116 Ok(Self {
5117 span: ::treesitter_types::Span::from(node),
5118 children: {
5119 #[allow(clippy::suspicious_else_formatting)]
5120 let non_field_children = {
5121 let mut cursor = node.walk();
5122 let mut result = ::std::vec::Vec::new();
5123 if cursor.goto_first_child() {
5124 loop {
5125 if cursor.field_name().is_none()
5126 && cursor.node().is_named()
5127 && !cursor.node().is_extra()
5128 {
5129 result.push(cursor.node());
5130 }
5131 if !cursor.goto_next_sibling() {
5132 break;
5133 }
5134 }
5135 }
5136 result
5137 };
5138 match non_field_children.first() {
5139 Some(&child) => Some(<Lhs as ::treesitter_types::FromNode>::from_node(
5140 child, src,
5141 )?),
5142 None => None,
5143 }
5144 },
5145 })
5146 }
5147}
5148impl ::treesitter_types::Spanned for RestAssignment<'_> {
5149 fn span(&self) -> ::treesitter_types::Span {
5150 self.span
5151 }
5152}
5153#[derive(Debug, Clone, PartialEq, Eq)]
5154pub struct Retry<'tree> {
5155 pub span: ::treesitter_types::Span,
5156 pub children: ::core::option::Option<ArgumentList<'tree>>,
5157}
5158impl<'tree> ::treesitter_types::FromNode<'tree> for Retry<'tree> {
5159 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5160 fn from_node(
5161 node: ::tree_sitter::Node<'tree>,
5162 src: &'tree [u8],
5163 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5164 debug_assert_eq!(node.kind(), "retry");
5165 Ok(Self {
5166 span: ::treesitter_types::Span::from(node),
5167 children: {
5168 #[allow(clippy::suspicious_else_formatting)]
5169 let non_field_children = {
5170 let mut cursor = node.walk();
5171 let mut result = ::std::vec::Vec::new();
5172 if cursor.goto_first_child() {
5173 loop {
5174 if cursor.field_name().is_none()
5175 && cursor.node().is_named()
5176 && !cursor.node().is_extra()
5177 {
5178 result.push(cursor.node());
5179 }
5180 if !cursor.goto_next_sibling() {
5181 break;
5182 }
5183 }
5184 }
5185 result
5186 };
5187 match non_field_children.first() {
5188 Some(&child) => Some(
5189 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?,
5190 ),
5191 None => None,
5192 }
5193 },
5194 })
5195 }
5196}
5197impl ::treesitter_types::Spanned for Retry<'_> {
5198 fn span(&self) -> ::treesitter_types::Span {
5199 self.span
5200 }
5201}
5202#[derive(Debug, Clone, PartialEq, Eq)]
5203pub struct Return<'tree> {
5204 pub span: ::treesitter_types::Span,
5205 pub children: ::core::option::Option<ArgumentList<'tree>>,
5206}
5207impl<'tree> ::treesitter_types::FromNode<'tree> for Return<'tree> {
5208 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5209 fn from_node(
5210 node: ::tree_sitter::Node<'tree>,
5211 src: &'tree [u8],
5212 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5213 debug_assert_eq!(node.kind(), "return");
5214 Ok(Self {
5215 span: ::treesitter_types::Span::from(node),
5216 children: {
5217 #[allow(clippy::suspicious_else_formatting)]
5218 let non_field_children = {
5219 let mut cursor = node.walk();
5220 let mut result = ::std::vec::Vec::new();
5221 if cursor.goto_first_child() {
5222 loop {
5223 if cursor.field_name().is_none()
5224 && cursor.node().is_named()
5225 && !cursor.node().is_extra()
5226 {
5227 result.push(cursor.node());
5228 }
5229 if !cursor.goto_next_sibling() {
5230 break;
5231 }
5232 }
5233 }
5234 result
5235 };
5236 match non_field_children.first() {
5237 Some(&child) => Some(
5238 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?,
5239 ),
5240 None => None,
5241 }
5242 },
5243 })
5244 }
5245}
5246impl ::treesitter_types::Spanned for Return<'_> {
5247 fn span(&self) -> ::treesitter_types::Span {
5248 self.span
5249 }
5250}
5251#[derive(Debug, Clone, PartialEq, Eq)]
5252pub struct RightAssignmentList<'tree> {
5253 pub span: ::treesitter_types::Span,
5254 pub children: ::std::vec::Vec<RightAssignmentListChildren<'tree>>,
5255}
5256impl<'tree> ::treesitter_types::FromNode<'tree> for RightAssignmentList<'tree> {
5257 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5258 fn from_node(
5259 node: ::tree_sitter::Node<'tree>,
5260 src: &'tree [u8],
5261 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5262 debug_assert_eq!(node.kind(), "right_assignment_list");
5263 Ok(Self {
5264 span: ::treesitter_types::Span::from(node),
5265 children: {
5266 #[allow(clippy::suspicious_else_formatting)]
5267 let non_field_children = {
5268 let mut cursor = node.walk();
5269 let mut result = ::std::vec::Vec::new();
5270 if cursor.goto_first_child() {
5271 loop {
5272 if cursor.field_name().is_none()
5273 && cursor.node().is_named()
5274 && !cursor.node().is_extra()
5275 {
5276 result.push(cursor.node());
5277 }
5278 if !cursor.goto_next_sibling() {
5279 break;
5280 }
5281 }
5282 }
5283 result
5284 };
5285 let mut items = ::std::vec::Vec::new();
5286 for child in non_field_children {
5287 items.push(
5288 <RightAssignmentListChildren as ::treesitter_types::FromNode>::from_node(
5289 child, src,
5290 )?,
5291 );
5292 }
5293 items
5294 },
5295 })
5296 }
5297}
5298impl ::treesitter_types::Spanned for RightAssignmentList<'_> {
5299 fn span(&self) -> ::treesitter_types::Span {
5300 self.span
5301 }
5302}
5303#[derive(Debug, Clone, PartialEq, Eq)]
5304pub struct ScopeResolution<'tree> {
5305 pub span: ::treesitter_types::Span,
5306 pub name: Constant<'tree>,
5307 pub scope: ::core::option::Option<ScopeResolutionScope<'tree>>,
5308}
5309impl<'tree> ::treesitter_types::FromNode<'tree> for ScopeResolution<'tree> {
5310 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5311 fn from_node(
5312 node: ::tree_sitter::Node<'tree>,
5313 src: &'tree [u8],
5314 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5315 debug_assert_eq!(node.kind(), "scope_resolution");
5316 Ok(Self {
5317 span: ::treesitter_types::Span::from(node),
5318 name: {
5319 let child = node
5320 .child_by_field_name("name")
5321 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5322 <Constant as ::treesitter_types::FromNode>::from_node(child, src)?
5323 },
5324 scope: match node.child_by_field_name("scope") {
5325 Some(child) => Some(
5326 <ScopeResolutionScope as ::treesitter_types::FromNode>::from_node(child, src)?,
5327 ),
5328 None => None,
5329 },
5330 })
5331 }
5332}
5333impl ::treesitter_types::Spanned for ScopeResolution<'_> {
5334 fn span(&self) -> ::treesitter_types::Span {
5335 self.span
5336 }
5337}
5338#[derive(Debug, Clone, PartialEq, Eq)]
5339pub struct Setter<'tree> {
5340 pub span: ::treesitter_types::Span,
5341 pub name: Identifier<'tree>,
5342}
5343impl<'tree> ::treesitter_types::FromNode<'tree> for Setter<'tree> {
5344 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5345 fn from_node(
5346 node: ::tree_sitter::Node<'tree>,
5347 src: &'tree [u8],
5348 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5349 debug_assert_eq!(node.kind(), "setter");
5350 Ok(Self {
5351 span: ::treesitter_types::Span::from(node),
5352 name: {
5353 let child = node
5354 .child_by_field_name("name")
5355 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5356 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
5357 },
5358 })
5359 }
5360}
5361impl ::treesitter_types::Spanned for Setter<'_> {
5362 fn span(&self) -> ::treesitter_types::Span {
5363 self.span
5364 }
5365}
5366#[derive(Debug, Clone, PartialEq, Eq)]
5367pub struct SingletonClass<'tree> {
5368 pub span: ::treesitter_types::Span,
5369 pub body: ::core::option::Option<BodyStatement<'tree>>,
5370 pub value: Arg<'tree>,
5371}
5372impl<'tree> ::treesitter_types::FromNode<'tree> for SingletonClass<'tree> {
5373 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5374 fn from_node(
5375 node: ::tree_sitter::Node<'tree>,
5376 src: &'tree [u8],
5377 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5378 debug_assert_eq!(node.kind(), "singleton_class");
5379 Ok(Self {
5380 span: ::treesitter_types::Span::from(node),
5381 body: match node.child_by_field_name("body") {
5382 Some(child) => Some(<BodyStatement as ::treesitter_types::FromNode>::from_node(
5383 child, src,
5384 )?),
5385 None => None,
5386 },
5387 value: {
5388 let child = node
5389 .child_by_field_name("value")
5390 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5391 <Arg as ::treesitter_types::FromNode>::from_node(child, src)?
5392 },
5393 })
5394 }
5395}
5396impl ::treesitter_types::Spanned for SingletonClass<'_> {
5397 fn span(&self) -> ::treesitter_types::Span {
5398 self.span
5399 }
5400}
5401#[derive(Debug, Clone, PartialEq, Eq)]
5402pub struct SingletonMethod<'tree> {
5403 pub span: ::treesitter_types::Span,
5404 pub body: ::core::option::Option<SingletonMethodBody<'tree>>,
5405 pub name: MethodName<'tree>,
5406 pub object: SingletonMethodObject<'tree>,
5407 pub parameters: ::core::option::Option<MethodParameters<'tree>>,
5408}
5409impl<'tree> ::treesitter_types::FromNode<'tree> for SingletonMethod<'tree> {
5410 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5411 fn from_node(
5412 node: ::tree_sitter::Node<'tree>,
5413 src: &'tree [u8],
5414 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5415 debug_assert_eq!(node.kind(), "singleton_method");
5416 Ok(Self {
5417 span: ::treesitter_types::Span::from(node),
5418 body: match node.child_by_field_name("body") {
5419 Some(child) => Some(
5420 <SingletonMethodBody as ::treesitter_types::FromNode>::from_node(child, src)?,
5421 ),
5422 None => None,
5423 },
5424 name: {
5425 let child = node
5426 .child_by_field_name("name")
5427 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5428 <MethodName as ::treesitter_types::FromNode>::from_node(child, src)?
5429 },
5430 object: {
5431 let child = node
5432 .child_by_field_name("object")
5433 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5434 <SingletonMethodObject as ::treesitter_types::FromNode>::from_node(child, src)?
5435 },
5436 parameters: match node.child_by_field_name("parameters") {
5437 Some(child) => {
5438 Some(<MethodParameters as ::treesitter_types::FromNode>::from_node(child, src)?)
5439 }
5440 None => None,
5441 },
5442 })
5443 }
5444}
5445impl ::treesitter_types::Spanned for SingletonMethod<'_> {
5446 fn span(&self) -> ::treesitter_types::Span {
5447 self.span
5448 }
5449}
5450#[derive(Debug, Clone, PartialEq, Eq)]
5451pub struct SplatArgument<'tree> {
5452 pub span: ::treesitter_types::Span,
5453 pub children: ::core::option::Option<Arg<'tree>>,
5454}
5455impl<'tree> ::treesitter_types::FromNode<'tree> for SplatArgument<'tree> {
5456 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5457 fn from_node(
5458 node: ::tree_sitter::Node<'tree>,
5459 src: &'tree [u8],
5460 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5461 debug_assert_eq!(node.kind(), "splat_argument");
5462 Ok(Self {
5463 span: ::treesitter_types::Span::from(node),
5464 children: {
5465 #[allow(clippy::suspicious_else_formatting)]
5466 let non_field_children = {
5467 let mut cursor = node.walk();
5468 let mut result = ::std::vec::Vec::new();
5469 if cursor.goto_first_child() {
5470 loop {
5471 if cursor.field_name().is_none()
5472 && cursor.node().is_named()
5473 && !cursor.node().is_extra()
5474 {
5475 result.push(cursor.node());
5476 }
5477 if !cursor.goto_next_sibling() {
5478 break;
5479 }
5480 }
5481 }
5482 result
5483 };
5484 match non_field_children.first() {
5485 Some(&child) => Some(<Arg as ::treesitter_types::FromNode>::from_node(
5486 child, src,
5487 )?),
5488 None => None,
5489 }
5490 },
5491 })
5492 }
5493}
5494impl ::treesitter_types::Spanned for SplatArgument<'_> {
5495 fn span(&self) -> ::treesitter_types::Span {
5496 self.span
5497 }
5498}
5499#[derive(Debug, Clone, PartialEq, Eq)]
5500pub struct SplatParameter<'tree> {
5501 pub span: ::treesitter_types::Span,
5502 pub name: ::core::option::Option<Identifier<'tree>>,
5503}
5504impl<'tree> ::treesitter_types::FromNode<'tree> for SplatParameter<'tree> {
5505 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5506 fn from_node(
5507 node: ::tree_sitter::Node<'tree>,
5508 src: &'tree [u8],
5509 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5510 debug_assert_eq!(node.kind(), "splat_parameter");
5511 Ok(Self {
5512 span: ::treesitter_types::Span::from(node),
5513 name: match node.child_by_field_name("name") {
5514 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
5515 child, src,
5516 )?),
5517 None => None,
5518 },
5519 })
5520 }
5521}
5522impl ::treesitter_types::Spanned for SplatParameter<'_> {
5523 fn span(&self) -> ::treesitter_types::Span {
5524 self.span
5525 }
5526}
5527#[derive(Debug, Clone, PartialEq, Eq)]
5528pub struct String<'tree> {
5529 pub span: ::treesitter_types::Span,
5530 pub children: ::std::vec::Vec<StringChildren<'tree>>,
5531}
5532impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
5533 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5534 fn from_node(
5535 node: ::tree_sitter::Node<'tree>,
5536 src: &'tree [u8],
5537 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5538 debug_assert_eq!(node.kind(), "string");
5539 Ok(Self {
5540 span: ::treesitter_types::Span::from(node),
5541 children: {
5542 #[allow(clippy::suspicious_else_formatting)]
5543 let non_field_children = {
5544 let mut cursor = node.walk();
5545 let mut result = ::std::vec::Vec::new();
5546 if cursor.goto_first_child() {
5547 loop {
5548 if cursor.field_name().is_none()
5549 && cursor.node().is_named()
5550 && !cursor.node().is_extra()
5551 {
5552 result.push(cursor.node());
5553 }
5554 if !cursor.goto_next_sibling() {
5555 break;
5556 }
5557 }
5558 }
5559 result
5560 };
5561 let mut items = ::std::vec::Vec::new();
5562 for child in non_field_children {
5563 items.push(<StringChildren as ::treesitter_types::FromNode>::from_node(
5564 child, src,
5565 )?);
5566 }
5567 items
5568 },
5569 })
5570 }
5571}
5572impl ::treesitter_types::Spanned for String<'_> {
5573 fn span(&self) -> ::treesitter_types::Span {
5574 self.span
5575 }
5576}
5577#[derive(Debug, Clone, PartialEq, Eq)]
5578pub struct StringArray<'tree> {
5579 pub span: ::treesitter_types::Span,
5580 pub children: ::std::vec::Vec<BareString<'tree>>,
5581}
5582impl<'tree> ::treesitter_types::FromNode<'tree> for StringArray<'tree> {
5583 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5584 fn from_node(
5585 node: ::tree_sitter::Node<'tree>,
5586 src: &'tree [u8],
5587 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5588 debug_assert_eq!(node.kind(), "string_array");
5589 Ok(Self {
5590 span: ::treesitter_types::Span::from(node),
5591 children: {
5592 #[allow(clippy::suspicious_else_formatting)]
5593 let non_field_children = {
5594 let mut cursor = node.walk();
5595 let mut result = ::std::vec::Vec::new();
5596 if cursor.goto_first_child() {
5597 loop {
5598 if cursor.field_name().is_none()
5599 && cursor.node().is_named()
5600 && !cursor.node().is_extra()
5601 {
5602 result.push(cursor.node());
5603 }
5604 if !cursor.goto_next_sibling() {
5605 break;
5606 }
5607 }
5608 }
5609 result
5610 };
5611 let mut items = ::std::vec::Vec::new();
5612 for child in non_field_children {
5613 items.push(<BareString as ::treesitter_types::FromNode>::from_node(
5614 child, src,
5615 )?);
5616 }
5617 items
5618 },
5619 })
5620 }
5621}
5622impl ::treesitter_types::Spanned for StringArray<'_> {
5623 fn span(&self) -> ::treesitter_types::Span {
5624 self.span
5625 }
5626}
5627#[derive(Debug, Clone, PartialEq, Eq)]
5628pub struct Subshell<'tree> {
5629 pub span: ::treesitter_types::Span,
5630 pub children: ::std::vec::Vec<SubshellChildren<'tree>>,
5631}
5632impl<'tree> ::treesitter_types::FromNode<'tree> for Subshell<'tree> {
5633 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5634 fn from_node(
5635 node: ::tree_sitter::Node<'tree>,
5636 src: &'tree [u8],
5637 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5638 debug_assert_eq!(node.kind(), "subshell");
5639 Ok(Self {
5640 span: ::treesitter_types::Span::from(node),
5641 children: {
5642 #[allow(clippy::suspicious_else_formatting)]
5643 let non_field_children = {
5644 let mut cursor = node.walk();
5645 let mut result = ::std::vec::Vec::new();
5646 if cursor.goto_first_child() {
5647 loop {
5648 if cursor.field_name().is_none()
5649 && cursor.node().is_named()
5650 && !cursor.node().is_extra()
5651 {
5652 result.push(cursor.node());
5653 }
5654 if !cursor.goto_next_sibling() {
5655 break;
5656 }
5657 }
5658 }
5659 result
5660 };
5661 let mut items = ::std::vec::Vec::new();
5662 for child in non_field_children {
5663 items.push(
5664 <SubshellChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
5665 );
5666 }
5667 items
5668 },
5669 })
5670 }
5671}
5672impl ::treesitter_types::Spanned for Subshell<'_> {
5673 fn span(&self) -> ::treesitter_types::Span {
5674 self.span
5675 }
5676}
5677#[derive(Debug, Clone, PartialEq, Eq)]
5678pub struct Superclass<'tree> {
5679 pub span: ::treesitter_types::Span,
5680 pub children: Expression<'tree>,
5681}
5682impl<'tree> ::treesitter_types::FromNode<'tree> for Superclass<'tree> {
5683 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5684 fn from_node(
5685 node: ::tree_sitter::Node<'tree>,
5686 src: &'tree [u8],
5687 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5688 debug_assert_eq!(node.kind(), "superclass");
5689 Ok(Self {
5690 span: ::treesitter_types::Span::from(node),
5691 children: {
5692 #[allow(clippy::suspicious_else_formatting)]
5693 let non_field_children = {
5694 let mut cursor = node.walk();
5695 let mut result = ::std::vec::Vec::new();
5696 if cursor.goto_first_child() {
5697 loop {
5698 if cursor.field_name().is_none()
5699 && cursor.node().is_named()
5700 && !cursor.node().is_extra()
5701 {
5702 result.push(cursor.node());
5703 }
5704 if !cursor.goto_next_sibling() {
5705 break;
5706 }
5707 }
5708 }
5709 result
5710 };
5711 let child = if let Some(&c) = non_field_children.first() {
5712 c
5713 } else {
5714 let mut fallback_cursor = node.walk();
5715 let mut fallback_child = None;
5716 if fallback_cursor.goto_first_child() {
5717 loop {
5718 if fallback_cursor.field_name().is_none()
5719 && !fallback_cursor.node().is_extra()
5720 {
5721 let candidate = fallback_cursor.node();
5722 #[allow(clippy::needless_question_mark)]
5723 if (|| -> ::core::result::Result<
5724 _,
5725 ::treesitter_types::ParseError,
5726 > {
5727 let child = candidate;
5728 Ok(
5729 <Expression as ::treesitter_types::FromNode>::from_node(
5730 child,
5731 src,
5732 )?,
5733 )
5734 })()
5735 .is_ok()
5736 {
5737 fallback_child = Some(candidate);
5738 break;
5739 }
5740 }
5741 if !fallback_cursor.goto_next_sibling() {
5742 break;
5743 }
5744 }
5745 }
5746 if fallback_child.is_none() {
5747 let mut cursor2 = node.walk();
5748 if cursor2.goto_first_child() {
5749 loop {
5750 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5751 let candidate = cursor2.node();
5752 #[allow(clippy::needless_question_mark)]
5753 if (|| -> ::core::result::Result<
5754 _,
5755 ::treesitter_types::ParseError,
5756 > {
5757 let child = candidate;
5758 Ok(
5759 <Expression as ::treesitter_types::FromNode>::from_node(
5760 child,
5761 src,
5762 )?,
5763 )
5764 })()
5765 .is_ok()
5766 {
5767 fallback_child = Some(candidate);
5768 break;
5769 }
5770 }
5771 if !cursor2.goto_next_sibling() {
5772 break;
5773 }
5774 }
5775 }
5776 }
5777 fallback_child.ok_or_else(|| {
5778 ::treesitter_types::ParseError::missing_field("children", node)
5779 })?
5780 };
5781 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5782 },
5783 })
5784 }
5785}
5786impl ::treesitter_types::Spanned for Superclass<'_> {
5787 fn span(&self) -> ::treesitter_types::Span {
5788 self.span
5789 }
5790}
5791#[derive(Debug, Clone, PartialEq, Eq)]
5792pub struct SymbolArray<'tree> {
5793 pub span: ::treesitter_types::Span,
5794 pub children: ::std::vec::Vec<BareSymbol<'tree>>,
5795}
5796impl<'tree> ::treesitter_types::FromNode<'tree> for SymbolArray<'tree> {
5797 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5798 fn from_node(
5799 node: ::tree_sitter::Node<'tree>,
5800 src: &'tree [u8],
5801 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5802 debug_assert_eq!(node.kind(), "symbol_array");
5803 Ok(Self {
5804 span: ::treesitter_types::Span::from(node),
5805 children: {
5806 #[allow(clippy::suspicious_else_formatting)]
5807 let non_field_children = {
5808 let mut cursor = node.walk();
5809 let mut result = ::std::vec::Vec::new();
5810 if cursor.goto_first_child() {
5811 loop {
5812 if cursor.field_name().is_none()
5813 && cursor.node().is_named()
5814 && !cursor.node().is_extra()
5815 {
5816 result.push(cursor.node());
5817 }
5818 if !cursor.goto_next_sibling() {
5819 break;
5820 }
5821 }
5822 }
5823 result
5824 };
5825 let mut items = ::std::vec::Vec::new();
5826 for child in non_field_children {
5827 items.push(<BareSymbol as ::treesitter_types::FromNode>::from_node(
5828 child, src,
5829 )?);
5830 }
5831 items
5832 },
5833 })
5834 }
5835}
5836impl ::treesitter_types::Spanned for SymbolArray<'_> {
5837 fn span(&self) -> ::treesitter_types::Span {
5838 self.span
5839 }
5840}
5841#[derive(Debug, Clone, PartialEq, Eq)]
5842pub struct TestPattern<'tree> {
5843 pub span: ::treesitter_types::Span,
5844 pub pattern: PatternTopExprBody<'tree>,
5845 pub value: Arg<'tree>,
5846}
5847impl<'tree> ::treesitter_types::FromNode<'tree> for TestPattern<'tree> {
5848 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5849 fn from_node(
5850 node: ::tree_sitter::Node<'tree>,
5851 src: &'tree [u8],
5852 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5853 debug_assert_eq!(node.kind(), "test_pattern");
5854 Ok(Self {
5855 span: ::treesitter_types::Span::from(node),
5856 pattern: {
5857 let child = node.child_by_field_name("pattern").ok_or_else(|| {
5858 ::treesitter_types::ParseError::missing_field("pattern", node)
5859 })?;
5860 <PatternTopExprBody as ::treesitter_types::FromNode>::from_node(child, src)?
5861 },
5862 value: {
5863 let child = node
5864 .child_by_field_name("value")
5865 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5866 <Arg as ::treesitter_types::FromNode>::from_node(child, src)?
5867 },
5868 })
5869 }
5870}
5871impl ::treesitter_types::Spanned for TestPattern<'_> {
5872 fn span(&self) -> ::treesitter_types::Span {
5873 self.span
5874 }
5875}
5876#[derive(Debug, Clone, PartialEq, Eq)]
5877pub struct Then<'tree> {
5878 pub span: ::treesitter_types::Span,
5879 pub children: ::std::vec::Vec<ThenChildren<'tree>>,
5880}
5881impl<'tree> ::treesitter_types::FromNode<'tree> for Then<'tree> {
5882 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5883 fn from_node(
5884 node: ::tree_sitter::Node<'tree>,
5885 src: &'tree [u8],
5886 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5887 debug_assert_eq!(node.kind(), "then");
5888 Ok(Self {
5889 span: ::treesitter_types::Span::from(node),
5890 children: {
5891 #[allow(clippy::suspicious_else_formatting)]
5892 let non_field_children = {
5893 let mut cursor = node.walk();
5894 let mut result = ::std::vec::Vec::new();
5895 if cursor.goto_first_child() {
5896 loop {
5897 if cursor.field_name().is_none()
5898 && cursor.node().is_named()
5899 && !cursor.node().is_extra()
5900 {
5901 result.push(cursor.node());
5902 }
5903 if !cursor.goto_next_sibling() {
5904 break;
5905 }
5906 }
5907 }
5908 result
5909 };
5910 let mut items = ::std::vec::Vec::new();
5911 for child in non_field_children {
5912 items.push(<ThenChildren as ::treesitter_types::FromNode>::from_node(
5913 child, src,
5914 )?);
5915 }
5916 items
5917 },
5918 })
5919 }
5920}
5921impl ::treesitter_types::Spanned for Then<'_> {
5922 fn span(&self) -> ::treesitter_types::Span {
5923 self.span
5924 }
5925}
5926#[derive(Debug, Clone, PartialEq, Eq)]
5927pub struct Unary<'tree> {
5928 pub span: ::treesitter_types::Span,
5929 pub operand: UnaryOperand<'tree>,
5930 pub operator: UnaryOperator,
5931}
5932impl<'tree> ::treesitter_types::FromNode<'tree> for Unary<'tree> {
5933 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5934 fn from_node(
5935 node: ::tree_sitter::Node<'tree>,
5936 src: &'tree [u8],
5937 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5938 debug_assert_eq!(node.kind(), "unary");
5939 Ok(Self {
5940 span: ::treesitter_types::Span::from(node),
5941 operand: {
5942 let child = node.child_by_field_name("operand").ok_or_else(|| {
5943 ::treesitter_types::ParseError::missing_field("operand", node)
5944 })?;
5945 <UnaryOperand as ::treesitter_types::FromNode>::from_node(child, src)?
5946 },
5947 operator: {
5948 let child = node.child_by_field_name("operator").ok_or_else(|| {
5949 ::treesitter_types::ParseError::missing_field("operator", node)
5950 })?;
5951 <UnaryOperator as ::treesitter_types::FromNode>::from_node(child, src)?
5952 },
5953 })
5954 }
5955}
5956impl ::treesitter_types::Spanned for Unary<'_> {
5957 fn span(&self) -> ::treesitter_types::Span {
5958 self.span
5959 }
5960}
5961#[derive(Debug, Clone, PartialEq, Eq)]
5962pub struct Undef<'tree> {
5963 pub span: ::treesitter_types::Span,
5964 pub children: ::std::vec::Vec<MethodName<'tree>>,
5965}
5966impl<'tree> ::treesitter_types::FromNode<'tree> for Undef<'tree> {
5967 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5968 fn from_node(
5969 node: ::tree_sitter::Node<'tree>,
5970 src: &'tree [u8],
5971 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5972 debug_assert_eq!(node.kind(), "undef");
5973 Ok(Self {
5974 span: ::treesitter_types::Span::from(node),
5975 children: {
5976 #[allow(clippy::suspicious_else_formatting)]
5977 let non_field_children = {
5978 let mut cursor = node.walk();
5979 let mut result = ::std::vec::Vec::new();
5980 if cursor.goto_first_child() {
5981 loop {
5982 if cursor.field_name().is_none()
5983 && cursor.node().is_named()
5984 && !cursor.node().is_extra()
5985 {
5986 result.push(cursor.node());
5987 }
5988 if !cursor.goto_next_sibling() {
5989 break;
5990 }
5991 }
5992 }
5993 result
5994 };
5995 let mut items = ::std::vec::Vec::new();
5996 for child in non_field_children {
5997 items.push(<MethodName as ::treesitter_types::FromNode>::from_node(
5998 child, src,
5999 )?);
6000 }
6001 items
6002 },
6003 })
6004 }
6005}
6006impl ::treesitter_types::Spanned for Undef<'_> {
6007 fn span(&self) -> ::treesitter_types::Span {
6008 self.span
6009 }
6010}
6011#[derive(Debug, Clone, PartialEq, Eq)]
6012pub struct Unless<'tree> {
6013 pub span: ::treesitter_types::Span,
6014 pub alternative: ::core::option::Option<UnlessAlternative<'tree>>,
6015 pub condition: Statement<'tree>,
6016 pub consequence: ::core::option::Option<Then<'tree>>,
6017}
6018impl<'tree> ::treesitter_types::FromNode<'tree> for Unless<'tree> {
6019 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6020 fn from_node(
6021 node: ::tree_sitter::Node<'tree>,
6022 src: &'tree [u8],
6023 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6024 debug_assert_eq!(node.kind(), "unless");
6025 Ok(Self {
6026 span: ::treesitter_types::Span::from(node),
6027 alternative: match node.child_by_field_name("alternative") {
6028 Some(child) => Some(
6029 <UnlessAlternative as ::treesitter_types::FromNode>::from_node(child, src)?,
6030 ),
6031 None => None,
6032 },
6033 condition: {
6034 let child = node.child_by_field_name("condition").ok_or_else(|| {
6035 ::treesitter_types::ParseError::missing_field("condition", node)
6036 })?;
6037 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
6038 },
6039 consequence: match node.child_by_field_name("consequence") {
6040 Some(child) => Some(<Then as ::treesitter_types::FromNode>::from_node(
6041 child, src,
6042 )?),
6043 None => None,
6044 },
6045 })
6046 }
6047}
6048impl ::treesitter_types::Spanned for Unless<'_> {
6049 fn span(&self) -> ::treesitter_types::Span {
6050 self.span
6051 }
6052}
6053#[derive(Debug, Clone, PartialEq, Eq)]
6054pub struct UnlessGuard<'tree> {
6055 pub span: ::treesitter_types::Span,
6056 pub condition: Expression<'tree>,
6057}
6058impl<'tree> ::treesitter_types::FromNode<'tree> for UnlessGuard<'tree> {
6059 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6060 fn from_node(
6061 node: ::tree_sitter::Node<'tree>,
6062 src: &'tree [u8],
6063 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6064 debug_assert_eq!(node.kind(), "unless_guard");
6065 Ok(Self {
6066 span: ::treesitter_types::Span::from(node),
6067 condition: {
6068 let child = node.child_by_field_name("condition").ok_or_else(|| {
6069 ::treesitter_types::ParseError::missing_field("condition", node)
6070 })?;
6071 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6072 },
6073 })
6074 }
6075}
6076impl ::treesitter_types::Spanned for UnlessGuard<'_> {
6077 fn span(&self) -> ::treesitter_types::Span {
6078 self.span
6079 }
6080}
6081#[derive(Debug, Clone, PartialEq, Eq)]
6082pub struct UnlessModifier<'tree> {
6083 pub span: ::treesitter_types::Span,
6084 pub body: Statement<'tree>,
6085 pub condition: Expression<'tree>,
6086}
6087impl<'tree> ::treesitter_types::FromNode<'tree> for UnlessModifier<'tree> {
6088 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6089 fn from_node(
6090 node: ::tree_sitter::Node<'tree>,
6091 src: &'tree [u8],
6092 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6093 debug_assert_eq!(node.kind(), "unless_modifier");
6094 Ok(Self {
6095 span: ::treesitter_types::Span::from(node),
6096 body: {
6097 let child = node
6098 .child_by_field_name("body")
6099 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6100 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
6101 },
6102 condition: {
6103 let child = node.child_by_field_name("condition").ok_or_else(|| {
6104 ::treesitter_types::ParseError::missing_field("condition", node)
6105 })?;
6106 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6107 },
6108 })
6109 }
6110}
6111impl ::treesitter_types::Spanned for UnlessModifier<'_> {
6112 fn span(&self) -> ::treesitter_types::Span {
6113 self.span
6114 }
6115}
6116#[derive(Debug, Clone, PartialEq, Eq)]
6117pub struct Until<'tree> {
6118 pub span: ::treesitter_types::Span,
6119 pub body: Do<'tree>,
6120 pub condition: Statement<'tree>,
6121}
6122impl<'tree> ::treesitter_types::FromNode<'tree> for Until<'tree> {
6123 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6124 fn from_node(
6125 node: ::tree_sitter::Node<'tree>,
6126 src: &'tree [u8],
6127 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6128 debug_assert_eq!(node.kind(), "until");
6129 Ok(Self {
6130 span: ::treesitter_types::Span::from(node),
6131 body: {
6132 let child = node
6133 .child_by_field_name("body")
6134 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6135 <Do as ::treesitter_types::FromNode>::from_node(child, src)?
6136 },
6137 condition: {
6138 let child = node.child_by_field_name("condition").ok_or_else(|| {
6139 ::treesitter_types::ParseError::missing_field("condition", node)
6140 })?;
6141 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
6142 },
6143 })
6144 }
6145}
6146impl ::treesitter_types::Spanned for Until<'_> {
6147 fn span(&self) -> ::treesitter_types::Span {
6148 self.span
6149 }
6150}
6151#[derive(Debug, Clone, PartialEq, Eq)]
6152pub struct UntilModifier<'tree> {
6153 pub span: ::treesitter_types::Span,
6154 pub body: Statement<'tree>,
6155 pub condition: Expression<'tree>,
6156}
6157impl<'tree> ::treesitter_types::FromNode<'tree> for UntilModifier<'tree> {
6158 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6159 fn from_node(
6160 node: ::tree_sitter::Node<'tree>,
6161 src: &'tree [u8],
6162 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6163 debug_assert_eq!(node.kind(), "until_modifier");
6164 Ok(Self {
6165 span: ::treesitter_types::Span::from(node),
6166 body: {
6167 let child = node
6168 .child_by_field_name("body")
6169 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6170 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
6171 },
6172 condition: {
6173 let child = node.child_by_field_name("condition").ok_or_else(|| {
6174 ::treesitter_types::ParseError::missing_field("condition", node)
6175 })?;
6176 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6177 },
6178 })
6179 }
6180}
6181impl ::treesitter_types::Spanned for UntilModifier<'_> {
6182 fn span(&self) -> ::treesitter_types::Span {
6183 self.span
6184 }
6185}
6186#[derive(Debug, Clone, PartialEq, Eq)]
6187pub struct VariableReferencePattern<'tree> {
6188 pub span: ::treesitter_types::Span,
6189 pub name: VariableReferencePatternName<'tree>,
6190}
6191impl<'tree> ::treesitter_types::FromNode<'tree> for VariableReferencePattern<'tree> {
6192 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6193 fn from_node(
6194 node: ::tree_sitter::Node<'tree>,
6195 src: &'tree [u8],
6196 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6197 debug_assert_eq!(node.kind(), "variable_reference_pattern");
6198 Ok(Self {
6199 span: ::treesitter_types::Span::from(node),
6200 name: {
6201 let child = node
6202 .child_by_field_name("name")
6203 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6204 <VariableReferencePatternName as ::treesitter_types::FromNode>::from_node(
6205 child, src,
6206 )?
6207 },
6208 })
6209 }
6210}
6211impl ::treesitter_types::Spanned for VariableReferencePattern<'_> {
6212 fn span(&self) -> ::treesitter_types::Span {
6213 self.span
6214 }
6215}
6216#[derive(Debug, Clone, PartialEq, Eq)]
6217pub struct When<'tree> {
6218 pub span: ::treesitter_types::Span,
6219 pub body: ::core::option::Option<Then<'tree>>,
6220 pub pattern: ::std::vec::Vec<Pattern<'tree>>,
6221}
6222impl<'tree> ::treesitter_types::FromNode<'tree> for When<'tree> {
6223 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6224 fn from_node(
6225 node: ::tree_sitter::Node<'tree>,
6226 src: &'tree [u8],
6227 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6228 debug_assert_eq!(node.kind(), "when");
6229 Ok(Self {
6230 span: ::treesitter_types::Span::from(node),
6231 body: match node.child_by_field_name("body") {
6232 Some(child) => Some(<Then as ::treesitter_types::FromNode>::from_node(
6233 child, src,
6234 )?),
6235 None => None,
6236 },
6237 pattern: {
6238 let mut cursor = node.walk();
6239 let mut items = ::std::vec::Vec::new();
6240 for child in node.children_by_field_name("pattern", &mut cursor) {
6241 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
6242 child, src,
6243 )?);
6244 }
6245 items
6246 },
6247 })
6248 }
6249}
6250impl ::treesitter_types::Spanned for When<'_> {
6251 fn span(&self) -> ::treesitter_types::Span {
6252 self.span
6253 }
6254}
6255#[derive(Debug, Clone, PartialEq, Eq)]
6256pub struct While<'tree> {
6257 pub span: ::treesitter_types::Span,
6258 pub body: Do<'tree>,
6259 pub condition: Statement<'tree>,
6260}
6261impl<'tree> ::treesitter_types::FromNode<'tree> for While<'tree> {
6262 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6263 fn from_node(
6264 node: ::tree_sitter::Node<'tree>,
6265 src: &'tree [u8],
6266 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6267 debug_assert_eq!(node.kind(), "while");
6268 Ok(Self {
6269 span: ::treesitter_types::Span::from(node),
6270 body: {
6271 let child = node
6272 .child_by_field_name("body")
6273 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6274 <Do as ::treesitter_types::FromNode>::from_node(child, src)?
6275 },
6276 condition: {
6277 let child = node.child_by_field_name("condition").ok_or_else(|| {
6278 ::treesitter_types::ParseError::missing_field("condition", node)
6279 })?;
6280 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
6281 },
6282 })
6283 }
6284}
6285impl ::treesitter_types::Spanned for While<'_> {
6286 fn span(&self) -> ::treesitter_types::Span {
6287 self.span
6288 }
6289}
6290#[derive(Debug, Clone, PartialEq, Eq)]
6291pub struct WhileModifier<'tree> {
6292 pub span: ::treesitter_types::Span,
6293 pub body: Statement<'tree>,
6294 pub condition: Expression<'tree>,
6295}
6296impl<'tree> ::treesitter_types::FromNode<'tree> for WhileModifier<'tree> {
6297 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6298 fn from_node(
6299 node: ::tree_sitter::Node<'tree>,
6300 src: &'tree [u8],
6301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6302 debug_assert_eq!(node.kind(), "while_modifier");
6303 Ok(Self {
6304 span: ::treesitter_types::Span::from(node),
6305 body: {
6306 let child = node
6307 .child_by_field_name("body")
6308 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6309 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
6310 },
6311 condition: {
6312 let child = node.child_by_field_name("condition").ok_or_else(|| {
6313 ::treesitter_types::ParseError::missing_field("condition", node)
6314 })?;
6315 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6316 },
6317 })
6318 }
6319}
6320impl ::treesitter_types::Spanned for WhileModifier<'_> {
6321 fn span(&self) -> ::treesitter_types::Span {
6322 self.span
6323 }
6324}
6325#[derive(Debug, Clone, PartialEq, Eq)]
6326pub struct Yield<'tree> {
6327 pub span: ::treesitter_types::Span,
6328 pub children: ::core::option::Option<ArgumentList<'tree>>,
6329}
6330impl<'tree> ::treesitter_types::FromNode<'tree> for Yield<'tree> {
6331 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6332 fn from_node(
6333 node: ::tree_sitter::Node<'tree>,
6334 src: &'tree [u8],
6335 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6336 debug_assert_eq!(node.kind(), "yield");
6337 Ok(Self {
6338 span: ::treesitter_types::Span::from(node),
6339 children: {
6340 #[allow(clippy::suspicious_else_formatting)]
6341 let non_field_children = {
6342 let mut cursor = node.walk();
6343 let mut result = ::std::vec::Vec::new();
6344 if cursor.goto_first_child() {
6345 loop {
6346 if cursor.field_name().is_none()
6347 && cursor.node().is_named()
6348 && !cursor.node().is_extra()
6349 {
6350 result.push(cursor.node());
6351 }
6352 if !cursor.goto_next_sibling() {
6353 break;
6354 }
6355 }
6356 }
6357 result
6358 };
6359 match non_field_children.first() {
6360 Some(&child) => Some(
6361 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?,
6362 ),
6363 None => None,
6364 }
6365 },
6366 })
6367 }
6368}
6369impl ::treesitter_types::Spanned for Yield<'_> {
6370 fn span(&self) -> ::treesitter_types::Span {
6371 self.span
6372 }
6373}
6374#[derive(Debug, Clone, PartialEq, Eq)]
6375pub struct Character<'tree> {
6376 pub span: ::treesitter_types::Span,
6377 text: &'tree str,
6378}
6379impl<'tree> ::treesitter_types::FromNode<'tree> for Character<'tree> {
6380 fn from_node(
6381 node: ::tree_sitter::Node<'tree>,
6382 src: &'tree [u8],
6383 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6384 debug_assert_eq!(node.kind(), "character");
6385 Ok(Self {
6386 span: ::treesitter_types::Span::from(node),
6387 text: node.utf8_text(src)?,
6388 })
6389 }
6390}
6391impl<'tree> ::treesitter_types::LeafNode<'tree> for Character<'tree> {
6392 fn text(&self) -> &'tree str {
6393 self.text
6394 }
6395}
6396impl ::treesitter_types::Spanned for Character<'_> {
6397 fn span(&self) -> ::treesitter_types::Span {
6398 self.span
6399 }
6400}
6401#[derive(Debug, Clone, PartialEq, Eq)]
6402pub struct ClassVariable<'tree> {
6403 pub span: ::treesitter_types::Span,
6404 text: &'tree str,
6405}
6406impl<'tree> ::treesitter_types::FromNode<'tree> for ClassVariable<'tree> {
6407 fn from_node(
6408 node: ::tree_sitter::Node<'tree>,
6409 src: &'tree [u8],
6410 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6411 debug_assert_eq!(node.kind(), "class_variable");
6412 Ok(Self {
6413 span: ::treesitter_types::Span::from(node),
6414 text: node.utf8_text(src)?,
6415 })
6416 }
6417}
6418impl<'tree> ::treesitter_types::LeafNode<'tree> for ClassVariable<'tree> {
6419 fn text(&self) -> &'tree str {
6420 self.text
6421 }
6422}
6423impl ::treesitter_types::Spanned for ClassVariable<'_> {
6424 fn span(&self) -> ::treesitter_types::Span {
6425 self.span
6426 }
6427}
6428#[derive(Debug, Clone, PartialEq, Eq)]
6429pub struct Comment<'tree> {
6430 pub span: ::treesitter_types::Span,
6431 text: &'tree str,
6432}
6433impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
6434 fn from_node(
6435 node: ::tree_sitter::Node<'tree>,
6436 src: &'tree [u8],
6437 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6438 debug_assert_eq!(node.kind(), "comment");
6439 Ok(Self {
6440 span: ::treesitter_types::Span::from(node),
6441 text: node.utf8_text(src)?,
6442 })
6443 }
6444}
6445impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
6446 fn text(&self) -> &'tree str {
6447 self.text
6448 }
6449}
6450impl ::treesitter_types::Spanned for Comment<'_> {
6451 fn span(&self) -> ::treesitter_types::Span {
6452 self.span
6453 }
6454}
6455#[derive(Debug, Clone, PartialEq, Eq)]
6456pub struct Encoding<'tree> {
6457 pub span: ::treesitter_types::Span,
6458 text: &'tree str,
6459}
6460impl<'tree> ::treesitter_types::FromNode<'tree> for Encoding<'tree> {
6461 fn from_node(
6462 node: ::tree_sitter::Node<'tree>,
6463 src: &'tree [u8],
6464 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6465 debug_assert_eq!(node.kind(), "encoding");
6466 Ok(Self {
6467 span: ::treesitter_types::Span::from(node),
6468 text: node.utf8_text(src)?,
6469 })
6470 }
6471}
6472impl<'tree> ::treesitter_types::LeafNode<'tree> for Encoding<'tree> {
6473 fn text(&self) -> &'tree str {
6474 self.text
6475 }
6476}
6477impl ::treesitter_types::Spanned for Encoding<'_> {
6478 fn span(&self) -> ::treesitter_types::Span {
6479 self.span
6480 }
6481}
6482#[derive(Debug, Clone, PartialEq, Eq)]
6483pub struct EscapeSequence<'tree> {
6484 pub span: ::treesitter_types::Span,
6485 text: &'tree str,
6486}
6487impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
6488 fn from_node(
6489 node: ::tree_sitter::Node<'tree>,
6490 src: &'tree [u8],
6491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6492 debug_assert_eq!(node.kind(), "escape_sequence");
6493 Ok(Self {
6494 span: ::treesitter_types::Span::from(node),
6495 text: node.utf8_text(src)?,
6496 })
6497 }
6498}
6499impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
6500 fn text(&self) -> &'tree str {
6501 self.text
6502 }
6503}
6504impl ::treesitter_types::Spanned for EscapeSequence<'_> {
6505 fn span(&self) -> ::treesitter_types::Span {
6506 self.span
6507 }
6508}
6509#[derive(Debug, Clone, PartialEq, Eq)]
6510pub struct False<'tree> {
6511 pub span: ::treesitter_types::Span,
6512 text: &'tree str,
6513}
6514impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
6515 fn from_node(
6516 node: ::tree_sitter::Node<'tree>,
6517 src: &'tree [u8],
6518 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6519 debug_assert_eq!(node.kind(), "false");
6520 Ok(Self {
6521 span: ::treesitter_types::Span::from(node),
6522 text: node.utf8_text(src)?,
6523 })
6524 }
6525}
6526impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
6527 fn text(&self) -> &'tree str {
6528 self.text
6529 }
6530}
6531impl ::treesitter_types::Spanned for False<'_> {
6532 fn span(&self) -> ::treesitter_types::Span {
6533 self.span
6534 }
6535}
6536#[derive(Debug, Clone, PartialEq, Eq)]
6537pub struct File<'tree> {
6538 pub span: ::treesitter_types::Span,
6539 text: &'tree str,
6540}
6541impl<'tree> ::treesitter_types::FromNode<'tree> for File<'tree> {
6542 fn from_node(
6543 node: ::tree_sitter::Node<'tree>,
6544 src: &'tree [u8],
6545 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6546 debug_assert_eq!(node.kind(), "file");
6547 Ok(Self {
6548 span: ::treesitter_types::Span::from(node),
6549 text: node.utf8_text(src)?,
6550 })
6551 }
6552}
6553impl<'tree> ::treesitter_types::LeafNode<'tree> for File<'tree> {
6554 fn text(&self) -> &'tree str {
6555 self.text
6556 }
6557}
6558impl ::treesitter_types::Spanned for File<'_> {
6559 fn span(&self) -> ::treesitter_types::Span {
6560 self.span
6561 }
6562}
6563#[derive(Debug, Clone, PartialEq, Eq)]
6564pub struct Float<'tree> {
6565 pub span: ::treesitter_types::Span,
6566 text: &'tree str,
6567}
6568impl<'tree> ::treesitter_types::FromNode<'tree> for Float<'tree> {
6569 fn from_node(
6570 node: ::tree_sitter::Node<'tree>,
6571 src: &'tree [u8],
6572 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6573 debug_assert_eq!(node.kind(), "float");
6574 Ok(Self {
6575 span: ::treesitter_types::Span::from(node),
6576 text: node.utf8_text(src)?,
6577 })
6578 }
6579}
6580impl<'tree> ::treesitter_types::LeafNode<'tree> for Float<'tree> {
6581 fn text(&self) -> &'tree str {
6582 self.text
6583 }
6584}
6585impl ::treesitter_types::Spanned for Float<'_> {
6586 fn span(&self) -> ::treesitter_types::Span {
6587 self.span
6588 }
6589}
6590#[derive(Debug, Clone, PartialEq, Eq)]
6591pub struct GlobalVariable<'tree> {
6592 pub span: ::treesitter_types::Span,
6593 text: &'tree str,
6594}
6595impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalVariable<'tree> {
6596 fn from_node(
6597 node: ::tree_sitter::Node<'tree>,
6598 src: &'tree [u8],
6599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6600 debug_assert_eq!(node.kind(), "global_variable");
6601 Ok(Self {
6602 span: ::treesitter_types::Span::from(node),
6603 text: node.utf8_text(src)?,
6604 })
6605 }
6606}
6607impl<'tree> ::treesitter_types::LeafNode<'tree> for GlobalVariable<'tree> {
6608 fn text(&self) -> &'tree str {
6609 self.text
6610 }
6611}
6612impl ::treesitter_types::Spanned for GlobalVariable<'_> {
6613 fn span(&self) -> ::treesitter_types::Span {
6614 self.span
6615 }
6616}
6617#[derive(Debug, Clone, PartialEq, Eq)]
6618pub struct HeredocBeginning<'tree> {
6619 pub span: ::treesitter_types::Span,
6620 text: &'tree str,
6621}
6622impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBeginning<'tree> {
6623 fn from_node(
6624 node: ::tree_sitter::Node<'tree>,
6625 src: &'tree [u8],
6626 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6627 debug_assert_eq!(node.kind(), "heredoc_beginning");
6628 Ok(Self {
6629 span: ::treesitter_types::Span::from(node),
6630 text: node.utf8_text(src)?,
6631 })
6632 }
6633}
6634impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocBeginning<'tree> {
6635 fn text(&self) -> &'tree str {
6636 self.text
6637 }
6638}
6639impl ::treesitter_types::Spanned for HeredocBeginning<'_> {
6640 fn span(&self) -> ::treesitter_types::Span {
6641 self.span
6642 }
6643}
6644#[derive(Debug, Clone, PartialEq, Eq)]
6645pub struct HeredocContent<'tree> {
6646 pub span: ::treesitter_types::Span,
6647 text: &'tree str,
6648}
6649impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocContent<'tree> {
6650 fn from_node(
6651 node: ::tree_sitter::Node<'tree>,
6652 src: &'tree [u8],
6653 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6654 debug_assert_eq!(node.kind(), "heredoc_content");
6655 Ok(Self {
6656 span: ::treesitter_types::Span::from(node),
6657 text: node.utf8_text(src)?,
6658 })
6659 }
6660}
6661impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocContent<'tree> {
6662 fn text(&self) -> &'tree str {
6663 self.text
6664 }
6665}
6666impl ::treesitter_types::Spanned for HeredocContent<'_> {
6667 fn span(&self) -> ::treesitter_types::Span {
6668 self.span
6669 }
6670}
6671#[derive(Debug, Clone, PartialEq, Eq)]
6672pub struct HeredocEnd<'tree> {
6673 pub span: ::treesitter_types::Span,
6674 text: &'tree str,
6675}
6676impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocEnd<'tree> {
6677 fn from_node(
6678 node: ::tree_sitter::Node<'tree>,
6679 src: &'tree [u8],
6680 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6681 debug_assert_eq!(node.kind(), "heredoc_end");
6682 Ok(Self {
6683 span: ::treesitter_types::Span::from(node),
6684 text: node.utf8_text(src)?,
6685 })
6686 }
6687}
6688impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocEnd<'tree> {
6689 fn text(&self) -> &'tree str {
6690 self.text
6691 }
6692}
6693impl ::treesitter_types::Spanned for HeredocEnd<'_> {
6694 fn span(&self) -> ::treesitter_types::Span {
6695 self.span
6696 }
6697}
6698#[derive(Debug, Clone, PartialEq, Eq)]
6699pub struct InstanceVariable<'tree> {
6700 pub span: ::treesitter_types::Span,
6701 text: &'tree str,
6702}
6703impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceVariable<'tree> {
6704 fn from_node(
6705 node: ::tree_sitter::Node<'tree>,
6706 src: &'tree [u8],
6707 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6708 debug_assert_eq!(node.kind(), "instance_variable");
6709 Ok(Self {
6710 span: ::treesitter_types::Span::from(node),
6711 text: node.utf8_text(src)?,
6712 })
6713 }
6714}
6715impl<'tree> ::treesitter_types::LeafNode<'tree> for InstanceVariable<'tree> {
6716 fn text(&self) -> &'tree str {
6717 self.text
6718 }
6719}
6720impl ::treesitter_types::Spanned for InstanceVariable<'_> {
6721 fn span(&self) -> ::treesitter_types::Span {
6722 self.span
6723 }
6724}
6725#[derive(Debug, Clone, PartialEq, Eq)]
6726pub struct Integer<'tree> {
6727 pub span: ::treesitter_types::Span,
6728 text: &'tree str,
6729}
6730impl<'tree> ::treesitter_types::FromNode<'tree> for Integer<'tree> {
6731 fn from_node(
6732 node: ::tree_sitter::Node<'tree>,
6733 src: &'tree [u8],
6734 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6735 debug_assert_eq!(node.kind(), "integer");
6736 Ok(Self {
6737 span: ::treesitter_types::Span::from(node),
6738 text: node.utf8_text(src)?,
6739 })
6740 }
6741}
6742impl<'tree> ::treesitter_types::LeafNode<'tree> for Integer<'tree> {
6743 fn text(&self) -> &'tree str {
6744 self.text
6745 }
6746}
6747impl ::treesitter_types::Spanned for Integer<'_> {
6748 fn span(&self) -> ::treesitter_types::Span {
6749 self.span
6750 }
6751}
6752#[derive(Debug, Clone, PartialEq, Eq)]
6753pub struct Line<'tree> {
6754 pub span: ::treesitter_types::Span,
6755 text: &'tree str,
6756}
6757impl<'tree> ::treesitter_types::FromNode<'tree> for Line<'tree> {
6758 fn from_node(
6759 node: ::tree_sitter::Node<'tree>,
6760 src: &'tree [u8],
6761 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6762 debug_assert_eq!(node.kind(), "line");
6763 Ok(Self {
6764 span: ::treesitter_types::Span::from(node),
6765 text: node.utf8_text(src)?,
6766 })
6767 }
6768}
6769impl<'tree> ::treesitter_types::LeafNode<'tree> for Line<'tree> {
6770 fn text(&self) -> &'tree str {
6771 self.text
6772 }
6773}
6774impl ::treesitter_types::Spanned for Line<'_> {
6775 fn span(&self) -> ::treesitter_types::Span {
6776 self.span
6777 }
6778}
6779#[derive(Debug, Clone, PartialEq, Eq)]
6780pub struct SelfType<'tree> {
6781 pub span: ::treesitter_types::Span,
6782 text: &'tree str,
6783}
6784impl<'tree> ::treesitter_types::FromNode<'tree> for SelfType<'tree> {
6785 fn from_node(
6786 node: ::tree_sitter::Node<'tree>,
6787 src: &'tree [u8],
6788 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6789 debug_assert_eq!(node.kind(), "self");
6790 Ok(Self {
6791 span: ::treesitter_types::Span::from(node),
6792 text: node.utf8_text(src)?,
6793 })
6794 }
6795}
6796impl<'tree> ::treesitter_types::LeafNode<'tree> for SelfType<'tree> {
6797 fn text(&self) -> &'tree str {
6798 self.text
6799 }
6800}
6801impl ::treesitter_types::Spanned for SelfType<'_> {
6802 fn span(&self) -> ::treesitter_types::Span {
6803 self.span
6804 }
6805}
6806#[derive(Debug, Clone, PartialEq, Eq)]
6807pub struct SimpleSymbol<'tree> {
6808 pub span: ::treesitter_types::Span,
6809 text: &'tree str,
6810}
6811impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleSymbol<'tree> {
6812 fn from_node(
6813 node: ::tree_sitter::Node<'tree>,
6814 src: &'tree [u8],
6815 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6816 debug_assert_eq!(node.kind(), "simple_symbol");
6817 Ok(Self {
6818 span: ::treesitter_types::Span::from(node),
6819 text: node.utf8_text(src)?,
6820 })
6821 }
6822}
6823impl<'tree> ::treesitter_types::LeafNode<'tree> for SimpleSymbol<'tree> {
6824 fn text(&self) -> &'tree str {
6825 self.text
6826 }
6827}
6828impl ::treesitter_types::Spanned for SimpleSymbol<'_> {
6829 fn span(&self) -> ::treesitter_types::Span {
6830 self.span
6831 }
6832}
6833#[derive(Debug, Clone, PartialEq, Eq)]
6834pub struct StringContent<'tree> {
6835 pub span: ::treesitter_types::Span,
6836 text: &'tree str,
6837}
6838impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
6839 fn from_node(
6840 node: ::tree_sitter::Node<'tree>,
6841 src: &'tree [u8],
6842 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6843 debug_assert_eq!(node.kind(), "string_content");
6844 Ok(Self {
6845 span: ::treesitter_types::Span::from(node),
6846 text: node.utf8_text(src)?,
6847 })
6848 }
6849}
6850impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
6851 fn text(&self) -> &'tree str {
6852 self.text
6853 }
6854}
6855impl ::treesitter_types::Spanned for StringContent<'_> {
6856 fn span(&self) -> ::treesitter_types::Span {
6857 self.span
6858 }
6859}
6860#[derive(Debug, Clone, PartialEq, Eq)]
6861pub struct Super<'tree> {
6862 pub span: ::treesitter_types::Span,
6863 text: &'tree str,
6864}
6865impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
6866 fn from_node(
6867 node: ::tree_sitter::Node<'tree>,
6868 src: &'tree [u8],
6869 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6870 debug_assert_eq!(node.kind(), "super");
6871 Ok(Self {
6872 span: ::treesitter_types::Span::from(node),
6873 text: node.utf8_text(src)?,
6874 })
6875 }
6876}
6877impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
6878 fn text(&self) -> &'tree str {
6879 self.text
6880 }
6881}
6882impl ::treesitter_types::Spanned for Super<'_> {
6883 fn span(&self) -> ::treesitter_types::Span {
6884 self.span
6885 }
6886}
6887#[derive(Debug, Clone, PartialEq, Eq)]
6888pub struct True<'tree> {
6889 pub span: ::treesitter_types::Span,
6890 text: &'tree str,
6891}
6892impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
6893 fn from_node(
6894 node: ::tree_sitter::Node<'tree>,
6895 src: &'tree [u8],
6896 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6897 debug_assert_eq!(node.kind(), "true");
6898 Ok(Self {
6899 span: ::treesitter_types::Span::from(node),
6900 text: node.utf8_text(src)?,
6901 })
6902 }
6903}
6904impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
6905 fn text(&self) -> &'tree str {
6906 self.text
6907 }
6908}
6909impl ::treesitter_types::Spanned for True<'_> {
6910 fn span(&self) -> ::treesitter_types::Span {
6911 self.span
6912 }
6913}
6914#[derive(Debug, Clone, PartialEq, Eq)]
6915pub struct Uninterpreted<'tree> {
6916 pub span: ::treesitter_types::Span,
6917 text: &'tree str,
6918}
6919impl<'tree> ::treesitter_types::FromNode<'tree> for Uninterpreted<'tree> {
6920 fn from_node(
6921 node: ::tree_sitter::Node<'tree>,
6922 src: &'tree [u8],
6923 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6924 debug_assert_eq!(node.kind(), "uninterpreted");
6925 Ok(Self {
6926 span: ::treesitter_types::Span::from(node),
6927 text: node.utf8_text(src)?,
6928 })
6929 }
6930}
6931impl<'tree> ::treesitter_types::LeafNode<'tree> for Uninterpreted<'tree> {
6932 fn text(&self) -> &'tree str {
6933 self.text
6934 }
6935}
6936impl ::treesitter_types::Spanned for Uninterpreted<'_> {
6937 fn span(&self) -> ::treesitter_types::Span {
6938 self.span
6939 }
6940}
6941#[derive(Debug, Clone, PartialEq, Eq)]
6942pub enum ArgumentListChildren<'tree> {
6943 Expression(::std::boxed::Box<Expression<'tree>>),
6944 BlockArgument(::std::boxed::Box<BlockArgument<'tree>>),
6945 ForwardArgument(::std::boxed::Box<ForwardArgument<'tree>>),
6946 HashSplatArgument(::std::boxed::Box<HashSplatArgument<'tree>>),
6947 Pair(::std::boxed::Box<Pair<'tree>>),
6948 SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
6949}
6950impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentListChildren<'tree> {
6951 #[allow(clippy::collapsible_else_if)]
6952 fn from_node(
6953 node: ::tree_sitter::Node<'tree>,
6954 src: &'tree [u8],
6955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6956 match node.kind() {
6957 "block_argument" => Ok(Self::BlockArgument(::std::boxed::Box::new(
6958 <BlockArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
6959 ))),
6960 "forward_argument" => Ok(Self::ForwardArgument(::std::boxed::Box::new(
6961 <ForwardArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
6962 ))),
6963 "hash_splat_argument" => Ok(Self::HashSplatArgument(::std::boxed::Box::new(
6964 <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
6965 ))),
6966 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
6967 <Pair as ::treesitter_types::FromNode>::from_node(node, src)?,
6968 ))),
6969 "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
6970 <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
6971 ))),
6972 _other => {
6973 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
6974 Ok(Self::Expression(::std::boxed::Box::new(v)))
6975 } else {
6976 Err(::treesitter_types::ParseError::unexpected_kind(
6977 _other, node,
6978 ))
6979 }
6980 }
6981 }
6982 }
6983}
6984impl ::treesitter_types::Spanned for ArgumentListChildren<'_> {
6985 fn span(&self) -> ::treesitter_types::Span {
6986 match self {
6987 Self::Expression(inner) => inner.span(),
6988 Self::BlockArgument(inner) => inner.span(),
6989 Self::ForwardArgument(inner) => inner.span(),
6990 Self::HashSplatArgument(inner) => inner.span(),
6991 Self::Pair(inner) => inner.span(),
6992 Self::SplatArgument(inner) => inner.span(),
6993 }
6994 }
6995}
6996#[derive(Debug, Clone, PartialEq, Eq)]
6997pub enum ArrayChildren<'tree> {
6998 Expression(::std::boxed::Box<Expression<'tree>>),
6999 BlockArgument(::std::boxed::Box<BlockArgument<'tree>>),
7000 ForwardArgument(::std::boxed::Box<ForwardArgument<'tree>>),
7001 HashSplatArgument(::std::boxed::Box<HashSplatArgument<'tree>>),
7002 Pair(::std::boxed::Box<Pair<'tree>>),
7003 SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
7004}
7005impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayChildren<'tree> {
7006 #[allow(clippy::collapsible_else_if)]
7007 fn from_node(
7008 node: ::tree_sitter::Node<'tree>,
7009 src: &'tree [u8],
7010 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7011 match node.kind() {
7012 "block_argument" => Ok(Self::BlockArgument(::std::boxed::Box::new(
7013 <BlockArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
7014 ))),
7015 "forward_argument" => Ok(Self::ForwardArgument(::std::boxed::Box::new(
7016 <ForwardArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
7017 ))),
7018 "hash_splat_argument" => Ok(Self::HashSplatArgument(::std::boxed::Box::new(
7019 <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
7020 ))),
7021 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
7022 <Pair as ::treesitter_types::FromNode>::from_node(node, src)?,
7023 ))),
7024 "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
7025 <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
7026 ))),
7027 _other => {
7028 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
7029 Ok(Self::Expression(::std::boxed::Box::new(v)))
7030 } else {
7031 Err(::treesitter_types::ParseError::unexpected_kind(
7032 _other, node,
7033 ))
7034 }
7035 }
7036 }
7037 }
7038}
7039impl ::treesitter_types::Spanned for ArrayChildren<'_> {
7040 fn span(&self) -> ::treesitter_types::Span {
7041 match self {
7042 Self::Expression(inner) => inner.span(),
7043 Self::BlockArgument(inner) => inner.span(),
7044 Self::ForwardArgument(inner) => inner.span(),
7045 Self::HashSplatArgument(inner) => inner.span(),
7046 Self::Pair(inner) => inner.span(),
7047 Self::SplatArgument(inner) => inner.span(),
7048 }
7049 }
7050}
7051#[derive(Debug, Clone, PartialEq, Eq)]
7052pub enum ArrayPatternChildren<'tree> {
7053 PatternExpr(::std::boxed::Box<PatternExpr<'tree>>),
7054 SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
7055}
7056impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPatternChildren<'tree> {
7057 #[allow(clippy::collapsible_else_if)]
7058 fn from_node(
7059 node: ::tree_sitter::Node<'tree>,
7060 src: &'tree [u8],
7061 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7062 match node.kind() {
7063 "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
7064 <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7065 ))),
7066 _other => {
7067 if let Ok(v) = <PatternExpr as ::treesitter_types::FromNode>::from_node(node, src) {
7068 Ok(Self::PatternExpr(::std::boxed::Box::new(v)))
7069 } else {
7070 Err(::treesitter_types::ParseError::unexpected_kind(
7071 _other, node,
7072 ))
7073 }
7074 }
7075 }
7076 }
7077}
7078impl ::treesitter_types::Spanned for ArrayPatternChildren<'_> {
7079 fn span(&self) -> ::treesitter_types::Span {
7080 match self {
7081 Self::PatternExpr(inner) => inner.span(),
7082 Self::SplatParameter(inner) => inner.span(),
7083 }
7084 }
7085}
7086#[derive(Debug, Clone, PartialEq, Eq)]
7087pub enum AssignmentLeft<'tree> {
7088 Lhs(::std::boxed::Box<Lhs<'tree>>),
7089 LeftAssignmentList(::std::boxed::Box<LeftAssignmentList<'tree>>),
7090}
7091impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentLeft<'tree> {
7092 #[allow(clippy::collapsible_else_if)]
7093 fn from_node(
7094 node: ::tree_sitter::Node<'tree>,
7095 src: &'tree [u8],
7096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7097 match node.kind() {
7098 "left_assignment_list" => Ok(Self::LeftAssignmentList(::std::boxed::Box::new(
7099 <LeftAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)?,
7100 ))),
7101 _other => {
7102 if let Ok(v) = <Lhs as ::treesitter_types::FromNode>::from_node(node, src) {
7103 Ok(Self::Lhs(::std::boxed::Box::new(v)))
7104 } else {
7105 Err(::treesitter_types::ParseError::unexpected_kind(
7106 _other, node,
7107 ))
7108 }
7109 }
7110 }
7111 }
7112}
7113impl ::treesitter_types::Spanned for AssignmentLeft<'_> {
7114 fn span(&self) -> ::treesitter_types::Span {
7115 match self {
7116 Self::Lhs(inner) => inner.span(),
7117 Self::LeftAssignmentList(inner) => inner.span(),
7118 }
7119 }
7120}
7121#[derive(Debug, Clone, PartialEq, Eq)]
7122pub enum AssignmentRight<'tree> {
7123 Expression(::std::boxed::Box<Expression<'tree>>),
7124 RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
7125 RightAssignmentList(::std::boxed::Box<RightAssignmentList<'tree>>),
7126 SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
7127}
7128impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentRight<'tree> {
7129 #[allow(clippy::collapsible_else_if)]
7130 fn from_node(
7131 node: ::tree_sitter::Node<'tree>,
7132 src: &'tree [u8],
7133 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7134 match node.kind() {
7135 "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
7136 <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7137 ))),
7138 "right_assignment_list" => Ok(Self::RightAssignmentList(::std::boxed::Box::new(
7139 <RightAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)?,
7140 ))),
7141 "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
7142 <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
7143 ))),
7144 _other => {
7145 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
7146 Ok(Self::Expression(::std::boxed::Box::new(v)))
7147 } else {
7148 Err(::treesitter_types::ParseError::unexpected_kind(
7149 _other, node,
7150 ))
7151 }
7152 }
7153 }
7154 }
7155}
7156impl ::treesitter_types::Spanned for AssignmentRight<'_> {
7157 fn span(&self) -> ::treesitter_types::Span {
7158 match self {
7159 Self::Expression(inner) => inner.span(),
7160 Self::RescueModifier(inner) => inner.span(),
7161 Self::RightAssignmentList(inner) => inner.span(),
7162 Self::SplatArgument(inner) => inner.span(),
7163 }
7164 }
7165}
7166#[derive(Debug, Clone, PartialEq, Eq)]
7167pub enum BareStringChildren<'tree> {
7168 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
7169 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
7170 StringContent(::std::boxed::Box<StringContent<'tree>>),
7171}
7172impl<'tree> ::treesitter_types::FromNode<'tree> for BareStringChildren<'tree> {
7173 #[allow(clippy::collapsible_else_if)]
7174 fn from_node(
7175 node: ::tree_sitter::Node<'tree>,
7176 src: &'tree [u8],
7177 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7178 match node.kind() {
7179 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
7180 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
7181 ))),
7182 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
7183 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
7184 ))),
7185 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
7186 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
7187 ))),
7188 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7189 }
7190 }
7191}
7192impl ::treesitter_types::Spanned for BareStringChildren<'_> {
7193 fn span(&self) -> ::treesitter_types::Span {
7194 match self {
7195 Self::EscapeSequence(inner) => inner.span(),
7196 Self::Interpolation(inner) => inner.span(),
7197 Self::StringContent(inner) => inner.span(),
7198 }
7199 }
7200}
7201#[derive(Debug, Clone, PartialEq, Eq)]
7202pub enum BareSymbolChildren<'tree> {
7203 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
7204 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
7205 StringContent(::std::boxed::Box<StringContent<'tree>>),
7206}
7207impl<'tree> ::treesitter_types::FromNode<'tree> for BareSymbolChildren<'tree> {
7208 #[allow(clippy::collapsible_else_if)]
7209 fn from_node(
7210 node: ::tree_sitter::Node<'tree>,
7211 src: &'tree [u8],
7212 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7213 match node.kind() {
7214 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
7215 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
7216 ))),
7217 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
7218 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
7219 ))),
7220 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
7221 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
7222 ))),
7223 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7224 }
7225 }
7226}
7227impl ::treesitter_types::Spanned for BareSymbolChildren<'_> {
7228 fn span(&self) -> ::treesitter_types::Span {
7229 match self {
7230 Self::EscapeSequence(inner) => inner.span(),
7231 Self::Interpolation(inner) => inner.span(),
7232 Self::StringContent(inner) => inner.span(),
7233 }
7234 }
7235}
7236#[derive(Debug, Clone, PartialEq, Eq)]
7237pub enum BeginChildren<'tree> {
7238 Statement(::std::boxed::Box<Statement<'tree>>),
7239 Else(::std::boxed::Box<Else<'tree>>),
7240 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7241 Ensure(::std::boxed::Box<Ensure<'tree>>),
7242 Rescue(::std::boxed::Box<Rescue<'tree>>),
7243}
7244impl<'tree> ::treesitter_types::FromNode<'tree> for BeginChildren<'tree> {
7245 #[allow(clippy::collapsible_else_if)]
7246 fn from_node(
7247 node: ::tree_sitter::Node<'tree>,
7248 src: &'tree [u8],
7249 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7250 match node.kind() {
7251 "else" => Ok(Self::Else(::std::boxed::Box::new(
7252 <Else as ::treesitter_types::FromNode>::from_node(node, src)?,
7253 ))),
7254 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7255 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
7256 ))),
7257 "ensure" => Ok(Self::Ensure(::std::boxed::Box::new(
7258 <Ensure as ::treesitter_types::FromNode>::from_node(node, src)?,
7259 ))),
7260 "rescue" => Ok(Self::Rescue(::std::boxed::Box::new(
7261 <Rescue as ::treesitter_types::FromNode>::from_node(node, src)?,
7262 ))),
7263 _other => {
7264 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
7265 Ok(Self::Statement(::std::boxed::Box::new(v)))
7266 } else {
7267 Err(::treesitter_types::ParseError::unexpected_kind(
7268 _other, node,
7269 ))
7270 }
7271 }
7272 }
7273 }
7274}
7275impl ::treesitter_types::Spanned for BeginChildren<'_> {
7276 fn span(&self) -> ::treesitter_types::Span {
7277 match self {
7278 Self::Statement(inner) => inner.span(),
7279 Self::Else(inner) => inner.span(),
7280 Self::EmptyStatement(inner) => inner.span(),
7281 Self::Ensure(inner) => inner.span(),
7282 Self::Rescue(inner) => inner.span(),
7283 }
7284 }
7285}
7286#[derive(Debug, Clone, PartialEq, Eq)]
7287pub enum BeginBlockChildren<'tree> {
7288 Statement(::std::boxed::Box<Statement<'tree>>),
7289 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7290}
7291impl<'tree> ::treesitter_types::FromNode<'tree> for BeginBlockChildren<'tree> {
7292 #[allow(clippy::collapsible_else_if)]
7293 fn from_node(
7294 node: ::tree_sitter::Node<'tree>,
7295 src: &'tree [u8],
7296 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7297 match node.kind() {
7298 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7299 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
7300 ))),
7301 _other => {
7302 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
7303 Ok(Self::Statement(::std::boxed::Box::new(v)))
7304 } else {
7305 Err(::treesitter_types::ParseError::unexpected_kind(
7306 _other, node,
7307 ))
7308 }
7309 }
7310 }
7311 }
7312}
7313impl ::treesitter_types::Spanned for BeginBlockChildren<'_> {
7314 fn span(&self) -> ::treesitter_types::Span {
7315 match self {
7316 Self::Statement(inner) => inner.span(),
7317 Self::EmptyStatement(inner) => inner.span(),
7318 }
7319 }
7320}
7321#[derive(Debug, Clone, PartialEq, Eq)]
7322pub enum BinaryLeft<'tree> {
7323 Expression(::std::boxed::Box<Expression<'tree>>),
7324 SimpleNumeric(::std::boxed::Box<SimpleNumeric<'tree>>),
7325}
7326impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryLeft<'tree> {
7327 #[allow(clippy::collapsible_else_if)]
7328 fn from_node(
7329 node: ::tree_sitter::Node<'tree>,
7330 src: &'tree [u8],
7331 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7332 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
7333 Ok(Self::Expression(::std::boxed::Box::new(v)))
7334 } else {
7335 if let Ok(v) = <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src) {
7336 Ok(Self::SimpleNumeric(::std::boxed::Box::new(v)))
7337 } else {
7338 Err(::treesitter_types::ParseError::unexpected_kind(
7339 node.kind(),
7340 node,
7341 ))
7342 }
7343 }
7344 }
7345}
7346impl ::treesitter_types::Spanned for BinaryLeft<'_> {
7347 fn span(&self) -> ::treesitter_types::Span {
7348 match self {
7349 Self::Expression(inner) => inner.span(),
7350 Self::SimpleNumeric(inner) => inner.span(),
7351 }
7352 }
7353}
7354#[derive(Debug, Clone, PartialEq, Eq)]
7355pub enum BinaryOperator {
7356 NotEq(::treesitter_types::Span),
7357 BangTilde(::treesitter_types::Span),
7358 Percent(::treesitter_types::Span),
7359 Amp(::treesitter_types::Span),
7360 AmpAmp(::treesitter_types::Span),
7361 Star(::treesitter_types::Span),
7362 StarStar(::treesitter_types::Span),
7363 Plus(::treesitter_types::Span),
7364 Minus(::treesitter_types::Span),
7365 Slash(::treesitter_types::Span),
7366 Lt(::treesitter_types::Span),
7367 Shl(::treesitter_types::Span),
7368 LtEq(::treesitter_types::Span),
7369 LtEqGt(::treesitter_types::Span),
7370 EqEq(::treesitter_types::Span),
7371 EqEqEq(::treesitter_types::Span),
7372 EqTilde(::treesitter_types::Span),
7373 Gt(::treesitter_types::Span),
7374 GtEq(::treesitter_types::Span),
7375 Shr(::treesitter_types::Span),
7376 Caret(::treesitter_types::Span),
7377 And(::treesitter_types::Span),
7378 Or(::treesitter_types::Span),
7379 Pipe(::treesitter_types::Span),
7380 PipePipe(::treesitter_types::Span),
7381}
7382impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryOperator {
7383 #[allow(clippy::collapsible_else_if)]
7384 fn from_node(
7385 node: ::tree_sitter::Node<'tree>,
7386 _src: &'tree [u8],
7387 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7388 match node.kind() {
7389 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
7390 "!~" => Ok(Self::BangTilde(::treesitter_types::Span::from(node))),
7391 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
7392 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
7393 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
7394 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
7395 "**" => Ok(Self::StarStar(::treesitter_types::Span::from(node))),
7396 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
7397 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
7398 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
7399 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
7400 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
7401 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
7402 "<=>" => Ok(Self::LtEqGt(::treesitter_types::Span::from(node))),
7403 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
7404 "===" => Ok(Self::EqEqEq(::treesitter_types::Span::from(node))),
7405 "=~" => Ok(Self::EqTilde(::treesitter_types::Span::from(node))),
7406 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
7407 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
7408 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
7409 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
7410 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
7411 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
7412 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
7413 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
7414 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7415 }
7416 }
7417}
7418impl ::treesitter_types::Spanned for BinaryOperator {
7419 fn span(&self) -> ::treesitter_types::Span {
7420 match self {
7421 Self::NotEq(span) => *span,
7422 Self::BangTilde(span) => *span,
7423 Self::Percent(span) => *span,
7424 Self::Amp(span) => *span,
7425 Self::AmpAmp(span) => *span,
7426 Self::Star(span) => *span,
7427 Self::StarStar(span) => *span,
7428 Self::Plus(span) => *span,
7429 Self::Minus(span) => *span,
7430 Self::Slash(span) => *span,
7431 Self::Lt(span) => *span,
7432 Self::Shl(span) => *span,
7433 Self::LtEq(span) => *span,
7434 Self::LtEqGt(span) => *span,
7435 Self::EqEq(span) => *span,
7436 Self::EqEqEq(span) => *span,
7437 Self::EqTilde(span) => *span,
7438 Self::Gt(span) => *span,
7439 Self::GtEq(span) => *span,
7440 Self::Shr(span) => *span,
7441 Self::Caret(span) => *span,
7442 Self::And(span) => *span,
7443 Self::Or(span) => *span,
7444 Self::Pipe(span) => *span,
7445 Self::PipePipe(span) => *span,
7446 }
7447 }
7448}
7449#[derive(Debug, Clone, PartialEq, Eq)]
7450pub enum BlockBodyChildren<'tree> {
7451 Statement(::std::boxed::Box<Statement<'tree>>),
7452 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7453}
7454impl<'tree> ::treesitter_types::FromNode<'tree> for BlockBodyChildren<'tree> {
7455 #[allow(clippy::collapsible_else_if)]
7456 fn from_node(
7457 node: ::tree_sitter::Node<'tree>,
7458 src: &'tree [u8],
7459 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7460 match node.kind() {
7461 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7462 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
7463 ))),
7464 _other => {
7465 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
7466 Ok(Self::Statement(::std::boxed::Box::new(v)))
7467 } else {
7468 Err(::treesitter_types::ParseError::unexpected_kind(
7469 _other, node,
7470 ))
7471 }
7472 }
7473 }
7474 }
7475}
7476impl ::treesitter_types::Spanned for BlockBodyChildren<'_> {
7477 fn span(&self) -> ::treesitter_types::Span {
7478 match self {
7479 Self::Statement(inner) => inner.span(),
7480 Self::EmptyStatement(inner) => inner.span(),
7481 }
7482 }
7483}
7484#[derive(Debug, Clone, PartialEq, Eq)]
7485pub enum BlockParametersChildren<'tree> {
7486 BlockParameter(::std::boxed::Box<BlockParameter<'tree>>),
7487 DestructuredParameter(::std::boxed::Box<DestructuredParameter<'tree>>),
7488 ForwardParameter(::std::boxed::Box<ForwardParameter<'tree>>),
7489 HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
7490 HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
7491 Identifier(::std::boxed::Box<Identifier<'tree>>),
7492 KeywordParameter(::std::boxed::Box<KeywordParameter<'tree>>),
7493 OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
7494 SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
7495}
7496impl<'tree> ::treesitter_types::FromNode<'tree> for BlockParametersChildren<'tree> {
7497 #[allow(clippy::collapsible_else_if)]
7498 fn from_node(
7499 node: ::tree_sitter::Node<'tree>,
7500 src: &'tree [u8],
7501 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7502 match node.kind() {
7503 "block_parameter" => Ok(Self::BlockParameter(::std::boxed::Box::new(
7504 <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7505 ))),
7506 "destructured_parameter" => Ok(Self::DestructuredParameter(::std::boxed::Box::new(
7507 <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7508 ))),
7509 "forward_parameter" => Ok(Self::ForwardParameter(::std::boxed::Box::new(
7510 <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7511 ))),
7512 "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
7513 <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)?,
7514 ))),
7515 "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
7516 <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7517 ))),
7518 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7519 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7520 ))),
7521 "keyword_parameter" => Ok(Self::KeywordParameter(::std::boxed::Box::new(
7522 <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7523 ))),
7524 "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
7525 <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7526 ))),
7527 "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
7528 <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7529 ))),
7530 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7531 }
7532 }
7533}
7534impl ::treesitter_types::Spanned for BlockParametersChildren<'_> {
7535 fn span(&self) -> ::treesitter_types::Span {
7536 match self {
7537 Self::BlockParameter(inner) => inner.span(),
7538 Self::DestructuredParameter(inner) => inner.span(),
7539 Self::ForwardParameter(inner) => inner.span(),
7540 Self::HashSplatNil(inner) => inner.span(),
7541 Self::HashSplatParameter(inner) => inner.span(),
7542 Self::Identifier(inner) => inner.span(),
7543 Self::KeywordParameter(inner) => inner.span(),
7544 Self::OptionalParameter(inner) => inner.span(),
7545 Self::SplatParameter(inner) => inner.span(),
7546 }
7547 }
7548}
7549#[derive(Debug, Clone, PartialEq, Eq)]
7550pub enum BodyStatementChildren<'tree> {
7551 Statement(::std::boxed::Box<Statement<'tree>>),
7552 Else(::std::boxed::Box<Else<'tree>>),
7553 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7554 Ensure(::std::boxed::Box<Ensure<'tree>>),
7555 Rescue(::std::boxed::Box<Rescue<'tree>>),
7556}
7557impl<'tree> ::treesitter_types::FromNode<'tree> for BodyStatementChildren<'tree> {
7558 #[allow(clippy::collapsible_else_if)]
7559 fn from_node(
7560 node: ::tree_sitter::Node<'tree>,
7561 src: &'tree [u8],
7562 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7563 match node.kind() {
7564 "else" => Ok(Self::Else(::std::boxed::Box::new(
7565 <Else as ::treesitter_types::FromNode>::from_node(node, src)?,
7566 ))),
7567 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7568 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
7569 ))),
7570 "ensure" => Ok(Self::Ensure(::std::boxed::Box::new(
7571 <Ensure as ::treesitter_types::FromNode>::from_node(node, src)?,
7572 ))),
7573 "rescue" => Ok(Self::Rescue(::std::boxed::Box::new(
7574 <Rescue as ::treesitter_types::FromNode>::from_node(node, src)?,
7575 ))),
7576 _other => {
7577 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
7578 Ok(Self::Statement(::std::boxed::Box::new(v)))
7579 } else {
7580 Err(::treesitter_types::ParseError::unexpected_kind(
7581 _other, node,
7582 ))
7583 }
7584 }
7585 }
7586 }
7587}
7588impl ::treesitter_types::Spanned for BodyStatementChildren<'_> {
7589 fn span(&self) -> ::treesitter_types::Span {
7590 match self {
7591 Self::Statement(inner) => inner.span(),
7592 Self::Else(inner) => inner.span(),
7593 Self::EmptyStatement(inner) => inner.span(),
7594 Self::Ensure(inner) => inner.span(),
7595 Self::Rescue(inner) => inner.span(),
7596 }
7597 }
7598}
7599#[derive(Debug, Clone, PartialEq, Eq)]
7600pub enum CallBlock<'tree> {
7601 Block(::std::boxed::Box<Block<'tree>>),
7602 DoBlock(::std::boxed::Box<DoBlock<'tree>>),
7603}
7604impl<'tree> ::treesitter_types::FromNode<'tree> for CallBlock<'tree> {
7605 #[allow(clippy::collapsible_else_if)]
7606 fn from_node(
7607 node: ::tree_sitter::Node<'tree>,
7608 src: &'tree [u8],
7609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7610 match node.kind() {
7611 "block" => Ok(Self::Block(::std::boxed::Box::new(
7612 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
7613 ))),
7614 "do_block" => Ok(Self::DoBlock(::std::boxed::Box::new(
7615 <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
7616 ))),
7617 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7618 }
7619 }
7620}
7621impl ::treesitter_types::Spanned for CallBlock<'_> {
7622 fn span(&self) -> ::treesitter_types::Span {
7623 match self {
7624 Self::Block(inner) => inner.span(),
7625 Self::DoBlock(inner) => inner.span(),
7626 }
7627 }
7628}
7629#[derive(Debug, Clone, PartialEq, Eq)]
7630pub enum CallMethod<'tree> {
7631 Variable(::std::boxed::Box<Variable<'tree>>),
7632 Operator(::std::boxed::Box<Operator<'tree>>),
7633}
7634impl<'tree> ::treesitter_types::FromNode<'tree> for CallMethod<'tree> {
7635 #[allow(clippy::collapsible_else_if)]
7636 fn from_node(
7637 node: ::tree_sitter::Node<'tree>,
7638 src: &'tree [u8],
7639 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7640 match node.kind() {
7641 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
7642 <Operator as ::treesitter_types::FromNode>::from_node(node, src)?,
7643 ))),
7644 _other => {
7645 if let Ok(v) = <Variable as ::treesitter_types::FromNode>::from_node(node, src) {
7646 Ok(Self::Variable(::std::boxed::Box::new(v)))
7647 } else {
7648 Err(::treesitter_types::ParseError::unexpected_kind(
7649 _other, node,
7650 ))
7651 }
7652 }
7653 }
7654 }
7655}
7656impl ::treesitter_types::Spanned for CallMethod<'_> {
7657 fn span(&self) -> ::treesitter_types::Span {
7658 match self {
7659 Self::Variable(inner) => inner.span(),
7660 Self::Operator(inner) => inner.span(),
7661 }
7662 }
7663}
7664#[derive(Debug, Clone, PartialEq, Eq)]
7665pub enum CaseChildren<'tree> {
7666 Else(::std::boxed::Box<Else<'tree>>),
7667 When(::std::boxed::Box<When<'tree>>),
7668}
7669impl<'tree> ::treesitter_types::FromNode<'tree> for CaseChildren<'tree> {
7670 #[allow(clippy::collapsible_else_if)]
7671 fn from_node(
7672 node: ::tree_sitter::Node<'tree>,
7673 src: &'tree [u8],
7674 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7675 match node.kind() {
7676 "else" => Ok(Self::Else(::std::boxed::Box::new(
7677 <Else as ::treesitter_types::FromNode>::from_node(node, src)?,
7678 ))),
7679 "when" => Ok(Self::When(::std::boxed::Box::new(
7680 <When as ::treesitter_types::FromNode>::from_node(node, src)?,
7681 ))),
7682 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7683 }
7684 }
7685}
7686impl ::treesitter_types::Spanned for CaseChildren<'_> {
7687 fn span(&self) -> ::treesitter_types::Span {
7688 match self {
7689 Self::Else(inner) => inner.span(),
7690 Self::When(inner) => inner.span(),
7691 }
7692 }
7693}
7694#[derive(Debug, Clone, PartialEq, Eq)]
7695pub enum ClassName<'tree> {
7696 Constant(::std::boxed::Box<Constant<'tree>>),
7697 ScopeResolution(::std::boxed::Box<ScopeResolution<'tree>>),
7698}
7699impl<'tree> ::treesitter_types::FromNode<'tree> for ClassName<'tree> {
7700 #[allow(clippy::collapsible_else_if)]
7701 fn from_node(
7702 node: ::tree_sitter::Node<'tree>,
7703 src: &'tree [u8],
7704 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7705 match node.kind() {
7706 "constant" => Ok(Self::Constant(::std::boxed::Box::new(
7707 <Constant as ::treesitter_types::FromNode>::from_node(node, src)?,
7708 ))),
7709 "scope_resolution" => Ok(Self::ScopeResolution(::std::boxed::Box::new(
7710 <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)?,
7711 ))),
7712 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7713 }
7714 }
7715}
7716impl ::treesitter_types::Spanned for ClassName<'_> {
7717 fn span(&self) -> ::treesitter_types::Span {
7718 match self {
7719 Self::Constant(inner) => inner.span(),
7720 Self::ScopeResolution(inner) => inner.span(),
7721 }
7722 }
7723}
7724#[derive(Debug, Clone, PartialEq, Eq)]
7725pub enum ComplexChildren<'tree> {
7726 Float(::std::boxed::Box<Float<'tree>>),
7727 Integer(::std::boxed::Box<Integer<'tree>>),
7728 Rational(::std::boxed::Box<Rational<'tree>>),
7729}
7730impl<'tree> ::treesitter_types::FromNode<'tree> for ComplexChildren<'tree> {
7731 #[allow(clippy::collapsible_else_if)]
7732 fn from_node(
7733 node: ::tree_sitter::Node<'tree>,
7734 src: &'tree [u8],
7735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7736 match node.kind() {
7737 "float" => Ok(Self::Float(::std::boxed::Box::new(
7738 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
7739 ))),
7740 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
7741 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
7742 ))),
7743 "rational" => Ok(Self::Rational(::std::boxed::Box::new(
7744 <Rational as ::treesitter_types::FromNode>::from_node(node, src)?,
7745 ))),
7746 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7747 }
7748 }
7749}
7750impl ::treesitter_types::Spanned for ComplexChildren<'_> {
7751 fn span(&self) -> ::treesitter_types::Span {
7752 match self {
7753 Self::Float(inner) => inner.span(),
7754 Self::Integer(inner) => inner.span(),
7755 Self::Rational(inner) => inner.span(),
7756 }
7757 }
7758}
7759#[derive(Debug, Clone, PartialEq, Eq)]
7760pub enum DelimitedSymbolChildren<'tree> {
7761 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
7762 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
7763 StringContent(::std::boxed::Box<StringContent<'tree>>),
7764}
7765impl<'tree> ::treesitter_types::FromNode<'tree> for DelimitedSymbolChildren<'tree> {
7766 #[allow(clippy::collapsible_else_if)]
7767 fn from_node(
7768 node: ::tree_sitter::Node<'tree>,
7769 src: &'tree [u8],
7770 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7771 match node.kind() {
7772 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
7773 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
7774 ))),
7775 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
7776 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
7777 ))),
7778 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
7779 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
7780 ))),
7781 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7782 }
7783 }
7784}
7785impl ::treesitter_types::Spanned for DelimitedSymbolChildren<'_> {
7786 fn span(&self) -> ::treesitter_types::Span {
7787 match self {
7788 Self::EscapeSequence(inner) => inner.span(),
7789 Self::Interpolation(inner) => inner.span(),
7790 Self::StringContent(inner) => inner.span(),
7791 }
7792 }
7793}
7794#[derive(Debug, Clone, PartialEq, Eq)]
7795pub enum DestructuredLeftAssignmentChildren<'tree> {
7796 Lhs(::std::boxed::Box<Lhs<'tree>>),
7797 DestructuredLeftAssignment(::std::boxed::Box<DestructuredLeftAssignment<'tree>>),
7798 RestAssignment(::std::boxed::Box<RestAssignment<'tree>>),
7799}
7800impl<'tree> ::treesitter_types::FromNode<'tree> for DestructuredLeftAssignmentChildren<'tree> {
7801 #[allow(clippy::collapsible_else_if)]
7802 fn from_node(
7803 node: ::tree_sitter::Node<'tree>,
7804 src: &'tree [u8],
7805 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7806 match node.kind() {
7807 "destructured_left_assignment" => {
7808 Ok(Self::DestructuredLeftAssignment(::std::boxed::Box::new(
7809 <DestructuredLeftAssignment as ::treesitter_types::FromNode>::from_node(
7810 node, src,
7811 )?,
7812 )))
7813 }
7814 "rest_assignment" => Ok(Self::RestAssignment(::std::boxed::Box::new(
7815 <RestAssignment as ::treesitter_types::FromNode>::from_node(node, src)?,
7816 ))),
7817 _other => {
7818 if let Ok(v) = <Lhs as ::treesitter_types::FromNode>::from_node(node, src) {
7819 Ok(Self::Lhs(::std::boxed::Box::new(v)))
7820 } else {
7821 Err(::treesitter_types::ParseError::unexpected_kind(
7822 _other, node,
7823 ))
7824 }
7825 }
7826 }
7827 }
7828}
7829impl ::treesitter_types::Spanned for DestructuredLeftAssignmentChildren<'_> {
7830 fn span(&self) -> ::treesitter_types::Span {
7831 match self {
7832 Self::Lhs(inner) => inner.span(),
7833 Self::DestructuredLeftAssignment(inner) => inner.span(),
7834 Self::RestAssignment(inner) => inner.span(),
7835 }
7836 }
7837}
7838#[derive(Debug, Clone, PartialEq, Eq)]
7839pub enum DestructuredParameterChildren<'tree> {
7840 BlockParameter(::std::boxed::Box<BlockParameter<'tree>>),
7841 DestructuredParameter(::std::boxed::Box<DestructuredParameter<'tree>>),
7842 ForwardParameter(::std::boxed::Box<ForwardParameter<'tree>>),
7843 HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
7844 HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
7845 Identifier(::std::boxed::Box<Identifier<'tree>>),
7846 KeywordParameter(::std::boxed::Box<KeywordParameter<'tree>>),
7847 OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
7848 SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
7849}
7850impl<'tree> ::treesitter_types::FromNode<'tree> for DestructuredParameterChildren<'tree> {
7851 #[allow(clippy::collapsible_else_if)]
7852 fn from_node(
7853 node: ::tree_sitter::Node<'tree>,
7854 src: &'tree [u8],
7855 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7856 match node.kind() {
7857 "block_parameter" => Ok(Self::BlockParameter(::std::boxed::Box::new(
7858 <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7859 ))),
7860 "destructured_parameter" => Ok(Self::DestructuredParameter(::std::boxed::Box::new(
7861 <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7862 ))),
7863 "forward_parameter" => Ok(Self::ForwardParameter(::std::boxed::Box::new(
7864 <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7865 ))),
7866 "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
7867 <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)?,
7868 ))),
7869 "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
7870 <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7871 ))),
7872 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7873 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7874 ))),
7875 "keyword_parameter" => Ok(Self::KeywordParameter(::std::boxed::Box::new(
7876 <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7877 ))),
7878 "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
7879 <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7880 ))),
7881 "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
7882 <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
7883 ))),
7884 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7885 }
7886 }
7887}
7888impl ::treesitter_types::Spanned for DestructuredParameterChildren<'_> {
7889 fn span(&self) -> ::treesitter_types::Span {
7890 match self {
7891 Self::BlockParameter(inner) => inner.span(),
7892 Self::DestructuredParameter(inner) => inner.span(),
7893 Self::ForwardParameter(inner) => inner.span(),
7894 Self::HashSplatNil(inner) => inner.span(),
7895 Self::HashSplatParameter(inner) => inner.span(),
7896 Self::Identifier(inner) => inner.span(),
7897 Self::KeywordParameter(inner) => inner.span(),
7898 Self::OptionalParameter(inner) => inner.span(),
7899 Self::SplatParameter(inner) => inner.span(),
7900 }
7901 }
7902}
7903#[derive(Debug, Clone, PartialEq, Eq)]
7904pub enum DoChildren<'tree> {
7905 Statement(::std::boxed::Box<Statement<'tree>>),
7906 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7907}
7908impl<'tree> ::treesitter_types::FromNode<'tree> for DoChildren<'tree> {
7909 #[allow(clippy::collapsible_else_if)]
7910 fn from_node(
7911 node: ::tree_sitter::Node<'tree>,
7912 src: &'tree [u8],
7913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7914 match node.kind() {
7915 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7916 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
7917 ))),
7918 _other => {
7919 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
7920 Ok(Self::Statement(::std::boxed::Box::new(v)))
7921 } else {
7922 Err(::treesitter_types::ParseError::unexpected_kind(
7923 _other, node,
7924 ))
7925 }
7926 }
7927 }
7928 }
7929}
7930impl ::treesitter_types::Spanned for DoChildren<'_> {
7931 fn span(&self) -> ::treesitter_types::Span {
7932 match self {
7933 Self::Statement(inner) => inner.span(),
7934 Self::EmptyStatement(inner) => inner.span(),
7935 }
7936 }
7937}
7938#[derive(Debug, Clone, PartialEq, Eq)]
7939pub enum ElementReferenceBlock<'tree> {
7940 Block(::std::boxed::Box<Block<'tree>>),
7941 DoBlock(::std::boxed::Box<DoBlock<'tree>>),
7942}
7943impl<'tree> ::treesitter_types::FromNode<'tree> for ElementReferenceBlock<'tree> {
7944 #[allow(clippy::collapsible_else_if)]
7945 fn from_node(
7946 node: ::tree_sitter::Node<'tree>,
7947 src: &'tree [u8],
7948 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7949 match node.kind() {
7950 "block" => Ok(Self::Block(::std::boxed::Box::new(
7951 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
7952 ))),
7953 "do_block" => Ok(Self::DoBlock(::std::boxed::Box::new(
7954 <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
7955 ))),
7956 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7957 }
7958 }
7959}
7960impl ::treesitter_types::Spanned for ElementReferenceBlock<'_> {
7961 fn span(&self) -> ::treesitter_types::Span {
7962 match self {
7963 Self::Block(inner) => inner.span(),
7964 Self::DoBlock(inner) => inner.span(),
7965 }
7966 }
7967}
7968#[derive(Debug, Clone, PartialEq, Eq)]
7969pub enum ElementReferenceChildren<'tree> {
7970 Expression(::std::boxed::Box<Expression<'tree>>),
7971 BlockArgument(::std::boxed::Box<BlockArgument<'tree>>),
7972 ForwardArgument(::std::boxed::Box<ForwardArgument<'tree>>),
7973 HashSplatArgument(::std::boxed::Box<HashSplatArgument<'tree>>),
7974 Pair(::std::boxed::Box<Pair<'tree>>),
7975 SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
7976}
7977impl<'tree> ::treesitter_types::FromNode<'tree> for ElementReferenceChildren<'tree> {
7978 #[allow(clippy::collapsible_else_if)]
7979 fn from_node(
7980 node: ::tree_sitter::Node<'tree>,
7981 src: &'tree [u8],
7982 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7983 match node.kind() {
7984 "block_argument" => Ok(Self::BlockArgument(::std::boxed::Box::new(
7985 <BlockArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
7986 ))),
7987 "forward_argument" => Ok(Self::ForwardArgument(::std::boxed::Box::new(
7988 <ForwardArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
7989 ))),
7990 "hash_splat_argument" => Ok(Self::HashSplatArgument(::std::boxed::Box::new(
7991 <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
7992 ))),
7993 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
7994 <Pair as ::treesitter_types::FromNode>::from_node(node, src)?,
7995 ))),
7996 "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
7997 <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
7998 ))),
7999 _other => {
8000 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8001 Ok(Self::Expression(::std::boxed::Box::new(v)))
8002 } else {
8003 Err(::treesitter_types::ParseError::unexpected_kind(
8004 _other, node,
8005 ))
8006 }
8007 }
8008 }
8009 }
8010}
8011impl ::treesitter_types::Spanned for ElementReferenceChildren<'_> {
8012 fn span(&self) -> ::treesitter_types::Span {
8013 match self {
8014 Self::Expression(inner) => inner.span(),
8015 Self::BlockArgument(inner) => inner.span(),
8016 Self::ForwardArgument(inner) => inner.span(),
8017 Self::HashSplatArgument(inner) => inner.span(),
8018 Self::Pair(inner) => inner.span(),
8019 Self::SplatArgument(inner) => inner.span(),
8020 }
8021 }
8022}
8023#[derive(Debug, Clone, PartialEq, Eq)]
8024pub enum ElseChildren<'tree> {
8025 Statement(::std::boxed::Box<Statement<'tree>>),
8026 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8027}
8028impl<'tree> ::treesitter_types::FromNode<'tree> for ElseChildren<'tree> {
8029 #[allow(clippy::collapsible_else_if)]
8030 fn from_node(
8031 node: ::tree_sitter::Node<'tree>,
8032 src: &'tree [u8],
8033 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8034 match node.kind() {
8035 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8036 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
8037 ))),
8038 _other => {
8039 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
8040 Ok(Self::Statement(::std::boxed::Box::new(v)))
8041 } else {
8042 Err(::treesitter_types::ParseError::unexpected_kind(
8043 _other, node,
8044 ))
8045 }
8046 }
8047 }
8048 }
8049}
8050impl ::treesitter_types::Spanned for ElseChildren<'_> {
8051 fn span(&self) -> ::treesitter_types::Span {
8052 match self {
8053 Self::Statement(inner) => inner.span(),
8054 Self::EmptyStatement(inner) => inner.span(),
8055 }
8056 }
8057}
8058#[derive(Debug, Clone, PartialEq, Eq)]
8059pub enum ElsifAlternative<'tree> {
8060 Else(::std::boxed::Box<Else<'tree>>),
8061 Elsif(::std::boxed::Box<Elsif<'tree>>),
8062}
8063impl<'tree> ::treesitter_types::FromNode<'tree> for ElsifAlternative<'tree> {
8064 #[allow(clippy::collapsible_else_if)]
8065 fn from_node(
8066 node: ::tree_sitter::Node<'tree>,
8067 src: &'tree [u8],
8068 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8069 match node.kind() {
8070 "else" => Ok(Self::Else(::std::boxed::Box::new(
8071 <Else as ::treesitter_types::FromNode>::from_node(node, src)?,
8072 ))),
8073 "elsif" => Ok(Self::Elsif(::std::boxed::Box::new(
8074 <Elsif as ::treesitter_types::FromNode>::from_node(node, src)?,
8075 ))),
8076 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8077 }
8078 }
8079}
8080impl ::treesitter_types::Spanned for ElsifAlternative<'_> {
8081 fn span(&self) -> ::treesitter_types::Span {
8082 match self {
8083 Self::Else(inner) => inner.span(),
8084 Self::Elsif(inner) => inner.span(),
8085 }
8086 }
8087}
8088#[derive(Debug, Clone, PartialEq, Eq)]
8089pub enum EndBlockChildren<'tree> {
8090 Statement(::std::boxed::Box<Statement<'tree>>),
8091 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8092}
8093impl<'tree> ::treesitter_types::FromNode<'tree> for EndBlockChildren<'tree> {
8094 #[allow(clippy::collapsible_else_if)]
8095 fn from_node(
8096 node: ::tree_sitter::Node<'tree>,
8097 src: &'tree [u8],
8098 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8099 match node.kind() {
8100 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8101 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
8102 ))),
8103 _other => {
8104 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
8105 Ok(Self::Statement(::std::boxed::Box::new(v)))
8106 } else {
8107 Err(::treesitter_types::ParseError::unexpected_kind(
8108 _other, node,
8109 ))
8110 }
8111 }
8112 }
8113 }
8114}
8115impl ::treesitter_types::Spanned for EndBlockChildren<'_> {
8116 fn span(&self) -> ::treesitter_types::Span {
8117 match self {
8118 Self::Statement(inner) => inner.span(),
8119 Self::EmptyStatement(inner) => inner.span(),
8120 }
8121 }
8122}
8123#[derive(Debug, Clone, PartialEq, Eq)]
8124pub enum EnsureChildren<'tree> {
8125 Statement(::std::boxed::Box<Statement<'tree>>),
8126 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8127}
8128impl<'tree> ::treesitter_types::FromNode<'tree> for EnsureChildren<'tree> {
8129 #[allow(clippy::collapsible_else_if)]
8130 fn from_node(
8131 node: ::tree_sitter::Node<'tree>,
8132 src: &'tree [u8],
8133 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8134 match node.kind() {
8135 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8136 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
8137 ))),
8138 _other => {
8139 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
8140 Ok(Self::Statement(::std::boxed::Box::new(v)))
8141 } else {
8142 Err(::treesitter_types::ParseError::unexpected_kind(
8143 _other, node,
8144 ))
8145 }
8146 }
8147 }
8148 }
8149}
8150impl ::treesitter_types::Spanned for EnsureChildren<'_> {
8151 fn span(&self) -> ::treesitter_types::Span {
8152 match self {
8153 Self::Statement(inner) => inner.span(),
8154 Self::EmptyStatement(inner) => inner.span(),
8155 }
8156 }
8157}
8158#[derive(Debug, Clone, PartialEq, Eq)]
8159pub enum ExceptionsChildren<'tree> {
8160 Arg(::std::boxed::Box<Arg<'tree>>),
8161 SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
8162}
8163impl<'tree> ::treesitter_types::FromNode<'tree> for ExceptionsChildren<'tree> {
8164 #[allow(clippy::collapsible_else_if)]
8165 fn from_node(
8166 node: ::tree_sitter::Node<'tree>,
8167 src: &'tree [u8],
8168 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8169 match node.kind() {
8170 "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
8171 <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
8172 ))),
8173 _other => {
8174 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
8175 Ok(Self::Arg(::std::boxed::Box::new(v)))
8176 } else {
8177 Err(::treesitter_types::ParseError::unexpected_kind(
8178 _other, node,
8179 ))
8180 }
8181 }
8182 }
8183 }
8184}
8185impl ::treesitter_types::Spanned for ExceptionsChildren<'_> {
8186 fn span(&self) -> ::treesitter_types::Span {
8187 match self {
8188 Self::Arg(inner) => inner.span(),
8189 Self::SplatArgument(inner) => inner.span(),
8190 }
8191 }
8192}
8193#[derive(Debug, Clone, PartialEq, Eq)]
8194pub enum FindPatternChildren<'tree> {
8195 PatternExpr(::std::boxed::Box<PatternExpr<'tree>>),
8196 SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
8197}
8198impl<'tree> ::treesitter_types::FromNode<'tree> for FindPatternChildren<'tree> {
8199 #[allow(clippy::collapsible_else_if)]
8200 fn from_node(
8201 node: ::tree_sitter::Node<'tree>,
8202 src: &'tree [u8],
8203 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8204 match node.kind() {
8205 "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
8206 <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8207 ))),
8208 _other => {
8209 if let Ok(v) = <PatternExpr as ::treesitter_types::FromNode>::from_node(node, src) {
8210 Ok(Self::PatternExpr(::std::boxed::Box::new(v)))
8211 } else {
8212 Err(::treesitter_types::ParseError::unexpected_kind(
8213 _other, node,
8214 ))
8215 }
8216 }
8217 }
8218 }
8219}
8220impl ::treesitter_types::Spanned for FindPatternChildren<'_> {
8221 fn span(&self) -> ::treesitter_types::Span {
8222 match self {
8223 Self::PatternExpr(inner) => inner.span(),
8224 Self::SplatParameter(inner) => inner.span(),
8225 }
8226 }
8227}
8228#[derive(Debug, Clone, PartialEq, Eq)]
8229pub enum ForPattern<'tree> {
8230 Lhs(::std::boxed::Box<Lhs<'tree>>),
8231 LeftAssignmentList(::std::boxed::Box<LeftAssignmentList<'tree>>),
8232}
8233impl<'tree> ::treesitter_types::FromNode<'tree> for ForPattern<'tree> {
8234 #[allow(clippy::collapsible_else_if)]
8235 fn from_node(
8236 node: ::tree_sitter::Node<'tree>,
8237 src: &'tree [u8],
8238 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8239 match node.kind() {
8240 "left_assignment_list" => Ok(Self::LeftAssignmentList(::std::boxed::Box::new(
8241 <LeftAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)?,
8242 ))),
8243 _other => {
8244 if let Ok(v) = <Lhs as ::treesitter_types::FromNode>::from_node(node, src) {
8245 Ok(Self::Lhs(::std::boxed::Box::new(v)))
8246 } else {
8247 Err(::treesitter_types::ParseError::unexpected_kind(
8248 _other, node,
8249 ))
8250 }
8251 }
8252 }
8253 }
8254}
8255impl ::treesitter_types::Spanned for ForPattern<'_> {
8256 fn span(&self) -> ::treesitter_types::Span {
8257 match self {
8258 Self::Lhs(inner) => inner.span(),
8259 Self::LeftAssignmentList(inner) => inner.span(),
8260 }
8261 }
8262}
8263#[derive(Debug, Clone, PartialEq, Eq)]
8264pub enum HashChildren<'tree> {
8265 HashSplatArgument(::std::boxed::Box<HashSplatArgument<'tree>>),
8266 Pair(::std::boxed::Box<Pair<'tree>>),
8267}
8268impl<'tree> ::treesitter_types::FromNode<'tree> for HashChildren<'tree> {
8269 #[allow(clippy::collapsible_else_if)]
8270 fn from_node(
8271 node: ::tree_sitter::Node<'tree>,
8272 src: &'tree [u8],
8273 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8274 match node.kind() {
8275 "hash_splat_argument" => Ok(Self::HashSplatArgument(::std::boxed::Box::new(
8276 <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
8277 ))),
8278 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
8279 <Pair as ::treesitter_types::FromNode>::from_node(node, src)?,
8280 ))),
8281 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8282 }
8283 }
8284}
8285impl ::treesitter_types::Spanned for HashChildren<'_> {
8286 fn span(&self) -> ::treesitter_types::Span {
8287 match self {
8288 Self::HashSplatArgument(inner) => inner.span(),
8289 Self::Pair(inner) => inner.span(),
8290 }
8291 }
8292}
8293#[derive(Debug, Clone, PartialEq, Eq)]
8294pub enum HashPatternChildren<'tree> {
8295 HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
8296 HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
8297 KeywordPattern(::std::boxed::Box<KeywordPattern<'tree>>),
8298}
8299impl<'tree> ::treesitter_types::FromNode<'tree> for HashPatternChildren<'tree> {
8300 #[allow(clippy::collapsible_else_if)]
8301 fn from_node(
8302 node: ::tree_sitter::Node<'tree>,
8303 src: &'tree [u8],
8304 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8305 match node.kind() {
8306 "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
8307 <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)?,
8308 ))),
8309 "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
8310 <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8311 ))),
8312 "keyword_pattern" => Ok(Self::KeywordPattern(::std::boxed::Box::new(
8313 <KeywordPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
8314 ))),
8315 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8316 }
8317 }
8318}
8319impl ::treesitter_types::Spanned for HashPatternChildren<'_> {
8320 fn span(&self) -> ::treesitter_types::Span {
8321 match self {
8322 Self::HashSplatNil(inner) => inner.span(),
8323 Self::HashSplatParameter(inner) => inner.span(),
8324 Self::KeywordPattern(inner) => inner.span(),
8325 }
8326 }
8327}
8328#[derive(Debug, Clone, PartialEq, Eq)]
8329pub enum HeredocBodyChildren<'tree> {
8330 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
8331 HeredocContent(::std::boxed::Box<HeredocContent<'tree>>),
8332 HeredocEnd(::std::boxed::Box<HeredocEnd<'tree>>),
8333 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
8334}
8335impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBodyChildren<'tree> {
8336 #[allow(clippy::collapsible_else_if)]
8337 fn from_node(
8338 node: ::tree_sitter::Node<'tree>,
8339 src: &'tree [u8],
8340 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8341 match node.kind() {
8342 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
8343 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
8344 ))),
8345 "heredoc_content" => Ok(Self::HeredocContent(::std::boxed::Box::new(
8346 <HeredocContent as ::treesitter_types::FromNode>::from_node(node, src)?,
8347 ))),
8348 "heredoc_end" => Ok(Self::HeredocEnd(::std::boxed::Box::new(
8349 <HeredocEnd as ::treesitter_types::FromNode>::from_node(node, src)?,
8350 ))),
8351 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
8352 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
8353 ))),
8354 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8355 }
8356 }
8357}
8358impl ::treesitter_types::Spanned for HeredocBodyChildren<'_> {
8359 fn span(&self) -> ::treesitter_types::Span {
8360 match self {
8361 Self::EscapeSequence(inner) => inner.span(),
8362 Self::HeredocContent(inner) => inner.span(),
8363 Self::HeredocEnd(inner) => inner.span(),
8364 Self::Interpolation(inner) => inner.span(),
8365 }
8366 }
8367}
8368#[derive(Debug, Clone, PartialEq, Eq)]
8369pub enum IfAlternative<'tree> {
8370 Else(::std::boxed::Box<Else<'tree>>),
8371 Elsif(::std::boxed::Box<Elsif<'tree>>),
8372}
8373impl<'tree> ::treesitter_types::FromNode<'tree> for IfAlternative<'tree> {
8374 #[allow(clippy::collapsible_else_if)]
8375 fn from_node(
8376 node: ::tree_sitter::Node<'tree>,
8377 src: &'tree [u8],
8378 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8379 match node.kind() {
8380 "else" => Ok(Self::Else(::std::boxed::Box::new(
8381 <Else as ::treesitter_types::FromNode>::from_node(node, src)?,
8382 ))),
8383 "elsif" => Ok(Self::Elsif(::std::boxed::Box::new(
8384 <Elsif as ::treesitter_types::FromNode>::from_node(node, src)?,
8385 ))),
8386 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8387 }
8388 }
8389}
8390impl ::treesitter_types::Spanned for IfAlternative<'_> {
8391 fn span(&self) -> ::treesitter_types::Span {
8392 match self {
8393 Self::Else(inner) => inner.span(),
8394 Self::Elsif(inner) => inner.span(),
8395 }
8396 }
8397}
8398#[derive(Debug, Clone, PartialEq, Eq)]
8399pub enum InClauseGuard<'tree> {
8400 IfGuard(::std::boxed::Box<IfGuard<'tree>>),
8401 UnlessGuard(::std::boxed::Box<UnlessGuard<'tree>>),
8402}
8403impl<'tree> ::treesitter_types::FromNode<'tree> for InClauseGuard<'tree> {
8404 #[allow(clippy::collapsible_else_if)]
8405 fn from_node(
8406 node: ::tree_sitter::Node<'tree>,
8407 src: &'tree [u8],
8408 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8409 match node.kind() {
8410 "if_guard" => Ok(Self::IfGuard(::std::boxed::Box::new(
8411 <IfGuard as ::treesitter_types::FromNode>::from_node(node, src)?,
8412 ))),
8413 "unless_guard" => Ok(Self::UnlessGuard(::std::boxed::Box::new(
8414 <UnlessGuard as ::treesitter_types::FromNode>::from_node(node, src)?,
8415 ))),
8416 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8417 }
8418 }
8419}
8420impl ::treesitter_types::Spanned for InClauseGuard<'_> {
8421 fn span(&self) -> ::treesitter_types::Span {
8422 match self {
8423 Self::IfGuard(inner) => inner.span(),
8424 Self::UnlessGuard(inner) => inner.span(),
8425 }
8426 }
8427}
8428#[derive(Debug, Clone, PartialEq, Eq)]
8429pub enum InterpolationChildren<'tree> {
8430 NonlocalVariable(::std::boxed::Box<NonlocalVariable<'tree>>),
8431 Statement(::std::boxed::Box<Statement<'tree>>),
8432 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8433}
8434impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationChildren<'tree> {
8435 #[allow(clippy::collapsible_else_if)]
8436 fn from_node(
8437 node: ::tree_sitter::Node<'tree>,
8438 src: &'tree [u8],
8439 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8440 match node.kind() {
8441 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8442 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
8443 ))),
8444 _other => {
8445 if let Ok(v) =
8446 <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
8447 {
8448 Ok(Self::NonlocalVariable(::std::boxed::Box::new(v)))
8449 } else {
8450 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8451 {
8452 Ok(Self::Statement(::std::boxed::Box::new(v)))
8453 } else {
8454 Err(::treesitter_types::ParseError::unexpected_kind(
8455 _other, node,
8456 ))
8457 }
8458 }
8459 }
8460 }
8461 }
8462}
8463impl ::treesitter_types::Spanned for InterpolationChildren<'_> {
8464 fn span(&self) -> ::treesitter_types::Span {
8465 match self {
8466 Self::NonlocalVariable(inner) => inner.span(),
8467 Self::Statement(inner) => inner.span(),
8468 Self::EmptyStatement(inner) => inner.span(),
8469 }
8470 }
8471}
8472#[derive(Debug, Clone, PartialEq, Eq)]
8473pub enum KeywordPatternKey<'tree> {
8474 HashKeySymbol(::std::boxed::Box<HashKeySymbol<'tree>>),
8475 String(::std::boxed::Box<String<'tree>>),
8476}
8477impl<'tree> ::treesitter_types::FromNode<'tree> for KeywordPatternKey<'tree> {
8478 #[allow(clippy::collapsible_else_if)]
8479 fn from_node(
8480 node: ::tree_sitter::Node<'tree>,
8481 src: &'tree [u8],
8482 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8483 match node.kind() {
8484 "hash_key_symbol" => Ok(Self::HashKeySymbol(::std::boxed::Box::new(
8485 <HashKeySymbol as ::treesitter_types::FromNode>::from_node(node, src)?,
8486 ))),
8487 "string" => Ok(Self::String(::std::boxed::Box::new(
8488 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
8489 ))),
8490 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8491 }
8492 }
8493}
8494impl ::treesitter_types::Spanned for KeywordPatternKey<'_> {
8495 fn span(&self) -> ::treesitter_types::Span {
8496 match self {
8497 Self::HashKeySymbol(inner) => inner.span(),
8498 Self::String(inner) => inner.span(),
8499 }
8500 }
8501}
8502#[derive(Debug, Clone, PartialEq, Eq)]
8503pub enum LambdaBody<'tree> {
8504 Block(::std::boxed::Box<Block<'tree>>),
8505 DoBlock(::std::boxed::Box<DoBlock<'tree>>),
8506}
8507impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaBody<'tree> {
8508 #[allow(clippy::collapsible_else_if)]
8509 fn from_node(
8510 node: ::tree_sitter::Node<'tree>,
8511 src: &'tree [u8],
8512 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8513 match node.kind() {
8514 "block" => Ok(Self::Block(::std::boxed::Box::new(
8515 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
8516 ))),
8517 "do_block" => Ok(Self::DoBlock(::std::boxed::Box::new(
8518 <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
8519 ))),
8520 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8521 }
8522 }
8523}
8524impl ::treesitter_types::Spanned for LambdaBody<'_> {
8525 fn span(&self) -> ::treesitter_types::Span {
8526 match self {
8527 Self::Block(inner) => inner.span(),
8528 Self::DoBlock(inner) => inner.span(),
8529 }
8530 }
8531}
8532#[derive(Debug, Clone, PartialEq, Eq)]
8533pub enum LambdaParametersChildren<'tree> {
8534 BlockParameter(::std::boxed::Box<BlockParameter<'tree>>),
8535 DestructuredParameter(::std::boxed::Box<DestructuredParameter<'tree>>),
8536 ForwardParameter(::std::boxed::Box<ForwardParameter<'tree>>),
8537 HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
8538 HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
8539 Identifier(::std::boxed::Box<Identifier<'tree>>),
8540 KeywordParameter(::std::boxed::Box<KeywordParameter<'tree>>),
8541 OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
8542 SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
8543}
8544impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaParametersChildren<'tree> {
8545 #[allow(clippy::collapsible_else_if)]
8546 fn from_node(
8547 node: ::tree_sitter::Node<'tree>,
8548 src: &'tree [u8],
8549 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8550 match node.kind() {
8551 "block_parameter" => Ok(Self::BlockParameter(::std::boxed::Box::new(
8552 <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8553 ))),
8554 "destructured_parameter" => Ok(Self::DestructuredParameter(::std::boxed::Box::new(
8555 <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8556 ))),
8557 "forward_parameter" => Ok(Self::ForwardParameter(::std::boxed::Box::new(
8558 <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8559 ))),
8560 "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
8561 <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)?,
8562 ))),
8563 "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
8564 <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8565 ))),
8566 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8567 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8568 ))),
8569 "keyword_parameter" => Ok(Self::KeywordParameter(::std::boxed::Box::new(
8570 <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8571 ))),
8572 "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
8573 <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8574 ))),
8575 "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
8576 <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8577 ))),
8578 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8579 }
8580 }
8581}
8582impl ::treesitter_types::Spanned for LambdaParametersChildren<'_> {
8583 fn span(&self) -> ::treesitter_types::Span {
8584 match self {
8585 Self::BlockParameter(inner) => inner.span(),
8586 Self::DestructuredParameter(inner) => inner.span(),
8587 Self::ForwardParameter(inner) => inner.span(),
8588 Self::HashSplatNil(inner) => inner.span(),
8589 Self::HashSplatParameter(inner) => inner.span(),
8590 Self::Identifier(inner) => inner.span(),
8591 Self::KeywordParameter(inner) => inner.span(),
8592 Self::OptionalParameter(inner) => inner.span(),
8593 Self::SplatParameter(inner) => inner.span(),
8594 }
8595 }
8596}
8597#[derive(Debug, Clone, PartialEq, Eq)]
8598pub enum LeftAssignmentListChildren<'tree> {
8599 Lhs(::std::boxed::Box<Lhs<'tree>>),
8600 DestructuredLeftAssignment(::std::boxed::Box<DestructuredLeftAssignment<'tree>>),
8601 RestAssignment(::std::boxed::Box<RestAssignment<'tree>>),
8602}
8603impl<'tree> ::treesitter_types::FromNode<'tree> for LeftAssignmentListChildren<'tree> {
8604 #[allow(clippy::collapsible_else_if)]
8605 fn from_node(
8606 node: ::tree_sitter::Node<'tree>,
8607 src: &'tree [u8],
8608 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8609 match node.kind() {
8610 "destructured_left_assignment" => {
8611 Ok(Self::DestructuredLeftAssignment(::std::boxed::Box::new(
8612 <DestructuredLeftAssignment as ::treesitter_types::FromNode>::from_node(
8613 node, src,
8614 )?,
8615 )))
8616 }
8617 "rest_assignment" => Ok(Self::RestAssignment(::std::boxed::Box::new(
8618 <RestAssignment as ::treesitter_types::FromNode>::from_node(node, src)?,
8619 ))),
8620 _other => {
8621 if let Ok(v) = <Lhs as ::treesitter_types::FromNode>::from_node(node, src) {
8622 Ok(Self::Lhs(::std::boxed::Box::new(v)))
8623 } else {
8624 Err(::treesitter_types::ParseError::unexpected_kind(
8625 _other, node,
8626 ))
8627 }
8628 }
8629 }
8630 }
8631}
8632impl ::treesitter_types::Spanned for LeftAssignmentListChildren<'_> {
8633 fn span(&self) -> ::treesitter_types::Span {
8634 match self {
8635 Self::Lhs(inner) => inner.span(),
8636 Self::DestructuredLeftAssignment(inner) => inner.span(),
8637 Self::RestAssignment(inner) => inner.span(),
8638 }
8639 }
8640}
8641#[derive(Debug, Clone, PartialEq, Eq)]
8642pub enum MethodBody<'tree> {
8643 Arg(::std::boxed::Box<Arg<'tree>>),
8644 BodyStatement(::std::boxed::Box<BodyStatement<'tree>>),
8645 RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
8646}
8647impl<'tree> ::treesitter_types::FromNode<'tree> for MethodBody<'tree> {
8648 #[allow(clippy::collapsible_else_if)]
8649 fn from_node(
8650 node: ::tree_sitter::Node<'tree>,
8651 src: &'tree [u8],
8652 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8653 match node.kind() {
8654 "body_statement" => Ok(Self::BodyStatement(::std::boxed::Box::new(
8655 <BodyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
8656 ))),
8657 "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
8658 <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8659 ))),
8660 _other => {
8661 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
8662 Ok(Self::Arg(::std::boxed::Box::new(v)))
8663 } else {
8664 Err(::treesitter_types::ParseError::unexpected_kind(
8665 _other, node,
8666 ))
8667 }
8668 }
8669 }
8670 }
8671}
8672impl ::treesitter_types::Spanned for MethodBody<'_> {
8673 fn span(&self) -> ::treesitter_types::Span {
8674 match self {
8675 Self::Arg(inner) => inner.span(),
8676 Self::BodyStatement(inner) => inner.span(),
8677 Self::RescueModifier(inner) => inner.span(),
8678 }
8679 }
8680}
8681#[derive(Debug, Clone, PartialEq, Eq)]
8682pub enum MethodParametersChildren<'tree> {
8683 BlockParameter(::std::boxed::Box<BlockParameter<'tree>>),
8684 DestructuredParameter(::std::boxed::Box<DestructuredParameter<'tree>>),
8685 ForwardParameter(::std::boxed::Box<ForwardParameter<'tree>>),
8686 HashSplatNil(::std::boxed::Box<HashSplatNil<'tree>>),
8687 HashSplatParameter(::std::boxed::Box<HashSplatParameter<'tree>>),
8688 Identifier(::std::boxed::Box<Identifier<'tree>>),
8689 KeywordParameter(::std::boxed::Box<KeywordParameter<'tree>>),
8690 OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
8691 SplatParameter(::std::boxed::Box<SplatParameter<'tree>>),
8692}
8693impl<'tree> ::treesitter_types::FromNode<'tree> for MethodParametersChildren<'tree> {
8694 #[allow(clippy::collapsible_else_if)]
8695 fn from_node(
8696 node: ::tree_sitter::Node<'tree>,
8697 src: &'tree [u8],
8698 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8699 match node.kind() {
8700 "block_parameter" => Ok(Self::BlockParameter(::std::boxed::Box::new(
8701 <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8702 ))),
8703 "destructured_parameter" => Ok(Self::DestructuredParameter(::std::boxed::Box::new(
8704 <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8705 ))),
8706 "forward_parameter" => Ok(Self::ForwardParameter(::std::boxed::Box::new(
8707 <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8708 ))),
8709 "hash_splat_nil" => Ok(Self::HashSplatNil(::std::boxed::Box::new(
8710 <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)?,
8711 ))),
8712 "hash_splat_parameter" => Ok(Self::HashSplatParameter(::std::boxed::Box::new(
8713 <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8714 ))),
8715 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8716 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8717 ))),
8718 "keyword_parameter" => Ok(Self::KeywordParameter(::std::boxed::Box::new(
8719 <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8720 ))),
8721 "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
8722 <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8723 ))),
8724 "splat_parameter" => Ok(Self::SplatParameter(::std::boxed::Box::new(
8725 <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
8726 ))),
8727 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8728 }
8729 }
8730}
8731impl ::treesitter_types::Spanned for MethodParametersChildren<'_> {
8732 fn span(&self) -> ::treesitter_types::Span {
8733 match self {
8734 Self::BlockParameter(inner) => inner.span(),
8735 Self::DestructuredParameter(inner) => inner.span(),
8736 Self::ForwardParameter(inner) => inner.span(),
8737 Self::HashSplatNil(inner) => inner.span(),
8738 Self::HashSplatParameter(inner) => inner.span(),
8739 Self::Identifier(inner) => inner.span(),
8740 Self::KeywordParameter(inner) => inner.span(),
8741 Self::OptionalParameter(inner) => inner.span(),
8742 Self::SplatParameter(inner) => inner.span(),
8743 }
8744 }
8745}
8746#[derive(Debug, Clone, PartialEq, Eq)]
8747pub enum ModuleName<'tree> {
8748 Constant(::std::boxed::Box<Constant<'tree>>),
8749 ScopeResolution(::std::boxed::Box<ScopeResolution<'tree>>),
8750}
8751impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleName<'tree> {
8752 #[allow(clippy::collapsible_else_if)]
8753 fn from_node(
8754 node: ::tree_sitter::Node<'tree>,
8755 src: &'tree [u8],
8756 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8757 match node.kind() {
8758 "constant" => Ok(Self::Constant(::std::boxed::Box::new(
8759 <Constant as ::treesitter_types::FromNode>::from_node(node, src)?,
8760 ))),
8761 "scope_resolution" => Ok(Self::ScopeResolution(::std::boxed::Box::new(
8762 <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)?,
8763 ))),
8764 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8765 }
8766 }
8767}
8768impl ::treesitter_types::Spanned for ModuleName<'_> {
8769 fn span(&self) -> ::treesitter_types::Span {
8770 match self {
8771 Self::Constant(inner) => inner.span(),
8772 Self::ScopeResolution(inner) => inner.span(),
8773 }
8774 }
8775}
8776#[derive(Debug, Clone, PartialEq, Eq)]
8777pub enum OperatorAssignmentOperator {
8778 PercentEq(::treesitter_types::Span),
8779 AmpAmpEq(::treesitter_types::Span),
8780 AmpEq(::treesitter_types::Span),
8781 StarStarEq(::treesitter_types::Span),
8782 StarEq(::treesitter_types::Span),
8783 PlusEq(::treesitter_types::Span),
8784 MinusEq(::treesitter_types::Span),
8785 SlashEq(::treesitter_types::Span),
8786 ShlEq(::treesitter_types::Span),
8787 ShrEq(::treesitter_types::Span),
8788 CaretEq(::treesitter_types::Span),
8789 PipeEq(::treesitter_types::Span),
8790 PipePipeEq(::treesitter_types::Span),
8791}
8792impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorAssignmentOperator {
8793 #[allow(clippy::collapsible_else_if)]
8794 fn from_node(
8795 node: ::tree_sitter::Node<'tree>,
8796 _src: &'tree [u8],
8797 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8798 match node.kind() {
8799 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
8800 "&&=" => Ok(Self::AmpAmpEq(::treesitter_types::Span::from(node))),
8801 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
8802 "**=" => Ok(Self::StarStarEq(::treesitter_types::Span::from(node))),
8803 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
8804 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
8805 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
8806 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
8807 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
8808 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
8809 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
8810 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
8811 "||=" => Ok(Self::PipePipeEq(::treesitter_types::Span::from(node))),
8812 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8813 }
8814 }
8815}
8816impl ::treesitter_types::Spanned for OperatorAssignmentOperator {
8817 fn span(&self) -> ::treesitter_types::Span {
8818 match self {
8819 Self::PercentEq(span) => *span,
8820 Self::AmpAmpEq(span) => *span,
8821 Self::AmpEq(span) => *span,
8822 Self::StarStarEq(span) => *span,
8823 Self::StarEq(span) => *span,
8824 Self::PlusEq(span) => *span,
8825 Self::MinusEq(span) => *span,
8826 Self::SlashEq(span) => *span,
8827 Self::ShlEq(span) => *span,
8828 Self::ShrEq(span) => *span,
8829 Self::CaretEq(span) => *span,
8830 Self::PipeEq(span) => *span,
8831 Self::PipePipeEq(span) => *span,
8832 }
8833 }
8834}
8835#[derive(Debug, Clone, PartialEq, Eq)]
8836pub enum OperatorAssignmentRight<'tree> {
8837 Expression(::std::boxed::Box<Expression<'tree>>),
8838 RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
8839}
8840impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorAssignmentRight<'tree> {
8841 #[allow(clippy::collapsible_else_if)]
8842 fn from_node(
8843 node: ::tree_sitter::Node<'tree>,
8844 src: &'tree [u8],
8845 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8846 match node.kind() {
8847 "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
8848 <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8849 ))),
8850 _other => {
8851 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8852 Ok(Self::Expression(::std::boxed::Box::new(v)))
8853 } else {
8854 Err(::treesitter_types::ParseError::unexpected_kind(
8855 _other, node,
8856 ))
8857 }
8858 }
8859 }
8860 }
8861}
8862impl ::treesitter_types::Spanned for OperatorAssignmentRight<'_> {
8863 fn span(&self) -> ::treesitter_types::Span {
8864 match self {
8865 Self::Expression(inner) => inner.span(),
8866 Self::RescueModifier(inner) => inner.span(),
8867 }
8868 }
8869}
8870#[derive(Debug, Clone, PartialEq, Eq)]
8871pub enum PairKey<'tree> {
8872 Arg(::std::boxed::Box<Arg<'tree>>),
8873 HashKeySymbol(::std::boxed::Box<HashKeySymbol<'tree>>),
8874 String(::std::boxed::Box<String<'tree>>),
8875}
8876impl<'tree> ::treesitter_types::FromNode<'tree> for PairKey<'tree> {
8877 #[allow(clippy::collapsible_else_if)]
8878 fn from_node(
8879 node: ::tree_sitter::Node<'tree>,
8880 src: &'tree [u8],
8881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8882 match node.kind() {
8883 "hash_key_symbol" => Ok(Self::HashKeySymbol(::std::boxed::Box::new(
8884 <HashKeySymbol as ::treesitter_types::FromNode>::from_node(node, src)?,
8885 ))),
8886 "string" => Ok(Self::String(::std::boxed::Box::new(
8887 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
8888 ))),
8889 _other => {
8890 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
8891 Ok(Self::Arg(::std::boxed::Box::new(v)))
8892 } else {
8893 Err(::treesitter_types::ParseError::unexpected_kind(
8894 _other, node,
8895 ))
8896 }
8897 }
8898 }
8899 }
8900}
8901impl ::treesitter_types::Spanned for PairKey<'_> {
8902 fn span(&self) -> ::treesitter_types::Span {
8903 match self {
8904 Self::Arg(inner) => inner.span(),
8905 Self::HashKeySymbol(inner) => inner.span(),
8906 Self::String(inner) => inner.span(),
8907 }
8908 }
8909}
8910#[derive(Debug, Clone, PartialEq, Eq)]
8911pub enum ParenthesizedStatementsChildren<'tree> {
8912 Statement(::std::boxed::Box<Statement<'tree>>),
8913 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8914}
8915impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedStatementsChildren<'tree> {
8916 #[allow(clippy::collapsible_else_if)]
8917 fn from_node(
8918 node: ::tree_sitter::Node<'tree>,
8919 src: &'tree [u8],
8920 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8921 match node.kind() {
8922 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8923 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
8924 ))),
8925 _other => {
8926 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
8927 Ok(Self::Statement(::std::boxed::Box::new(v)))
8928 } else {
8929 Err(::treesitter_types::ParseError::unexpected_kind(
8930 _other, node,
8931 ))
8932 }
8933 }
8934 }
8935 }
8936}
8937impl ::treesitter_types::Spanned for ParenthesizedStatementsChildren<'_> {
8938 fn span(&self) -> ::treesitter_types::Span {
8939 match self {
8940 Self::Statement(inner) => inner.span(),
8941 Self::EmptyStatement(inner) => inner.span(),
8942 }
8943 }
8944}
8945#[derive(Debug, Clone, PartialEq, Eq)]
8946pub enum PatternChildren<'tree> {
8947 Arg(::std::boxed::Box<Arg<'tree>>),
8948 SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
8949}
8950impl<'tree> ::treesitter_types::FromNode<'tree> for PatternChildren<'tree> {
8951 #[allow(clippy::collapsible_else_if)]
8952 fn from_node(
8953 node: ::tree_sitter::Node<'tree>,
8954 src: &'tree [u8],
8955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8956 match node.kind() {
8957 "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
8958 <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
8959 ))),
8960 _other => {
8961 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
8962 Ok(Self::Arg(::std::boxed::Box::new(v)))
8963 } else {
8964 Err(::treesitter_types::ParseError::unexpected_kind(
8965 _other, node,
8966 ))
8967 }
8968 }
8969 }
8970 }
8971}
8972impl ::treesitter_types::Spanned for PatternChildren<'_> {
8973 fn span(&self) -> ::treesitter_types::Span {
8974 match self {
8975 Self::Arg(inner) => inner.span(),
8976 Self::SplatArgument(inner) => inner.span(),
8977 }
8978 }
8979}
8980#[derive(Debug, Clone, PartialEq, Eq)]
8981pub enum ProgramChildren<'tree> {
8982 Statement(::std::boxed::Box<Statement<'tree>>),
8983 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
8984 Uninterpreted(::std::boxed::Box<Uninterpreted<'tree>>),
8985}
8986impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
8987 #[allow(clippy::collapsible_else_if)]
8988 fn from_node(
8989 node: ::tree_sitter::Node<'tree>,
8990 src: &'tree [u8],
8991 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8992 match node.kind() {
8993 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
8994 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
8995 ))),
8996 "uninterpreted" => Ok(Self::Uninterpreted(::std::boxed::Box::new(
8997 <Uninterpreted as ::treesitter_types::FromNode>::from_node(node, src)?,
8998 ))),
8999 _other => {
9000 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
9001 Ok(Self::Statement(::std::boxed::Box::new(v)))
9002 } else {
9003 Err(::treesitter_types::ParseError::unexpected_kind(
9004 _other, node,
9005 ))
9006 }
9007 }
9008 }
9009 }
9010}
9011impl ::treesitter_types::Spanned for ProgramChildren<'_> {
9012 fn span(&self) -> ::treesitter_types::Span {
9013 match self {
9014 Self::Statement(inner) => inner.span(),
9015 Self::EmptyStatement(inner) => inner.span(),
9016 Self::Uninterpreted(inner) => inner.span(),
9017 }
9018 }
9019}
9020#[derive(Debug, Clone, PartialEq, Eq)]
9021pub enum RangeBegin<'tree> {
9022 Arg(::std::boxed::Box<Arg<'tree>>),
9023 PatternPrimitive(::std::boxed::Box<PatternPrimitive<'tree>>),
9024}
9025impl<'tree> ::treesitter_types::FromNode<'tree> for RangeBegin<'tree> {
9026 #[allow(clippy::collapsible_else_if)]
9027 fn from_node(
9028 node: ::tree_sitter::Node<'tree>,
9029 src: &'tree [u8],
9030 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9031 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
9032 Ok(Self::Arg(::std::boxed::Box::new(v)))
9033 } else {
9034 if let Ok(v) = <PatternPrimitive as ::treesitter_types::FromNode>::from_node(node, src)
9035 {
9036 Ok(Self::PatternPrimitive(::std::boxed::Box::new(v)))
9037 } else {
9038 Err(::treesitter_types::ParseError::unexpected_kind(
9039 node.kind(),
9040 node,
9041 ))
9042 }
9043 }
9044 }
9045}
9046impl ::treesitter_types::Spanned for RangeBegin<'_> {
9047 fn span(&self) -> ::treesitter_types::Span {
9048 match self {
9049 Self::Arg(inner) => inner.span(),
9050 Self::PatternPrimitive(inner) => inner.span(),
9051 }
9052 }
9053}
9054#[derive(Debug, Clone, PartialEq, Eq)]
9055pub enum RangeEnd<'tree> {
9056 Arg(::std::boxed::Box<Arg<'tree>>),
9057 PatternPrimitive(::std::boxed::Box<PatternPrimitive<'tree>>),
9058}
9059impl<'tree> ::treesitter_types::FromNode<'tree> for RangeEnd<'tree> {
9060 #[allow(clippy::collapsible_else_if)]
9061 fn from_node(
9062 node: ::tree_sitter::Node<'tree>,
9063 src: &'tree [u8],
9064 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9065 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
9066 Ok(Self::Arg(::std::boxed::Box::new(v)))
9067 } else {
9068 if let Ok(v) = <PatternPrimitive as ::treesitter_types::FromNode>::from_node(node, src)
9069 {
9070 Ok(Self::PatternPrimitive(::std::boxed::Box::new(v)))
9071 } else {
9072 Err(::treesitter_types::ParseError::unexpected_kind(
9073 node.kind(),
9074 node,
9075 ))
9076 }
9077 }
9078 }
9079}
9080impl ::treesitter_types::Spanned for RangeEnd<'_> {
9081 fn span(&self) -> ::treesitter_types::Span {
9082 match self {
9083 Self::Arg(inner) => inner.span(),
9084 Self::PatternPrimitive(inner) => inner.span(),
9085 }
9086 }
9087}
9088#[derive(Debug, Clone, PartialEq, Eq)]
9089pub enum RangeOperator {
9090 DotDot(::treesitter_types::Span),
9091 Ellipsis(::treesitter_types::Span),
9092}
9093impl<'tree> ::treesitter_types::FromNode<'tree> for RangeOperator {
9094 #[allow(clippy::collapsible_else_if)]
9095 fn from_node(
9096 node: ::tree_sitter::Node<'tree>,
9097 _src: &'tree [u8],
9098 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9099 match node.kind() {
9100 ".." => Ok(Self::DotDot(::treesitter_types::Span::from(node))),
9101 "..." => Ok(Self::Ellipsis(::treesitter_types::Span::from(node))),
9102 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9103 }
9104 }
9105}
9106impl ::treesitter_types::Spanned for RangeOperator {
9107 fn span(&self) -> ::treesitter_types::Span {
9108 match self {
9109 Self::DotDot(span) => *span,
9110 Self::Ellipsis(span) => *span,
9111 }
9112 }
9113}
9114#[derive(Debug, Clone, PartialEq, Eq)]
9115pub enum RationalChildren<'tree> {
9116 Float(::std::boxed::Box<Float<'tree>>),
9117 Integer(::std::boxed::Box<Integer<'tree>>),
9118}
9119impl<'tree> ::treesitter_types::FromNode<'tree> for RationalChildren<'tree> {
9120 #[allow(clippy::collapsible_else_if)]
9121 fn from_node(
9122 node: ::tree_sitter::Node<'tree>,
9123 src: &'tree [u8],
9124 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9125 match node.kind() {
9126 "float" => Ok(Self::Float(::std::boxed::Box::new(
9127 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
9128 ))),
9129 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
9130 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
9131 ))),
9132 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9133 }
9134 }
9135}
9136impl ::treesitter_types::Spanned for RationalChildren<'_> {
9137 fn span(&self) -> ::treesitter_types::Span {
9138 match self {
9139 Self::Float(inner) => inner.span(),
9140 Self::Integer(inner) => inner.span(),
9141 }
9142 }
9143}
9144#[derive(Debug, Clone, PartialEq, Eq)]
9145pub enum RegexChildren<'tree> {
9146 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
9147 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
9148 StringContent(::std::boxed::Box<StringContent<'tree>>),
9149}
9150impl<'tree> ::treesitter_types::FromNode<'tree> for RegexChildren<'tree> {
9151 #[allow(clippy::collapsible_else_if)]
9152 fn from_node(
9153 node: ::tree_sitter::Node<'tree>,
9154 src: &'tree [u8],
9155 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9156 match node.kind() {
9157 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
9158 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
9159 ))),
9160 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
9161 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
9162 ))),
9163 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
9164 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
9165 ))),
9166 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9167 }
9168 }
9169}
9170impl ::treesitter_types::Spanned for RegexChildren<'_> {
9171 fn span(&self) -> ::treesitter_types::Span {
9172 match self {
9173 Self::EscapeSequence(inner) => inner.span(),
9174 Self::Interpolation(inner) => inner.span(),
9175 Self::StringContent(inner) => inner.span(),
9176 }
9177 }
9178}
9179#[derive(Debug, Clone, PartialEq, Eq)]
9180pub enum RescueModifierBody<'tree> {
9181 Arg(::std::boxed::Box<Arg<'tree>>),
9182 Statement(::std::boxed::Box<Statement<'tree>>),
9183}
9184impl<'tree> ::treesitter_types::FromNode<'tree> for RescueModifierBody<'tree> {
9185 #[allow(clippy::collapsible_else_if)]
9186 fn from_node(
9187 node: ::tree_sitter::Node<'tree>,
9188 src: &'tree [u8],
9189 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9190 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
9191 Ok(Self::Arg(::std::boxed::Box::new(v)))
9192 } else {
9193 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
9194 Ok(Self::Statement(::std::boxed::Box::new(v)))
9195 } else {
9196 Err(::treesitter_types::ParseError::unexpected_kind(
9197 node.kind(),
9198 node,
9199 ))
9200 }
9201 }
9202 }
9203}
9204impl ::treesitter_types::Spanned for RescueModifierBody<'_> {
9205 fn span(&self) -> ::treesitter_types::Span {
9206 match self {
9207 Self::Arg(inner) => inner.span(),
9208 Self::Statement(inner) => inner.span(),
9209 }
9210 }
9211}
9212#[derive(Debug, Clone, PartialEq, Eq)]
9213pub enum RightAssignmentListChildren<'tree> {
9214 Arg(::std::boxed::Box<Arg<'tree>>),
9215 SplatArgument(::std::boxed::Box<SplatArgument<'tree>>),
9216}
9217impl<'tree> ::treesitter_types::FromNode<'tree> for RightAssignmentListChildren<'tree> {
9218 #[allow(clippy::collapsible_else_if)]
9219 fn from_node(
9220 node: ::tree_sitter::Node<'tree>,
9221 src: &'tree [u8],
9222 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9223 match node.kind() {
9224 "splat_argument" => Ok(Self::SplatArgument(::std::boxed::Box::new(
9225 <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)?,
9226 ))),
9227 _other => {
9228 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
9229 Ok(Self::Arg(::std::boxed::Box::new(v)))
9230 } else {
9231 Err(::treesitter_types::ParseError::unexpected_kind(
9232 _other, node,
9233 ))
9234 }
9235 }
9236 }
9237 }
9238}
9239impl ::treesitter_types::Spanned for RightAssignmentListChildren<'_> {
9240 fn span(&self) -> ::treesitter_types::Span {
9241 match self {
9242 Self::Arg(inner) => inner.span(),
9243 Self::SplatArgument(inner) => inner.span(),
9244 }
9245 }
9246}
9247#[derive(Debug, Clone, PartialEq, Eq)]
9248pub enum ScopeResolutionScope<'tree> {
9249 PatternConstant(::std::boxed::Box<PatternConstant<'tree>>),
9250 Primary(::std::boxed::Box<Primary<'tree>>),
9251}
9252impl<'tree> ::treesitter_types::FromNode<'tree> for ScopeResolutionScope<'tree> {
9253 #[allow(clippy::collapsible_else_if)]
9254 fn from_node(
9255 node: ::tree_sitter::Node<'tree>,
9256 src: &'tree [u8],
9257 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9258 if let Ok(v) = <PatternConstant as ::treesitter_types::FromNode>::from_node(node, src) {
9259 Ok(Self::PatternConstant(::std::boxed::Box::new(v)))
9260 } else {
9261 if let Ok(v) = <Primary as ::treesitter_types::FromNode>::from_node(node, src) {
9262 Ok(Self::Primary(::std::boxed::Box::new(v)))
9263 } else {
9264 Err(::treesitter_types::ParseError::unexpected_kind(
9265 node.kind(),
9266 node,
9267 ))
9268 }
9269 }
9270 }
9271}
9272impl ::treesitter_types::Spanned for ScopeResolutionScope<'_> {
9273 fn span(&self) -> ::treesitter_types::Span {
9274 match self {
9275 Self::PatternConstant(inner) => inner.span(),
9276 Self::Primary(inner) => inner.span(),
9277 }
9278 }
9279}
9280#[derive(Debug, Clone, PartialEq, Eq)]
9281pub enum SingletonMethodBody<'tree> {
9282 Arg(::std::boxed::Box<Arg<'tree>>),
9283 BodyStatement(::std::boxed::Box<BodyStatement<'tree>>),
9284 RescueModifier(::std::boxed::Box<RescueModifier<'tree>>),
9285}
9286impl<'tree> ::treesitter_types::FromNode<'tree> for SingletonMethodBody<'tree> {
9287 #[allow(clippy::collapsible_else_if)]
9288 fn from_node(
9289 node: ::tree_sitter::Node<'tree>,
9290 src: &'tree [u8],
9291 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9292 match node.kind() {
9293 "body_statement" => Ok(Self::BodyStatement(::std::boxed::Box::new(
9294 <BodyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
9295 ))),
9296 "rescue_modifier" => Ok(Self::RescueModifier(::std::boxed::Box::new(
9297 <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9298 ))),
9299 _other => {
9300 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
9301 Ok(Self::Arg(::std::boxed::Box::new(v)))
9302 } else {
9303 Err(::treesitter_types::ParseError::unexpected_kind(
9304 _other, node,
9305 ))
9306 }
9307 }
9308 }
9309 }
9310}
9311impl ::treesitter_types::Spanned for SingletonMethodBody<'_> {
9312 fn span(&self) -> ::treesitter_types::Span {
9313 match self {
9314 Self::Arg(inner) => inner.span(),
9315 Self::BodyStatement(inner) => inner.span(),
9316 Self::RescueModifier(inner) => inner.span(),
9317 }
9318 }
9319}
9320#[derive(Debug, Clone, PartialEq, Eq)]
9321pub enum SingletonMethodObject<'tree> {
9322 Arg(::std::boxed::Box<Arg<'tree>>),
9323 Variable(::std::boxed::Box<Variable<'tree>>),
9324}
9325impl<'tree> ::treesitter_types::FromNode<'tree> for SingletonMethodObject<'tree> {
9326 #[allow(clippy::collapsible_else_if)]
9327 fn from_node(
9328 node: ::tree_sitter::Node<'tree>,
9329 src: &'tree [u8],
9330 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9331 if let Ok(v) = <Arg as ::treesitter_types::FromNode>::from_node(node, src) {
9332 Ok(Self::Arg(::std::boxed::Box::new(v)))
9333 } else {
9334 if let Ok(v) = <Variable as ::treesitter_types::FromNode>::from_node(node, src) {
9335 Ok(Self::Variable(::std::boxed::Box::new(v)))
9336 } else {
9337 Err(::treesitter_types::ParseError::unexpected_kind(
9338 node.kind(),
9339 node,
9340 ))
9341 }
9342 }
9343 }
9344}
9345impl ::treesitter_types::Spanned for SingletonMethodObject<'_> {
9346 fn span(&self) -> ::treesitter_types::Span {
9347 match self {
9348 Self::Arg(inner) => inner.span(),
9349 Self::Variable(inner) => inner.span(),
9350 }
9351 }
9352}
9353#[derive(Debug, Clone, PartialEq, Eq)]
9354pub enum StringChildren<'tree> {
9355 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
9356 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
9357 StringContent(::std::boxed::Box<StringContent<'tree>>),
9358}
9359impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
9360 #[allow(clippy::collapsible_else_if)]
9361 fn from_node(
9362 node: ::tree_sitter::Node<'tree>,
9363 src: &'tree [u8],
9364 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9365 match node.kind() {
9366 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
9367 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
9368 ))),
9369 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
9370 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
9371 ))),
9372 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
9373 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
9374 ))),
9375 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9376 }
9377 }
9378}
9379impl ::treesitter_types::Spanned for StringChildren<'_> {
9380 fn span(&self) -> ::treesitter_types::Span {
9381 match self {
9382 Self::EscapeSequence(inner) => inner.span(),
9383 Self::Interpolation(inner) => inner.span(),
9384 Self::StringContent(inner) => inner.span(),
9385 }
9386 }
9387}
9388#[derive(Debug, Clone, PartialEq, Eq)]
9389pub enum SubshellChildren<'tree> {
9390 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
9391 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
9392 StringContent(::std::boxed::Box<StringContent<'tree>>),
9393}
9394impl<'tree> ::treesitter_types::FromNode<'tree> for SubshellChildren<'tree> {
9395 #[allow(clippy::collapsible_else_if)]
9396 fn from_node(
9397 node: ::tree_sitter::Node<'tree>,
9398 src: &'tree [u8],
9399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9400 match node.kind() {
9401 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
9402 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
9403 ))),
9404 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
9405 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
9406 ))),
9407 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
9408 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
9409 ))),
9410 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9411 }
9412 }
9413}
9414impl ::treesitter_types::Spanned for SubshellChildren<'_> {
9415 fn span(&self) -> ::treesitter_types::Span {
9416 match self {
9417 Self::EscapeSequence(inner) => inner.span(),
9418 Self::Interpolation(inner) => inner.span(),
9419 Self::StringContent(inner) => inner.span(),
9420 }
9421 }
9422}
9423#[derive(Debug, Clone, PartialEq, Eq)]
9424pub enum ThenChildren<'tree> {
9425 Statement(::std::boxed::Box<Statement<'tree>>),
9426 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
9427}
9428impl<'tree> ::treesitter_types::FromNode<'tree> for ThenChildren<'tree> {
9429 #[allow(clippy::collapsible_else_if)]
9430 fn from_node(
9431 node: ::tree_sitter::Node<'tree>,
9432 src: &'tree [u8],
9433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9434 match node.kind() {
9435 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
9436 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
9437 ))),
9438 _other => {
9439 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
9440 Ok(Self::Statement(::std::boxed::Box::new(v)))
9441 } else {
9442 Err(::treesitter_types::ParseError::unexpected_kind(
9443 _other, node,
9444 ))
9445 }
9446 }
9447 }
9448 }
9449}
9450impl ::treesitter_types::Spanned for ThenChildren<'_> {
9451 fn span(&self) -> ::treesitter_types::Span {
9452 match self {
9453 Self::Statement(inner) => inner.span(),
9454 Self::EmptyStatement(inner) => inner.span(),
9455 }
9456 }
9457}
9458#[derive(Debug, Clone, PartialEq, Eq)]
9459pub enum UnaryOperand<'tree> {
9460 Expression(::std::boxed::Box<Expression<'tree>>),
9461 SimpleNumeric(::std::boxed::Box<SimpleNumeric<'tree>>),
9462 ParenthesizedStatements(::std::boxed::Box<ParenthesizedStatements<'tree>>),
9463}
9464impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOperand<'tree> {
9465 #[allow(clippy::collapsible_else_if)]
9466 fn from_node(
9467 node: ::tree_sitter::Node<'tree>,
9468 src: &'tree [u8],
9469 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9470 match node.kind() {
9471 "parenthesized_statements" => {
9472 Ok(Self::ParenthesizedStatements(::std::boxed::Box::new(
9473 <ParenthesizedStatements as ::treesitter_types::FromNode>::from_node(
9474 node, src,
9475 )?,
9476 )))
9477 }
9478 _other => {
9479 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9480 Ok(Self::Expression(::std::boxed::Box::new(v)))
9481 } else {
9482 if let Ok(v) =
9483 <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src)
9484 {
9485 Ok(Self::SimpleNumeric(::std::boxed::Box::new(v)))
9486 } else {
9487 Err(::treesitter_types::ParseError::unexpected_kind(
9488 _other, node,
9489 ))
9490 }
9491 }
9492 }
9493 }
9494 }
9495}
9496impl ::treesitter_types::Spanned for UnaryOperand<'_> {
9497 fn span(&self) -> ::treesitter_types::Span {
9498 match self {
9499 Self::Expression(inner) => inner.span(),
9500 Self::SimpleNumeric(inner) => inner.span(),
9501 Self::ParenthesizedStatements(inner) => inner.span(),
9502 }
9503 }
9504}
9505#[derive(Debug, Clone, PartialEq, Eq)]
9506pub enum UnaryOperator {
9507 Bang(::treesitter_types::Span),
9508 Plus(::treesitter_types::Span),
9509 Minus(::treesitter_types::Span),
9510 DEFINEDQuestion(::treesitter_types::Span),
9511 Not(::treesitter_types::Span),
9512 Tilde(::treesitter_types::Span),
9513}
9514impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOperator {
9515 #[allow(clippy::collapsible_else_if)]
9516 fn from_node(
9517 node: ::tree_sitter::Node<'tree>,
9518 _src: &'tree [u8],
9519 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9520 match node.kind() {
9521 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
9522 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
9523 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
9524 "defined?" => Ok(Self::DEFINEDQuestion(::treesitter_types::Span::from(node))),
9525 "not" => Ok(Self::Not(::treesitter_types::Span::from(node))),
9526 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
9527 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9528 }
9529 }
9530}
9531impl ::treesitter_types::Spanned for UnaryOperator {
9532 fn span(&self) -> ::treesitter_types::Span {
9533 match self {
9534 Self::Bang(span) => *span,
9535 Self::Plus(span) => *span,
9536 Self::Minus(span) => *span,
9537 Self::DEFINEDQuestion(span) => *span,
9538 Self::Not(span) => *span,
9539 Self::Tilde(span) => *span,
9540 }
9541 }
9542}
9543#[derive(Debug, Clone, PartialEq, Eq)]
9544pub enum UnlessAlternative<'tree> {
9545 Else(::std::boxed::Box<Else<'tree>>),
9546 Elsif(::std::boxed::Box<Elsif<'tree>>),
9547}
9548impl<'tree> ::treesitter_types::FromNode<'tree> for UnlessAlternative<'tree> {
9549 #[allow(clippy::collapsible_else_if)]
9550 fn from_node(
9551 node: ::tree_sitter::Node<'tree>,
9552 src: &'tree [u8],
9553 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9554 match node.kind() {
9555 "else" => Ok(Self::Else(::std::boxed::Box::new(
9556 <Else as ::treesitter_types::FromNode>::from_node(node, src)?,
9557 ))),
9558 "elsif" => Ok(Self::Elsif(::std::boxed::Box::new(
9559 <Elsif as ::treesitter_types::FromNode>::from_node(node, src)?,
9560 ))),
9561 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9562 }
9563 }
9564}
9565impl ::treesitter_types::Spanned for UnlessAlternative<'_> {
9566 fn span(&self) -> ::treesitter_types::Span {
9567 match self {
9568 Self::Else(inner) => inner.span(),
9569 Self::Elsif(inner) => inner.span(),
9570 }
9571 }
9572}
9573#[derive(Debug, Clone, PartialEq, Eq)]
9574pub enum VariableReferencePatternName<'tree> {
9575 NonlocalVariable(::std::boxed::Box<NonlocalVariable<'tree>>),
9576 Identifier(::std::boxed::Box<Identifier<'tree>>),
9577}
9578impl<'tree> ::treesitter_types::FromNode<'tree> for VariableReferencePatternName<'tree> {
9579 #[allow(clippy::collapsible_else_if)]
9580 fn from_node(
9581 node: ::tree_sitter::Node<'tree>,
9582 src: &'tree [u8],
9583 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9584 match node.kind() {
9585 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9586 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9587 ))),
9588 _other => {
9589 if let Ok(v) =
9590 <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
9591 {
9592 Ok(Self::NonlocalVariable(::std::boxed::Box::new(v)))
9593 } else {
9594 Err(::treesitter_types::ParseError::unexpected_kind(
9595 _other, node,
9596 ))
9597 }
9598 }
9599 }
9600 }
9601}
9602impl ::treesitter_types::Spanned for VariableReferencePatternName<'_> {
9603 fn span(&self) -> ::treesitter_types::Span {
9604 match self {
9605 Self::NonlocalVariable(inner) => inner.span(),
9606 Self::Identifier(inner) => inner.span(),
9607 }
9608 }
9609}
9610#[derive(Debug, Clone, PartialEq, Eq)]
9611pub enum AnyNode<'tree> {
9612 Arg(Arg<'tree>),
9613 CallOperator(CallOperator),
9614 Expression(Expression<'tree>),
9615 Lhs(Lhs<'tree>),
9616 MethodName(MethodName<'tree>),
9617 NonlocalVariable(NonlocalVariable<'tree>),
9618 PatternConstant(PatternConstant<'tree>),
9619 PatternExpr(PatternExpr<'tree>),
9620 PatternExprBasic(PatternExprBasic<'tree>),
9621 PatternPrimitive(PatternPrimitive<'tree>),
9622 PatternTopExprBody(PatternTopExprBody<'tree>),
9623 Primary(Primary<'tree>),
9624 SimpleNumeric(SimpleNumeric<'tree>),
9625 Statement(Statement<'tree>),
9626 Variable(Variable<'tree>),
9627 Alias(Alias<'tree>),
9628 AlternativePattern(AlternativePattern<'tree>),
9629 ArgumentList(ArgumentList<'tree>),
9630 Array(Array<'tree>),
9631 ArrayPattern(ArrayPattern<'tree>),
9632 AsPattern(AsPattern<'tree>),
9633 Assignment(Assignment<'tree>),
9634 BareString(BareString<'tree>),
9635 BareSymbol(BareSymbol<'tree>),
9636 Begin(Begin<'tree>),
9637 BeginBlock(BeginBlock<'tree>),
9638 Binary(Binary<'tree>),
9639 Block(Block<'tree>),
9640 BlockArgument(BlockArgument<'tree>),
9641 BlockBody(BlockBody<'tree>),
9642 BlockParameter(BlockParameter<'tree>),
9643 BlockParameters(BlockParameters<'tree>),
9644 BodyStatement(BodyStatement<'tree>),
9645 Break(Break<'tree>),
9646 Call(Call<'tree>),
9647 Case(Case<'tree>),
9648 CaseMatch(CaseMatch<'tree>),
9649 ChainedString(ChainedString<'tree>),
9650 Class(Class<'tree>),
9651 Complex(Complex<'tree>),
9652 Conditional(Conditional<'tree>),
9653 Constant(Constant<'tree>),
9654 DelimitedSymbol(DelimitedSymbol<'tree>),
9655 DestructuredLeftAssignment(DestructuredLeftAssignment<'tree>),
9656 DestructuredParameter(DestructuredParameter<'tree>),
9657 Do(Do<'tree>),
9658 DoBlock(DoBlock<'tree>),
9659 ElementReference(ElementReference<'tree>),
9660 Else(Else<'tree>),
9661 Elsif(Elsif<'tree>),
9662 EmptyStatement(EmptyStatement<'tree>),
9663 EndBlock(EndBlock<'tree>),
9664 Ensure(Ensure<'tree>),
9665 ExceptionVariable(ExceptionVariable<'tree>),
9666 Exceptions(Exceptions<'tree>),
9667 ExpressionReferencePattern(ExpressionReferencePattern<'tree>),
9668 FindPattern(FindPattern<'tree>),
9669 For(For<'tree>),
9670 ForwardArgument(ForwardArgument<'tree>),
9671 ForwardParameter(ForwardParameter<'tree>),
9672 Hash(Hash<'tree>),
9673 HashKeySymbol(HashKeySymbol<'tree>),
9674 HashPattern(HashPattern<'tree>),
9675 HashSplatArgument(HashSplatArgument<'tree>),
9676 HashSplatNil(HashSplatNil<'tree>),
9677 HashSplatParameter(HashSplatParameter<'tree>),
9678 HeredocBody(HeredocBody<'tree>),
9679 Identifier(Identifier<'tree>),
9680 If(If<'tree>),
9681 IfGuard(IfGuard<'tree>),
9682 IfModifier(IfModifier<'tree>),
9683 In(In<'tree>),
9684 InClause(InClause<'tree>),
9685 Interpolation(Interpolation<'tree>),
9686 KeywordParameter(KeywordParameter<'tree>),
9687 KeywordPattern(KeywordPattern<'tree>),
9688 Lambda(Lambda<'tree>),
9689 LambdaParameters(LambdaParameters<'tree>),
9690 LeftAssignmentList(LeftAssignmentList<'tree>),
9691 MatchPattern(MatchPattern<'tree>),
9692 Method(Method<'tree>),
9693 MethodParameters(MethodParameters<'tree>),
9694 Module(Module<'tree>),
9695 Next(Next<'tree>),
9696 Nil(Nil<'tree>),
9697 Operator(Operator<'tree>),
9698 OperatorAssignment(OperatorAssignment<'tree>),
9699 OptionalParameter(OptionalParameter<'tree>),
9700 Pair(Pair<'tree>),
9701 ParenthesizedPattern(ParenthesizedPattern<'tree>),
9702 ParenthesizedStatements(ParenthesizedStatements<'tree>),
9703 Pattern(Pattern<'tree>),
9704 Program(Program<'tree>),
9705 Range(Range<'tree>),
9706 Rational(Rational<'tree>),
9707 Redo(Redo<'tree>),
9708 Regex(Regex<'tree>),
9709 Rescue(Rescue<'tree>),
9710 RescueModifier(RescueModifier<'tree>),
9711 RestAssignment(RestAssignment<'tree>),
9712 Retry(Retry<'tree>),
9713 Return(Return<'tree>),
9714 RightAssignmentList(RightAssignmentList<'tree>),
9715 ScopeResolution(ScopeResolution<'tree>),
9716 Setter(Setter<'tree>),
9717 SingletonClass(SingletonClass<'tree>),
9718 SingletonMethod(SingletonMethod<'tree>),
9719 SplatArgument(SplatArgument<'tree>),
9720 SplatParameter(SplatParameter<'tree>),
9721 String(String<'tree>),
9722 StringArray(StringArray<'tree>),
9723 Subshell(Subshell<'tree>),
9724 Superclass(Superclass<'tree>),
9725 SymbolArray(SymbolArray<'tree>),
9726 TestPattern(TestPattern<'tree>),
9727 Then(Then<'tree>),
9728 Unary(Unary<'tree>),
9729 Undef(Undef<'tree>),
9730 Unless(Unless<'tree>),
9731 UnlessGuard(UnlessGuard<'tree>),
9732 UnlessModifier(UnlessModifier<'tree>),
9733 Until(Until<'tree>),
9734 UntilModifier(UntilModifier<'tree>),
9735 VariableReferencePattern(VariableReferencePattern<'tree>),
9736 When(When<'tree>),
9737 While(While<'tree>),
9738 WhileModifier(WhileModifier<'tree>),
9739 Yield(Yield<'tree>),
9740 Character(Character<'tree>),
9741 ClassVariable(ClassVariable<'tree>),
9742 Comment(Comment<'tree>),
9743 Encoding(Encoding<'tree>),
9744 EscapeSequence(EscapeSequence<'tree>),
9745 False(False<'tree>),
9746 File(File<'tree>),
9747 Float(Float<'tree>),
9748 GlobalVariable(GlobalVariable<'tree>),
9749 HeredocBeginning(HeredocBeginning<'tree>),
9750 HeredocContent(HeredocContent<'tree>),
9751 HeredocEnd(HeredocEnd<'tree>),
9752 InstanceVariable(InstanceVariable<'tree>),
9753 Integer(Integer<'tree>),
9754 Line(Line<'tree>),
9755 SelfType(SelfType<'tree>),
9756 SimpleSymbol(SimpleSymbol<'tree>),
9757 StringContent(StringContent<'tree>),
9758 Super(Super<'tree>),
9759 True(True<'tree>),
9760 Uninterpreted(Uninterpreted<'tree>),
9761 Unknown(::tree_sitter::Node<'tree>),
9762}
9763impl<'tree> AnyNode<'tree> {
9764 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
9765 match node.kind() {
9766 "_arg" => <Arg as ::treesitter_types::FromNode>::from_node(node, src)
9767 .map(Self::Arg)
9768 .unwrap_or(Self::Unknown(node)),
9769 "_call_operator" => {
9770 <CallOperator as ::treesitter_types::FromNode>::from_node(node, src)
9771 .map(Self::CallOperator)
9772 .unwrap_or(Self::Unknown(node))
9773 }
9774 "_expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9775 .map(Self::Expression)
9776 .unwrap_or(Self::Unknown(node)),
9777 "_lhs" => <Lhs as ::treesitter_types::FromNode>::from_node(node, src)
9778 .map(Self::Lhs)
9779 .unwrap_or(Self::Unknown(node)),
9780 "_method_name" => <MethodName as ::treesitter_types::FromNode>::from_node(node, src)
9781 .map(Self::MethodName)
9782 .unwrap_or(Self::Unknown(node)),
9783 "_nonlocal_variable" => {
9784 <NonlocalVariable as ::treesitter_types::FromNode>::from_node(node, src)
9785 .map(Self::NonlocalVariable)
9786 .unwrap_or(Self::Unknown(node))
9787 }
9788 "_pattern_constant" => {
9789 <PatternConstant as ::treesitter_types::FromNode>::from_node(node, src)
9790 .map(Self::PatternConstant)
9791 .unwrap_or(Self::Unknown(node))
9792 }
9793 "_pattern_expr" => <PatternExpr as ::treesitter_types::FromNode>::from_node(node, src)
9794 .map(Self::PatternExpr)
9795 .unwrap_or(Self::Unknown(node)),
9796 "_pattern_expr_basic" => {
9797 <PatternExprBasic as ::treesitter_types::FromNode>::from_node(node, src)
9798 .map(Self::PatternExprBasic)
9799 .unwrap_or(Self::Unknown(node))
9800 }
9801 "_pattern_primitive" => {
9802 <PatternPrimitive as ::treesitter_types::FromNode>::from_node(node, src)
9803 .map(Self::PatternPrimitive)
9804 .unwrap_or(Self::Unknown(node))
9805 }
9806 "_pattern_top_expr_body" => {
9807 <PatternTopExprBody as ::treesitter_types::FromNode>::from_node(node, src)
9808 .map(Self::PatternTopExprBody)
9809 .unwrap_or(Self::Unknown(node))
9810 }
9811 "_primary" => <Primary as ::treesitter_types::FromNode>::from_node(node, src)
9812 .map(Self::Primary)
9813 .unwrap_or(Self::Unknown(node)),
9814 "_simple_numeric" => {
9815 <SimpleNumeric as ::treesitter_types::FromNode>::from_node(node, src)
9816 .map(Self::SimpleNumeric)
9817 .unwrap_or(Self::Unknown(node))
9818 }
9819 "_statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
9820 .map(Self::Statement)
9821 .unwrap_or(Self::Unknown(node)),
9822 "_variable" => <Variable as ::treesitter_types::FromNode>::from_node(node, src)
9823 .map(Self::Variable)
9824 .unwrap_or(Self::Unknown(node)),
9825 "alias" => <Alias as ::treesitter_types::FromNode>::from_node(node, src)
9826 .map(Self::Alias)
9827 .unwrap_or(Self::Unknown(node)),
9828 "alternative_pattern" => {
9829 <AlternativePattern as ::treesitter_types::FromNode>::from_node(node, src)
9830 .map(Self::AlternativePattern)
9831 .unwrap_or(Self::Unknown(node))
9832 }
9833 "argument_list" => <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
9834 .map(Self::ArgumentList)
9835 .unwrap_or(Self::Unknown(node)),
9836 "array" => <Array as ::treesitter_types::FromNode>::from_node(node, src)
9837 .map(Self::Array)
9838 .unwrap_or(Self::Unknown(node)),
9839 "array_pattern" => <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
9840 .map(Self::ArrayPattern)
9841 .unwrap_or(Self::Unknown(node)),
9842 "as_pattern" => <AsPattern as ::treesitter_types::FromNode>::from_node(node, src)
9843 .map(Self::AsPattern)
9844 .unwrap_or(Self::Unknown(node)),
9845 "assignment" => <Assignment as ::treesitter_types::FromNode>::from_node(node, src)
9846 .map(Self::Assignment)
9847 .unwrap_or(Self::Unknown(node)),
9848 "bare_string" => <BareString as ::treesitter_types::FromNode>::from_node(node, src)
9849 .map(Self::BareString)
9850 .unwrap_or(Self::Unknown(node)),
9851 "bare_symbol" => <BareSymbol as ::treesitter_types::FromNode>::from_node(node, src)
9852 .map(Self::BareSymbol)
9853 .unwrap_or(Self::Unknown(node)),
9854 "begin" => <Begin as ::treesitter_types::FromNode>::from_node(node, src)
9855 .map(Self::Begin)
9856 .unwrap_or(Self::Unknown(node)),
9857 "begin_block" => <BeginBlock as ::treesitter_types::FromNode>::from_node(node, src)
9858 .map(Self::BeginBlock)
9859 .unwrap_or(Self::Unknown(node)),
9860 "binary" => <Binary as ::treesitter_types::FromNode>::from_node(node, src)
9861 .map(Self::Binary)
9862 .unwrap_or(Self::Unknown(node)),
9863 "block" => <Block as ::treesitter_types::FromNode>::from_node(node, src)
9864 .map(Self::Block)
9865 .unwrap_or(Self::Unknown(node)),
9866 "block_argument" => {
9867 <BlockArgument as ::treesitter_types::FromNode>::from_node(node, src)
9868 .map(Self::BlockArgument)
9869 .unwrap_or(Self::Unknown(node))
9870 }
9871 "block_body" => <BlockBody as ::treesitter_types::FromNode>::from_node(node, src)
9872 .map(Self::BlockBody)
9873 .unwrap_or(Self::Unknown(node)),
9874 "block_parameter" => {
9875 <BlockParameter as ::treesitter_types::FromNode>::from_node(node, src)
9876 .map(Self::BlockParameter)
9877 .unwrap_or(Self::Unknown(node))
9878 }
9879 "block_parameters" => {
9880 <BlockParameters as ::treesitter_types::FromNode>::from_node(node, src)
9881 .map(Self::BlockParameters)
9882 .unwrap_or(Self::Unknown(node))
9883 }
9884 "body_statement" => {
9885 <BodyStatement as ::treesitter_types::FromNode>::from_node(node, src)
9886 .map(Self::BodyStatement)
9887 .unwrap_or(Self::Unknown(node))
9888 }
9889 "break" => <Break as ::treesitter_types::FromNode>::from_node(node, src)
9890 .map(Self::Break)
9891 .unwrap_or(Self::Unknown(node)),
9892 "call" => <Call as ::treesitter_types::FromNode>::from_node(node, src)
9893 .map(Self::Call)
9894 .unwrap_or(Self::Unknown(node)),
9895 "case" => <Case as ::treesitter_types::FromNode>::from_node(node, src)
9896 .map(Self::Case)
9897 .unwrap_or(Self::Unknown(node)),
9898 "case_match" => <CaseMatch as ::treesitter_types::FromNode>::from_node(node, src)
9899 .map(Self::CaseMatch)
9900 .unwrap_or(Self::Unknown(node)),
9901 "chained_string" => {
9902 <ChainedString as ::treesitter_types::FromNode>::from_node(node, src)
9903 .map(Self::ChainedString)
9904 .unwrap_or(Self::Unknown(node))
9905 }
9906 "class" => <Class as ::treesitter_types::FromNode>::from_node(node, src)
9907 .map(Self::Class)
9908 .unwrap_or(Self::Unknown(node)),
9909 "complex" => <Complex as ::treesitter_types::FromNode>::from_node(node, src)
9910 .map(Self::Complex)
9911 .unwrap_or(Self::Unknown(node)),
9912 "conditional" => <Conditional as ::treesitter_types::FromNode>::from_node(node, src)
9913 .map(Self::Conditional)
9914 .unwrap_or(Self::Unknown(node)),
9915 "constant" => <Constant as ::treesitter_types::FromNode>::from_node(node, src)
9916 .map(Self::Constant)
9917 .unwrap_or(Self::Unknown(node)),
9918 "delimited_symbol" => {
9919 <DelimitedSymbol as ::treesitter_types::FromNode>::from_node(node, src)
9920 .map(Self::DelimitedSymbol)
9921 .unwrap_or(Self::Unknown(node))
9922 }
9923 "destructured_left_assignment" => {
9924 <DestructuredLeftAssignment as ::treesitter_types::FromNode>::from_node(node, src)
9925 .map(Self::DestructuredLeftAssignment)
9926 .unwrap_or(Self::Unknown(node))
9927 }
9928 "destructured_parameter" => {
9929 <DestructuredParameter as ::treesitter_types::FromNode>::from_node(node, src)
9930 .map(Self::DestructuredParameter)
9931 .unwrap_or(Self::Unknown(node))
9932 }
9933 "do" => <Do as ::treesitter_types::FromNode>::from_node(node, src)
9934 .map(Self::Do)
9935 .unwrap_or(Self::Unknown(node)),
9936 "do_block" => <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)
9937 .map(Self::DoBlock)
9938 .unwrap_or(Self::Unknown(node)),
9939 "element_reference" => {
9940 <ElementReference as ::treesitter_types::FromNode>::from_node(node, src)
9941 .map(Self::ElementReference)
9942 .unwrap_or(Self::Unknown(node))
9943 }
9944 "else" => <Else as ::treesitter_types::FromNode>::from_node(node, src)
9945 .map(Self::Else)
9946 .unwrap_or(Self::Unknown(node)),
9947 "elsif" => <Elsif as ::treesitter_types::FromNode>::from_node(node, src)
9948 .map(Self::Elsif)
9949 .unwrap_or(Self::Unknown(node)),
9950 "empty_statement" => {
9951 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
9952 .map(Self::EmptyStatement)
9953 .unwrap_or(Self::Unknown(node))
9954 }
9955 "end_block" => <EndBlock as ::treesitter_types::FromNode>::from_node(node, src)
9956 .map(Self::EndBlock)
9957 .unwrap_or(Self::Unknown(node)),
9958 "ensure" => <Ensure as ::treesitter_types::FromNode>::from_node(node, src)
9959 .map(Self::Ensure)
9960 .unwrap_or(Self::Unknown(node)),
9961 "exception_variable" => {
9962 <ExceptionVariable as ::treesitter_types::FromNode>::from_node(node, src)
9963 .map(Self::ExceptionVariable)
9964 .unwrap_or(Self::Unknown(node))
9965 }
9966 "exceptions" => <Exceptions as ::treesitter_types::FromNode>::from_node(node, src)
9967 .map(Self::Exceptions)
9968 .unwrap_or(Self::Unknown(node)),
9969 "expression_reference_pattern" => {
9970 <ExpressionReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)
9971 .map(Self::ExpressionReferencePattern)
9972 .unwrap_or(Self::Unknown(node))
9973 }
9974 "find_pattern" => <FindPattern as ::treesitter_types::FromNode>::from_node(node, src)
9975 .map(Self::FindPattern)
9976 .unwrap_or(Self::Unknown(node)),
9977 "for" => <For as ::treesitter_types::FromNode>::from_node(node, src)
9978 .map(Self::For)
9979 .unwrap_or(Self::Unknown(node)),
9980 "forward_argument" => {
9981 <ForwardArgument as ::treesitter_types::FromNode>::from_node(node, src)
9982 .map(Self::ForwardArgument)
9983 .unwrap_or(Self::Unknown(node))
9984 }
9985 "forward_parameter" => {
9986 <ForwardParameter as ::treesitter_types::FromNode>::from_node(node, src)
9987 .map(Self::ForwardParameter)
9988 .unwrap_or(Self::Unknown(node))
9989 }
9990 "hash" => <Hash as ::treesitter_types::FromNode>::from_node(node, src)
9991 .map(Self::Hash)
9992 .unwrap_or(Self::Unknown(node)),
9993 "hash_key_symbol" => {
9994 <HashKeySymbol as ::treesitter_types::FromNode>::from_node(node, src)
9995 .map(Self::HashKeySymbol)
9996 .unwrap_or(Self::Unknown(node))
9997 }
9998 "hash_pattern" => <HashPattern as ::treesitter_types::FromNode>::from_node(node, src)
9999 .map(Self::HashPattern)
10000 .unwrap_or(Self::Unknown(node)),
10001 "hash_splat_argument" => {
10002 <HashSplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
10003 .map(Self::HashSplatArgument)
10004 .unwrap_or(Self::Unknown(node))
10005 }
10006 "hash_splat_nil" => {
10007 <HashSplatNil as ::treesitter_types::FromNode>::from_node(node, src)
10008 .map(Self::HashSplatNil)
10009 .unwrap_or(Self::Unknown(node))
10010 }
10011 "hash_splat_parameter" => {
10012 <HashSplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
10013 .map(Self::HashSplatParameter)
10014 .unwrap_or(Self::Unknown(node))
10015 }
10016 "heredoc_body" => <HeredocBody as ::treesitter_types::FromNode>::from_node(node, src)
10017 .map(Self::HeredocBody)
10018 .unwrap_or(Self::Unknown(node)),
10019 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10020 .map(Self::Identifier)
10021 .unwrap_or(Self::Unknown(node)),
10022 "if" => <If as ::treesitter_types::FromNode>::from_node(node, src)
10023 .map(Self::If)
10024 .unwrap_or(Self::Unknown(node)),
10025 "if_guard" => <IfGuard as ::treesitter_types::FromNode>::from_node(node, src)
10026 .map(Self::IfGuard)
10027 .unwrap_or(Self::Unknown(node)),
10028 "if_modifier" => <IfModifier as ::treesitter_types::FromNode>::from_node(node, src)
10029 .map(Self::IfModifier)
10030 .unwrap_or(Self::Unknown(node)),
10031 "in" => <In as ::treesitter_types::FromNode>::from_node(node, src)
10032 .map(Self::In)
10033 .unwrap_or(Self::Unknown(node)),
10034 "in_clause" => <InClause as ::treesitter_types::FromNode>::from_node(node, src)
10035 .map(Self::InClause)
10036 .unwrap_or(Self::Unknown(node)),
10037 "interpolation" => {
10038 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
10039 .map(Self::Interpolation)
10040 .unwrap_or(Self::Unknown(node))
10041 }
10042 "keyword_parameter" => {
10043 <KeywordParameter as ::treesitter_types::FromNode>::from_node(node, src)
10044 .map(Self::KeywordParameter)
10045 .unwrap_or(Self::Unknown(node))
10046 }
10047 "keyword_pattern" => {
10048 <KeywordPattern as ::treesitter_types::FromNode>::from_node(node, src)
10049 .map(Self::KeywordPattern)
10050 .unwrap_or(Self::Unknown(node))
10051 }
10052 "lambda" => <Lambda as ::treesitter_types::FromNode>::from_node(node, src)
10053 .map(Self::Lambda)
10054 .unwrap_or(Self::Unknown(node)),
10055 "lambda_parameters" => {
10056 <LambdaParameters as ::treesitter_types::FromNode>::from_node(node, src)
10057 .map(Self::LambdaParameters)
10058 .unwrap_or(Self::Unknown(node))
10059 }
10060 "left_assignment_list" => {
10061 <LeftAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)
10062 .map(Self::LeftAssignmentList)
10063 .unwrap_or(Self::Unknown(node))
10064 }
10065 "match_pattern" => <MatchPattern as ::treesitter_types::FromNode>::from_node(node, src)
10066 .map(Self::MatchPattern)
10067 .unwrap_or(Self::Unknown(node)),
10068 "method" => <Method as ::treesitter_types::FromNode>::from_node(node, src)
10069 .map(Self::Method)
10070 .unwrap_or(Self::Unknown(node)),
10071 "method_parameters" => {
10072 <MethodParameters as ::treesitter_types::FromNode>::from_node(node, src)
10073 .map(Self::MethodParameters)
10074 .unwrap_or(Self::Unknown(node))
10075 }
10076 "module" => <Module as ::treesitter_types::FromNode>::from_node(node, src)
10077 .map(Self::Module)
10078 .unwrap_or(Self::Unknown(node)),
10079 "next" => <Next as ::treesitter_types::FromNode>::from_node(node, src)
10080 .map(Self::Next)
10081 .unwrap_or(Self::Unknown(node)),
10082 "nil" => <Nil as ::treesitter_types::FromNode>::from_node(node, src)
10083 .map(Self::Nil)
10084 .unwrap_or(Self::Unknown(node)),
10085 "operator" => <Operator as ::treesitter_types::FromNode>::from_node(node, src)
10086 .map(Self::Operator)
10087 .unwrap_or(Self::Unknown(node)),
10088 "operator_assignment" => {
10089 <OperatorAssignment as ::treesitter_types::FromNode>::from_node(node, src)
10090 .map(Self::OperatorAssignment)
10091 .unwrap_or(Self::Unknown(node))
10092 }
10093 "optional_parameter" => {
10094 <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)
10095 .map(Self::OptionalParameter)
10096 .unwrap_or(Self::Unknown(node))
10097 }
10098 "pair" => <Pair as ::treesitter_types::FromNode>::from_node(node, src)
10099 .map(Self::Pair)
10100 .unwrap_or(Self::Unknown(node)),
10101 "parenthesized_pattern" => {
10102 <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)
10103 .map(Self::ParenthesizedPattern)
10104 .unwrap_or(Self::Unknown(node))
10105 }
10106 "parenthesized_statements" => {
10107 <ParenthesizedStatements as ::treesitter_types::FromNode>::from_node(node, src)
10108 .map(Self::ParenthesizedStatements)
10109 .unwrap_or(Self::Unknown(node))
10110 }
10111 "pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
10112 .map(Self::Pattern)
10113 .unwrap_or(Self::Unknown(node)),
10114 "program" => <Program as ::treesitter_types::FromNode>::from_node(node, src)
10115 .map(Self::Program)
10116 .unwrap_or(Self::Unknown(node)),
10117 "range" => <Range as ::treesitter_types::FromNode>::from_node(node, src)
10118 .map(Self::Range)
10119 .unwrap_or(Self::Unknown(node)),
10120 "rational" => <Rational as ::treesitter_types::FromNode>::from_node(node, src)
10121 .map(Self::Rational)
10122 .unwrap_or(Self::Unknown(node)),
10123 "redo" => <Redo as ::treesitter_types::FromNode>::from_node(node, src)
10124 .map(Self::Redo)
10125 .unwrap_or(Self::Unknown(node)),
10126 "regex" => <Regex as ::treesitter_types::FromNode>::from_node(node, src)
10127 .map(Self::Regex)
10128 .unwrap_or(Self::Unknown(node)),
10129 "rescue" => <Rescue as ::treesitter_types::FromNode>::from_node(node, src)
10130 .map(Self::Rescue)
10131 .unwrap_or(Self::Unknown(node)),
10132 "rescue_modifier" => {
10133 <RescueModifier as ::treesitter_types::FromNode>::from_node(node, src)
10134 .map(Self::RescueModifier)
10135 .unwrap_or(Self::Unknown(node))
10136 }
10137 "rest_assignment" => {
10138 <RestAssignment as ::treesitter_types::FromNode>::from_node(node, src)
10139 .map(Self::RestAssignment)
10140 .unwrap_or(Self::Unknown(node))
10141 }
10142 "retry" => <Retry as ::treesitter_types::FromNode>::from_node(node, src)
10143 .map(Self::Retry)
10144 .unwrap_or(Self::Unknown(node)),
10145 "return" => <Return as ::treesitter_types::FromNode>::from_node(node, src)
10146 .map(Self::Return)
10147 .unwrap_or(Self::Unknown(node)),
10148 "right_assignment_list" => {
10149 <RightAssignmentList as ::treesitter_types::FromNode>::from_node(node, src)
10150 .map(Self::RightAssignmentList)
10151 .unwrap_or(Self::Unknown(node))
10152 }
10153 "scope_resolution" => {
10154 <ScopeResolution as ::treesitter_types::FromNode>::from_node(node, src)
10155 .map(Self::ScopeResolution)
10156 .unwrap_or(Self::Unknown(node))
10157 }
10158 "setter" => <Setter as ::treesitter_types::FromNode>::from_node(node, src)
10159 .map(Self::Setter)
10160 .unwrap_or(Self::Unknown(node)),
10161 "singleton_class" => {
10162 <SingletonClass as ::treesitter_types::FromNode>::from_node(node, src)
10163 .map(Self::SingletonClass)
10164 .unwrap_or(Self::Unknown(node))
10165 }
10166 "singleton_method" => {
10167 <SingletonMethod as ::treesitter_types::FromNode>::from_node(node, src)
10168 .map(Self::SingletonMethod)
10169 .unwrap_or(Self::Unknown(node))
10170 }
10171 "splat_argument" => {
10172 <SplatArgument as ::treesitter_types::FromNode>::from_node(node, src)
10173 .map(Self::SplatArgument)
10174 .unwrap_or(Self::Unknown(node))
10175 }
10176 "splat_parameter" => {
10177 <SplatParameter as ::treesitter_types::FromNode>::from_node(node, src)
10178 .map(Self::SplatParameter)
10179 .unwrap_or(Self::Unknown(node))
10180 }
10181 "string" => <String as ::treesitter_types::FromNode>::from_node(node, src)
10182 .map(Self::String)
10183 .unwrap_or(Self::Unknown(node)),
10184 "string_array" => <StringArray as ::treesitter_types::FromNode>::from_node(node, src)
10185 .map(Self::StringArray)
10186 .unwrap_or(Self::Unknown(node)),
10187 "subshell" => <Subshell as ::treesitter_types::FromNode>::from_node(node, src)
10188 .map(Self::Subshell)
10189 .unwrap_or(Self::Unknown(node)),
10190 "superclass" => <Superclass as ::treesitter_types::FromNode>::from_node(node, src)
10191 .map(Self::Superclass)
10192 .unwrap_or(Self::Unknown(node)),
10193 "symbol_array" => <SymbolArray as ::treesitter_types::FromNode>::from_node(node, src)
10194 .map(Self::SymbolArray)
10195 .unwrap_or(Self::Unknown(node)),
10196 "test_pattern" => <TestPattern as ::treesitter_types::FromNode>::from_node(node, src)
10197 .map(Self::TestPattern)
10198 .unwrap_or(Self::Unknown(node)),
10199 "then" => <Then as ::treesitter_types::FromNode>::from_node(node, src)
10200 .map(Self::Then)
10201 .unwrap_or(Self::Unknown(node)),
10202 "unary" => <Unary as ::treesitter_types::FromNode>::from_node(node, src)
10203 .map(Self::Unary)
10204 .unwrap_or(Self::Unknown(node)),
10205 "undef" => <Undef as ::treesitter_types::FromNode>::from_node(node, src)
10206 .map(Self::Undef)
10207 .unwrap_or(Self::Unknown(node)),
10208 "unless" => <Unless as ::treesitter_types::FromNode>::from_node(node, src)
10209 .map(Self::Unless)
10210 .unwrap_or(Self::Unknown(node)),
10211 "unless_guard" => <UnlessGuard as ::treesitter_types::FromNode>::from_node(node, src)
10212 .map(Self::UnlessGuard)
10213 .unwrap_or(Self::Unknown(node)),
10214 "unless_modifier" => {
10215 <UnlessModifier as ::treesitter_types::FromNode>::from_node(node, src)
10216 .map(Self::UnlessModifier)
10217 .unwrap_or(Self::Unknown(node))
10218 }
10219 "until" => <Until as ::treesitter_types::FromNode>::from_node(node, src)
10220 .map(Self::Until)
10221 .unwrap_or(Self::Unknown(node)),
10222 "until_modifier" => {
10223 <UntilModifier as ::treesitter_types::FromNode>::from_node(node, src)
10224 .map(Self::UntilModifier)
10225 .unwrap_or(Self::Unknown(node))
10226 }
10227 "variable_reference_pattern" => {
10228 <VariableReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)
10229 .map(Self::VariableReferencePattern)
10230 .unwrap_or(Self::Unknown(node))
10231 }
10232 "when" => <When as ::treesitter_types::FromNode>::from_node(node, src)
10233 .map(Self::When)
10234 .unwrap_or(Self::Unknown(node)),
10235 "while" => <While as ::treesitter_types::FromNode>::from_node(node, src)
10236 .map(Self::While)
10237 .unwrap_or(Self::Unknown(node)),
10238 "while_modifier" => {
10239 <WhileModifier as ::treesitter_types::FromNode>::from_node(node, src)
10240 .map(Self::WhileModifier)
10241 .unwrap_or(Self::Unknown(node))
10242 }
10243 "yield" => <Yield as ::treesitter_types::FromNode>::from_node(node, src)
10244 .map(Self::Yield)
10245 .unwrap_or(Self::Unknown(node)),
10246 "character" => <Character as ::treesitter_types::FromNode>::from_node(node, src)
10247 .map(Self::Character)
10248 .unwrap_or(Self::Unknown(node)),
10249 "class_variable" => {
10250 <ClassVariable as ::treesitter_types::FromNode>::from_node(node, src)
10251 .map(Self::ClassVariable)
10252 .unwrap_or(Self::Unknown(node))
10253 }
10254 "comment" => <Comment as ::treesitter_types::FromNode>::from_node(node, src)
10255 .map(Self::Comment)
10256 .unwrap_or(Self::Unknown(node)),
10257 "encoding" => <Encoding as ::treesitter_types::FromNode>::from_node(node, src)
10258 .map(Self::Encoding)
10259 .unwrap_or(Self::Unknown(node)),
10260 "escape_sequence" => {
10261 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
10262 .map(Self::EscapeSequence)
10263 .unwrap_or(Self::Unknown(node))
10264 }
10265 "false" => <False as ::treesitter_types::FromNode>::from_node(node, src)
10266 .map(Self::False)
10267 .unwrap_or(Self::Unknown(node)),
10268 "file" => <File as ::treesitter_types::FromNode>::from_node(node, src)
10269 .map(Self::File)
10270 .unwrap_or(Self::Unknown(node)),
10271 "float" => <Float as ::treesitter_types::FromNode>::from_node(node, src)
10272 .map(Self::Float)
10273 .unwrap_or(Self::Unknown(node)),
10274 "global_variable" => {
10275 <GlobalVariable as ::treesitter_types::FromNode>::from_node(node, src)
10276 .map(Self::GlobalVariable)
10277 .unwrap_or(Self::Unknown(node))
10278 }
10279 "heredoc_beginning" => {
10280 <HeredocBeginning as ::treesitter_types::FromNode>::from_node(node, src)
10281 .map(Self::HeredocBeginning)
10282 .unwrap_or(Self::Unknown(node))
10283 }
10284 "heredoc_content" => {
10285 <HeredocContent as ::treesitter_types::FromNode>::from_node(node, src)
10286 .map(Self::HeredocContent)
10287 .unwrap_or(Self::Unknown(node))
10288 }
10289 "heredoc_end" => <HeredocEnd as ::treesitter_types::FromNode>::from_node(node, src)
10290 .map(Self::HeredocEnd)
10291 .unwrap_or(Self::Unknown(node)),
10292 "instance_variable" => {
10293 <InstanceVariable as ::treesitter_types::FromNode>::from_node(node, src)
10294 .map(Self::InstanceVariable)
10295 .unwrap_or(Self::Unknown(node))
10296 }
10297 "integer" => <Integer as ::treesitter_types::FromNode>::from_node(node, src)
10298 .map(Self::Integer)
10299 .unwrap_or(Self::Unknown(node)),
10300 "line" => <Line as ::treesitter_types::FromNode>::from_node(node, src)
10301 .map(Self::Line)
10302 .unwrap_or(Self::Unknown(node)),
10303 "self" => <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
10304 .map(Self::SelfType)
10305 .unwrap_or(Self::Unknown(node)),
10306 "simple_symbol" => <SimpleSymbol as ::treesitter_types::FromNode>::from_node(node, src)
10307 .map(Self::SimpleSymbol)
10308 .unwrap_or(Self::Unknown(node)),
10309 "string_content" => {
10310 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
10311 .map(Self::StringContent)
10312 .unwrap_or(Self::Unknown(node))
10313 }
10314 "super" => <Super as ::treesitter_types::FromNode>::from_node(node, src)
10315 .map(Self::Super)
10316 .unwrap_or(Self::Unknown(node)),
10317 "true" => <True as ::treesitter_types::FromNode>::from_node(node, src)
10318 .map(Self::True)
10319 .unwrap_or(Self::Unknown(node)),
10320 "uninterpreted" => {
10321 <Uninterpreted as ::treesitter_types::FromNode>::from_node(node, src)
10322 .map(Self::Uninterpreted)
10323 .unwrap_or(Self::Unknown(node))
10324 }
10325 _ => Self::Unknown(node),
10326 }
10327 }
10328}
10329impl ::treesitter_types::Spanned for AnyNode<'_> {
10330 fn span(&self) -> ::treesitter_types::Span {
10331 match self {
10332 Self::Arg(inner) => inner.span(),
10333 Self::CallOperator(inner) => inner.span(),
10334 Self::Expression(inner) => inner.span(),
10335 Self::Lhs(inner) => inner.span(),
10336 Self::MethodName(inner) => inner.span(),
10337 Self::NonlocalVariable(inner) => inner.span(),
10338 Self::PatternConstant(inner) => inner.span(),
10339 Self::PatternExpr(inner) => inner.span(),
10340 Self::PatternExprBasic(inner) => inner.span(),
10341 Self::PatternPrimitive(inner) => inner.span(),
10342 Self::PatternTopExprBody(inner) => inner.span(),
10343 Self::Primary(inner) => inner.span(),
10344 Self::SimpleNumeric(inner) => inner.span(),
10345 Self::Statement(inner) => inner.span(),
10346 Self::Variable(inner) => inner.span(),
10347 Self::Alias(inner) => inner.span(),
10348 Self::AlternativePattern(inner) => inner.span(),
10349 Self::ArgumentList(inner) => inner.span(),
10350 Self::Array(inner) => inner.span(),
10351 Self::ArrayPattern(inner) => inner.span(),
10352 Self::AsPattern(inner) => inner.span(),
10353 Self::Assignment(inner) => inner.span(),
10354 Self::BareString(inner) => inner.span(),
10355 Self::BareSymbol(inner) => inner.span(),
10356 Self::Begin(inner) => inner.span(),
10357 Self::BeginBlock(inner) => inner.span(),
10358 Self::Binary(inner) => inner.span(),
10359 Self::Block(inner) => inner.span(),
10360 Self::BlockArgument(inner) => inner.span(),
10361 Self::BlockBody(inner) => inner.span(),
10362 Self::BlockParameter(inner) => inner.span(),
10363 Self::BlockParameters(inner) => inner.span(),
10364 Self::BodyStatement(inner) => inner.span(),
10365 Self::Break(inner) => inner.span(),
10366 Self::Call(inner) => inner.span(),
10367 Self::Case(inner) => inner.span(),
10368 Self::CaseMatch(inner) => inner.span(),
10369 Self::ChainedString(inner) => inner.span(),
10370 Self::Class(inner) => inner.span(),
10371 Self::Complex(inner) => inner.span(),
10372 Self::Conditional(inner) => inner.span(),
10373 Self::Constant(inner) => inner.span(),
10374 Self::DelimitedSymbol(inner) => inner.span(),
10375 Self::DestructuredLeftAssignment(inner) => inner.span(),
10376 Self::DestructuredParameter(inner) => inner.span(),
10377 Self::Do(inner) => inner.span(),
10378 Self::DoBlock(inner) => inner.span(),
10379 Self::ElementReference(inner) => inner.span(),
10380 Self::Else(inner) => inner.span(),
10381 Self::Elsif(inner) => inner.span(),
10382 Self::EmptyStatement(inner) => inner.span(),
10383 Self::EndBlock(inner) => inner.span(),
10384 Self::Ensure(inner) => inner.span(),
10385 Self::ExceptionVariable(inner) => inner.span(),
10386 Self::Exceptions(inner) => inner.span(),
10387 Self::ExpressionReferencePattern(inner) => inner.span(),
10388 Self::FindPattern(inner) => inner.span(),
10389 Self::For(inner) => inner.span(),
10390 Self::ForwardArgument(inner) => inner.span(),
10391 Self::ForwardParameter(inner) => inner.span(),
10392 Self::Hash(inner) => inner.span(),
10393 Self::HashKeySymbol(inner) => inner.span(),
10394 Self::HashPattern(inner) => inner.span(),
10395 Self::HashSplatArgument(inner) => inner.span(),
10396 Self::HashSplatNil(inner) => inner.span(),
10397 Self::HashSplatParameter(inner) => inner.span(),
10398 Self::HeredocBody(inner) => inner.span(),
10399 Self::Identifier(inner) => inner.span(),
10400 Self::If(inner) => inner.span(),
10401 Self::IfGuard(inner) => inner.span(),
10402 Self::IfModifier(inner) => inner.span(),
10403 Self::In(inner) => inner.span(),
10404 Self::InClause(inner) => inner.span(),
10405 Self::Interpolation(inner) => inner.span(),
10406 Self::KeywordParameter(inner) => inner.span(),
10407 Self::KeywordPattern(inner) => inner.span(),
10408 Self::Lambda(inner) => inner.span(),
10409 Self::LambdaParameters(inner) => inner.span(),
10410 Self::LeftAssignmentList(inner) => inner.span(),
10411 Self::MatchPattern(inner) => inner.span(),
10412 Self::Method(inner) => inner.span(),
10413 Self::MethodParameters(inner) => inner.span(),
10414 Self::Module(inner) => inner.span(),
10415 Self::Next(inner) => inner.span(),
10416 Self::Nil(inner) => inner.span(),
10417 Self::Operator(inner) => inner.span(),
10418 Self::OperatorAssignment(inner) => inner.span(),
10419 Self::OptionalParameter(inner) => inner.span(),
10420 Self::Pair(inner) => inner.span(),
10421 Self::ParenthesizedPattern(inner) => inner.span(),
10422 Self::ParenthesizedStatements(inner) => inner.span(),
10423 Self::Pattern(inner) => inner.span(),
10424 Self::Program(inner) => inner.span(),
10425 Self::Range(inner) => inner.span(),
10426 Self::Rational(inner) => inner.span(),
10427 Self::Redo(inner) => inner.span(),
10428 Self::Regex(inner) => inner.span(),
10429 Self::Rescue(inner) => inner.span(),
10430 Self::RescueModifier(inner) => inner.span(),
10431 Self::RestAssignment(inner) => inner.span(),
10432 Self::Retry(inner) => inner.span(),
10433 Self::Return(inner) => inner.span(),
10434 Self::RightAssignmentList(inner) => inner.span(),
10435 Self::ScopeResolution(inner) => inner.span(),
10436 Self::Setter(inner) => inner.span(),
10437 Self::SingletonClass(inner) => inner.span(),
10438 Self::SingletonMethod(inner) => inner.span(),
10439 Self::SplatArgument(inner) => inner.span(),
10440 Self::SplatParameter(inner) => inner.span(),
10441 Self::String(inner) => inner.span(),
10442 Self::StringArray(inner) => inner.span(),
10443 Self::Subshell(inner) => inner.span(),
10444 Self::Superclass(inner) => inner.span(),
10445 Self::SymbolArray(inner) => inner.span(),
10446 Self::TestPattern(inner) => inner.span(),
10447 Self::Then(inner) => inner.span(),
10448 Self::Unary(inner) => inner.span(),
10449 Self::Undef(inner) => inner.span(),
10450 Self::Unless(inner) => inner.span(),
10451 Self::UnlessGuard(inner) => inner.span(),
10452 Self::UnlessModifier(inner) => inner.span(),
10453 Self::Until(inner) => inner.span(),
10454 Self::UntilModifier(inner) => inner.span(),
10455 Self::VariableReferencePattern(inner) => inner.span(),
10456 Self::When(inner) => inner.span(),
10457 Self::While(inner) => inner.span(),
10458 Self::WhileModifier(inner) => inner.span(),
10459 Self::Yield(inner) => inner.span(),
10460 Self::Character(inner) => inner.span(),
10461 Self::ClassVariable(inner) => inner.span(),
10462 Self::Comment(inner) => inner.span(),
10463 Self::Encoding(inner) => inner.span(),
10464 Self::EscapeSequence(inner) => inner.span(),
10465 Self::False(inner) => inner.span(),
10466 Self::File(inner) => inner.span(),
10467 Self::Float(inner) => inner.span(),
10468 Self::GlobalVariable(inner) => inner.span(),
10469 Self::HeredocBeginning(inner) => inner.span(),
10470 Self::HeredocContent(inner) => inner.span(),
10471 Self::HeredocEnd(inner) => inner.span(),
10472 Self::InstanceVariable(inner) => inner.span(),
10473 Self::Integer(inner) => inner.span(),
10474 Self::Line(inner) => inner.span(),
10475 Self::SelfType(inner) => inner.span(),
10476 Self::SimpleSymbol(inner) => inner.span(),
10477 Self::StringContent(inner) => inner.span(),
10478 Self::Super(inner) => inner.span(),
10479 Self::True(inner) => inner.span(),
10480 Self::Uninterpreted(inner) => inner.span(),
10481 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
10482 }
10483 }
10484}